Initial commit

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.github/workflows/space.yml

@@ -0,0 +1,45 @@
+name: Bump requirements.txt  # bump requirements.txt (to force reinstall in space), run tests, push to HF hub
+
+on:
+  schedule:
+    - cron: '0 05 * * *'   # daily at 05:00 UTC
+  workflow_dispatch:
+
+jobs:
+  update-and-sync:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+          token: ${{ secrets.GH_TOKEN }}
+      - name: Setup Python 3.12
+        uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Add timestamp 
+        run: |
+          python - <<'PY'
+          import datetime
+          with open("requirements.txt", "r", encoding="utf-8") as f:
+              req_content = f.read()
+          lines = [line for line in req_content.splitlines() if not line.startswith("# bumped:")]
+          ts = datetime.datetime.utcnow().strftime("%Y-%m-%dT%H:%M:%SZ")
+          lines.append(f"# bumped: {ts}")
+          new_req = "\n".join(lines) + "\n"
+          with open("requirements.txt", "w", encoding="utf-8") as f:
+              f.write(new_req)
+          PY
+          git config user.name "github-actions[bot]"
+          git config user.email "41898282+github-actions[bot]@users.noreply.github.com"
+          git add requirements.txt
+          git commit -m "ci: bump timestamp to trigger deps reinstall"
+          git push origin HEAD:main
+      - name: Install requirements
+        run: pip install -r requirements.txt
+      - name: Run test
+        run: python -m pytest test_optimum_support.py
+      - name: Push to hub
+        env:
+          HF_TOKEN: ${{ secrets.HF_TOKEN }}
+        run: git push https://helenai:[email protected]/spaces/helenai/check-optimum-intel-support main

README.md

@@ -0,0 +1,12 @@
+---
+title: Check Optimum Intel Support
+emoji: 🌖
+colorFrom: gray
+colorTo: red
+sdk: gradio
+sdk_version: 6.0.2
+app_file: app.py
+pinned: false
+short_description: Check if a model is supported by optimum-intel[openvino]
+---
+

app.py

@@ -0,0 +1,19 @@
+import importlib.metadata
+import gradio as gr
+from optimum_support import show_is_supported
+
+with gr.Blocks() as app:
+    gr.Markdown("# Check if model is supported by optimum-intel[openvino]")
+    with gr.Column():
+        model_id = gr.Textbox(label="model_id")
+        process_button = gr.Button("Check")
+        output_text = gr.Markdown(label="result", height=100)
+        optimum_intel_version = importlib.metadata.version("optimum-intel")
+        gr.Markdown(
+            f"Tested with optimum-intel {optimum_intel_version}. For testing purposes only, results may be wrong."
+        )
+
+    process_button.click(show_is_supported, inputs=[model_id], outputs=output_text)
+    model_id.submit(show_is_supported, inputs=[model_id], outputs=output_text)
+
+app.launch()

optimum_support.py

@@ -0,0 +1,109 @@
+import importlib.metadata
+import inspect
+import re
+import subprocess
+import sys
+from importlib import reload
+from pathlib import Path
+
+import optimum.intel.utils.import_utils as import_utils
+from huggingface_hub import HfApi
+from huggingface_hub.errors import RepositoryNotFoundError
+from packaging.requirements import Requirement
+
+if Path("optimum-intel").is_dir():
+    subprocess.run(["git", "pull"], cwd="optimum-intel")
+else:
+    subprocess.run(["git", "clone", "https://github.com/huggingface/optimum-intel.git"])
+test_path = Path(__file__).parent / "optimum-intel" / "tests" / "openvino"
+sys.path.append(str(test_path))
+
+# Stable Diffusion does not have a model_type in the config
+# Get supported diffusion classes from SUPPORTED_OV_PIPELINES, which lists all OV pipeline wrappers
+import optimum.intel.openvino.modeling_diffusion as _modeling_diffusion
+# Import the test modules from the cloned repository. This must be imported globally to avoid issues with reloading in Gradio
+import test_decoder
+import test_diffusion
+import test_modeling
+import test_seq2seq
+
+SUPPORTED_DIFFUSION_CLASSES = [
+    cls.auto_model_class.__name__
+    for cls in _modeling_diffusion.SUPPORTED_OV_PIPELINES
+    if hasattr(cls, "auto_model_class") and cls.auto_model_class is not None
+]
+
+
+def get_supported_models_for_version(version):
+    import_utils._transformers_version = version
+    test_seq2seq._transformers_version = version
+    test_modeling._transformers_version = version
+    test_diffusion._transformers_version = version
+    test_decoder._transformers_version = version
+
+    seq2seq = reload(test_seq2seq)
+    decoder = reload(test_decoder)
+    modeling = reload(test_modeling)
+    diffusion = reload(test_diffusion)
+
+    d = {}
+    modules = [seq2seq, decoder, modeling, diffusion]
+    for mod in modules:
+        for name, obj in inspect.getmembers(mod):
+            if inspect.isclass(obj):
+                if re.match(r"(OVModelFor.*IntegrationTest)", name) or re.match(r"(OVPipelineFor.*Test)", name):
+                    task = name.replace("IntegrationTest", "").replace("Test", "")
+                    if "CustomTasks" not in task:
+                        d[task] = obj.SUPPORTED_ARCHITECTURES
+    all_archs = []
+    for archs in d.values():
+        all_archs += archs
+    return sorted(set(all_archs))
+
+
+def get_min_max_transformers():
+    meta = importlib.metadata.metadata("optimum-intel")
+    requires = meta.get_all("Requires-Dist") or []
+    transformers_versions = [item for item in requires if "transformers" in item and "extra" not in item][0]
+    req = Requirement(transformers_versions)
+    maxver, minver = [ver.version for ver in list(req.specifier)]
+    return (minver, maxver)
+
+
+def show_is_supported(model_id):
+    print(f"Checking {model_id}...")
+    minver, maxver = get_min_max_transformers()
+    versions = [minver, "4.53.0", maxver]
+
+    all_supported_models = set()
+    for v in versions:
+        archs = get_supported_models_for_version(v)
+        all_supported_models.update(archs)
+    try:
+        model_info = HfApi().model_info(model_id)
+    except RepositoryNotFoundError:
+        message = f"Model {model_id} was not found on the Hugging Face hub. Make sure you entered the correct model_id. If the model requires authentication, use `hf auth login` or a token to authenticate."
+    else:
+        if (model_info.config is not None) and model_info.config != {}:
+            model_type = model_info.config.get("model_type")
+            if model_type is None:  # Check for diffusion class if model_type is not available
+                class_name = model_info.config.get("diffusers", {}).get("_class_name")
+                if class_name in SUPPORTED_DIFFUSION_CLASSES:
+                    message = (
+                        f"`{model_id}` with diffusion class `{class_name}` is **supported** by optimum-intel[openvino]."
+                    )
+                else:
+                    message = f"`{model_id}` is not in the list of supported architectures by optimum-intel[openvino]. It is **likely not supported**, but it is wise to doublecheck"
+            elif model_type in all_supported_models:
+                message = f"`{model_id}` with model type `{model_type}` is **supported** by optimum-intel[openvino]."
+            else:
+                message = f"`{model_id}` with model type `{model_type}` is not in the list of supported architectures by optimum-intel[openvino]. It is **likely not supported**, but it is wise to doublecheck"
+        else:
+            message = f"`{model_id}` is **not supported** by optimum-intel[openvino]."
+    print(f"Using transformers: {versions}. Total number of supported architectures: {len(all_supported_models)}")
+    print(message)
+    return message
+
+
+if __name__ == "__main__":
+    show_is_supported(sys.argv[1])

requirements.txt

@@ -0,0 +1,5 @@
+--extra-index-url "https://download.pytorch.org/whl/cpu"
+optimum-intel[tests,openvino,diffusers]@git+https://github.com/huggingface/optimum-intel
+packaging
+huggingface-hub
+# bumped: 2025-12-03T11:57:13Z

test_optimum_support.py

@@ -0,0 +1,31 @@
+import pytest
+
+from optimum_support import show_is_supported
+
+# (model_id, expected_substring)
+test_cases = [
+    ("openai/whisper-small", "is **supported**"),
+    ("Ultralytics/YOLO11", "is **not supported**"),
+    ("test/non-existing", "was not found on the Hugging Face hub"),
+    ("openai/gpt-oss-20b", "is **supported**"),
+    ("ibm-granite/granite-3.1-8b-instruct", "is **supported**"),
+    ("stabilityai/stable-diffusion-xl-base-1.0", "is **supported**"),
+    ("microsoft/Phi-4-multimodal-instruct", "is **supported**"),
+    ("google-bert/bert-base-uncased", "is **supported**"),
+    ("rednote-hilab/dots.ocr", "is not in the list of supported architectures"),
+    ("LiquidAI/LFM2-350M", "is **supported**"),
+    ("google/mobilenet_v2_1.0_224", "is **supported**"),
+    ("stabilityai/stable-diffusion-3.5-large", "is **supported**"),
+    ("stabilityai/sp4d", "is **not supported**"),
+    ("SimianLuo/LCM_Dreamshaper_v7", "is **supported**"),
+    ("stabilityai/sd-x2-latent-upscaler", "is not in the list"),
+    ("openbmb/MiniCPM3-4B", "is **supported**"),
+    ("Efficient-Large-Model/SANA-Video_2B_480p", "is **not supported**"),
+    ("optimum-intel-internal-testing/tiny-random-sana-sprint", "is **supported**"),
+]
+
+
+@pytest.mark.parametrize("model_id,expected", test_cases)
+def test_show_is_supported(model_id, expected):
+    result = show_is_supported(model_id)
+    assert expected in result, f"For {model_id}, expected '{expected}' in result, got: {result}"