added files

.gitignore

@@ -0,0 +1 @@
+.env

Dockerfile

@@ -0,0 +1,31 @@
+FROM python:3.12-slim
+
+ENV PORT=8501
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    git \
+    git-lfs \
+    cmake \
+    build-essential \
+    curl \
+    && rm -rf /var/lib/apt/lists/* \
+    && git lfs install
+
+WORKDIR /app
+
+ARG TRANSFORMERS_JS_VERSION=3.8.1
+RUN curl -L "https://github.com/huggingface/transformers.js/archive/refs/tags/${TRANSFORMERS_JS_VERSION}.tar.gz" -o transformers.tar.gz \
+    && tar -xzf transformers.tar.gz \
+    && mv "transformers.js-${TRANSFORMERS_JS_VERSION}" transformers.js \
+    && pip install --no-cache-dir -r "transformers.js/scripts/requirements.txt" \
+    && rm -rf transformers.tar.gz
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -U pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+EXPOSE $PORT
+
+CMD ["sh", "-c", "streamlit run app.py --server.port $PORT --server.address 0.0.0.0"]

README.md

@@ -1,13 +1,75 @@
 ---
-title: Convert Onnx V2
-emoji: ⚡
-colorFrom: red
-colorTo: green
-sdk: gradio
-sdk_version: 6.5.1
-app_file: app.py
-pinned: false
-license: mit
+title: Convert to ONNX
+emoji: ☯
+colorFrom: indigo
+colorTo: yellow
+sdk: docker
+app_port: 8501
+pinned: true
+license: apache-2.0
+short_description: Convert a Hugging Face model to ONNX format
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Convert to ONNX
+
+## Overview
+
+This project provides a Streamlit application that facilitates the conversion of Hugging Face models to ONNX format, downloading, converting, and uploading models to Hugging Face.
+
+## Docker Compose usage
+
+### 1. Prepare environment variables
+
+Copy the provided template and fill in your Hugging Face write token:
+
+```bash
+cp .env.example .env
+```
+
+### 2. Start the application
+
+```bash
+docker compose up
+```
+
+Access the interface at `http://localhost:8501`.
+
+Enter a Hugging Face model ID (e.g., `EleutherAI/pythia-14m`).
+
+After a successful conversion, the ONNX export is available under `{username}/{model-name}-ONNX` unless you opt into reusing the same repository.
+
+To stop the service, press `Ctrl+C` (or run `docker compose down`). Add `-d` to run detached.
+
+## Direct Docker usage (optional)
+
+If you prefer not to use Docker Compose, you can still build and run manually:
+
+```bash
+docker build -t convert-to-onnx .
+
+docker run --rm \
+  -p 8501:8501 \
+  -e HF_TOKEN="your_write_token" \
+  convert-to-onnx
+```
+
+## Development
+
+### Contributing
+
+1. Fork the repository
+2. Create a feature branch
+3. Implement changes with tests
+4. Submit a pull request
+
+## Troubleshooting
+
+Common issues and solutions:
+
+- **Authentication Errors**: Verify your Hugging Face credentials
+- **Conversion Failures**: Check model compatibility and available disk space
+- **Upload Issues**: Ensure stable internet connection and valid permissions
+
+## License
+
+[Apache 2.0 License](license.txt)

app.py

@@ -0,0 +1,609 @@
+"""Convert Hugging Face models to ONNX format.
+
+This application provides a Streamlit interface for converting Hugging Face models
+to ONNX format using the Transformers.js conversion scripts. It handles:
+- Model conversion with optional trust_remote_code and output_attentions
+- Automatic task inference with fallback support
+- README generation with merged metadata from the original model
+- Upload to Hugging Face Hub
+"""
+
+import logging
+import os
+import re
+import shutil
+import subprocess
+import sys
+from dataclasses import dataclass
+from pathlib import Path
+from typing import List, Optional, Tuple
+
+import streamlit as st
+import yaml
+from huggingface_hub import HfApi, hf_hub_download, model_info, whoami
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Config:
+    """Application configuration containing authentication and path settings.
+
+    Attributes:
+        hf_token: Hugging Face API token (user token takes precedence over system token)
+        hf_username: Hugging Face username associated with the token
+        is_using_user_token: True if using a user-provided token, False if using system token
+        hf_base_url: Base URL for Hugging Face Hub
+        repo_path: Path to the bundled transformers.js repository
+    """
+
+    hf_token: str
+    hf_username: str
+    is_using_user_token: bool
+    hf_base_url: str = "https://huggingface.co"
+    repo_path: Path = Path("./transformers.js")
+
+    @classmethod
+    def from_env(cls) -> "Config":
+        """Create configuration from environment variables and Streamlit session state.
+
+        Priority order for tokens:
+        1. User-provided token from Streamlit session (st.session_state.user_hf_token)
+        2. System token from environment variable (HF_TOKEN)
+
+        Returns:
+            Config: Initialized configuration object
+
+        Raises:
+            ValueError: If no valid token is available
+        """
+        system_token = os.getenv("HF_TOKEN")
+        user_token = st.session_state.get("user_hf_token")
+
+        # Determine username based on which token is being used
+        if user_token:
+            hf_username = whoami(token=user_token)["name"]
+        else:
+            hf_username = (
+                os.getenv("SPACE_AUTHOR_NAME") or whoami(token=system_token)["name"]
+            )
+
+        # User token takes precedence over system token
+        hf_token = user_token or system_token
+
+        if not hf_token:
+            raise ValueError(
+                "When the user token is not provided, the system token must be set."
+            )
+
+        return cls(
+            hf_token=hf_token,
+            hf_username=hf_username,
+            is_using_user_token=bool(user_token),
+        )
+
+
+class ModelConverter:
+    """Handles model conversion to ONNX format and upload to Hugging Face Hub.
+
+    This class manages the entire conversion workflow:
+    1. Fetching original model metadata and README
+    2. Running the ONNX conversion subprocess
+    3. Generating an enhanced README with merged metadata
+    4. Uploading the converted model to Hugging Face Hub
+
+    Attributes:
+        config: Application configuration containing tokens and paths
+        api: Hugging Face API client for repository operations
+    """
+
+    def __init__(self, config: Config):
+        """Initialize the converter with configuration.
+
+        Args:
+            config: Application configuration object
+        """
+        self.config = config
+        self.api = HfApi(token=config.hf_token)
+
+    # ============================================================================
+    # README Processing Methods
+    # ============================================================================
+
+    def _fetch_original_readme(self, repo_id: str) -> str:
+        """Download the README from the original model repository.
+
+        Args:
+            repo_id: Hugging Face model repository ID (e.g., 'username/model-name')
+
+        Returns:
+            str: Content of the README file, or empty string if not found
+        """
+        try:
+            readme_path = hf_hub_download(
+                repo_id=repo_id, filename="README.md", token=self.config.hf_token
+            )
+            with open(readme_path, "r", encoding="utf-8", errors="ignore") as f:
+                return f.read()
+        except Exception:
+            # Silently fail if README doesn't exist or can't be downloaded
+            return ""
+
+    def _strip_yaml_frontmatter(self, text: str) -> str:
+        """Remove YAML frontmatter from text, returning only the body.
+
+        YAML frontmatter is delimited by '---' at the start and end.
+
+        Args:
+            text: Text that may contain YAML frontmatter
+
+        Returns:
+            str: Text with frontmatter removed, or original text if no frontmatter found
+        """
+        if not text:
+            return ""
+        if text.startswith("---"):
+            match = re.match(r"^---[\s\S]*?\n---\s*\n", text)
+            if match:
+                return text[match.end() :]
+        return text
+
+    def _extract_yaml_frontmatter(self, text: str) -> Tuple[dict, str]:
+        """Parse and extract YAML frontmatter from text.
+
+        Args:
+            text: Text that may contain YAML frontmatter
+
+        Returns:
+            Tuple containing:
+            - dict: Parsed YAML frontmatter as a dictionary (empty dict if none found)
+            - str: Remaining body text after the frontmatter
+        """
+        if not text or not text.startswith("---"):
+            return {}, text or ""
+
+        # Match YAML frontmatter pattern: ---\n...content...\n---\n
+        match = re.match(r"^---\s*\n([\s\S]*?)\n---\s*\n", text)
+        if not match:
+            return {}, text
+
+        frontmatter_text = match.group(1)
+        body = text[match.end() :]
+
+        # Parse YAML safely, returning empty dict on any error
+        try:
+            parsed_data = yaml.safe_load(frontmatter_text)
+            if not isinstance(parsed_data, dict):
+                parsed_data = {}
+        except Exception:
+            parsed_data = {}
+
+        return parsed_data, body
+
+    def _get_pipeline_docs_url(self, pipeline_tag: Optional[str]) -> str:
+        """Generate Transformers.js documentation URL for a given pipeline tag.
+
+        Args:
+            pipeline_tag: Hugging Face pipeline tag (e.g., 'text-generation')
+
+        Returns:
+            str: URL to the relevant Transformers.js pipeline documentation
+        """
+        base_url = "https://huggingface.co/docs/transformers.js/api/pipelines"
+
+        if not pipeline_tag:
+            return base_url
+
+        # Map Hugging Face pipeline tags to Transformers.js pipeline class names
+        pipeline_class_mapping = {
+            "text-classification": "TextClassificationPipeline",
+            "token-classification": "TokenClassificationPipeline",
+            "question-answering": "QuestionAnsweringPipeline",
+            "fill-mask": "FillMaskPipeline",
+            "text2text-generation": "Text2TextGenerationPipeline",
+            "summarization": "SummarizationPipeline",
+            "translation": "TranslationPipeline",
+            "text-generation": "TextGenerationPipeline",
+            "zero-shot-classification": "ZeroShotClassificationPipeline",
+            "feature-extraction": "FeatureExtractionPipeline",
+            "image-feature-extraction": "ImageFeatureExtractionPipeline",
+            "audio-classification": "AudioClassificationPipeline",
+            "zero-shot-audio-classification": "ZeroShotAudioClassificationPipeline",
+            "automatic-speech-recognition": "AutomaticSpeechRecognitionPipeline",
+            "image-to-text": "ImageToTextPipeline",
+            "image-classification": "ImageClassificationPipeline",
+            "image-segmentation": "ImageSegmentationPipeline",
+            "background-removal": "BackgroundRemovalPipeline",
+            "zero-shot-image-classification": "ZeroShotImageClassificationPipeline",
+            "object-detection": "ObjectDetectionPipeline",
+            "zero-shot-object-detection": "ZeroShotObjectDetectionPipeline",
+            "document-question-answering": "DocumentQuestionAnsweringPipeline",
+            "text-to-audio": "TextToAudioPipeline",
+            "image-to-image": "ImageToImagePipeline",
+            "depth-estimation": "DepthEstimationPipeline",
+        }
+
+        pipeline_class = pipeline_class_mapping.get(pipeline_tag)
+        if not pipeline_class:
+            return base_url
+
+        return f"{base_url}#module_pipelines.{pipeline_class}"
+
+    def _normalize_pipeline_tag(self, pipeline_tag: Optional[str]) -> Optional[str]:
+        """Normalize pipeline tag to match expected task names.
+
+        Some pipeline tags use abbreviations that need to be expanded
+        for the conversion script to recognize them.
+
+        Args:
+            pipeline_tag: Original pipeline tag from model metadata
+
+        Returns:
+            Optional[str]: Normalized task name, or None if input is None
+        """
+        if not pipeline_tag:
+            return None
+
+        # Map abbreviated tags to their full names
+        tag_synonyms = {
+            "vqa": "visual-question-answering",
+        }
+
+        return tag_synonyms.get(pipeline_tag, pipeline_tag)
+
+    # ============================================================================
+    # Model Conversion Methods
+    # ============================================================================
+
+    def setup_repository(self) -> None:
+        """Verify that the transformers.js repository exists.
+
+        Raises:
+            RuntimeError: If the repository is not found at the expected path
+        """
+        if not self.config.repo_path.exists():
+            raise RuntimeError(
+                f"Expected transformers.js repository at {self.config.repo_path} "
+                f"but it was not found."
+            )
+
+    def _run_conversion_subprocess(
+        self, input_model_id: str, extra_args: Optional[List[str]] = None
+    ) -> subprocess.CompletedProcess:
+        """Execute the ONNX conversion script as a subprocess.
+
+        Args:
+            input_model_id: Hugging Face model ID to convert
+            extra_args: Additional command-line arguments for the conversion script
+
+        Returns:
+            subprocess.CompletedProcess: Result of the subprocess execution
+        """
+        # Build the conversion command
+        command = [
+            sys.executable,
+            "-m",
+            "scripts.convert",
+            "--quantize",
+            "--model_id",
+            input_model_id,
+        ]
+
+        if extra_args:
+            command.extend(extra_args)
+
+        # Run conversion in the transformers.js repository directory
+        return subprocess.run(
+            command,
+            cwd=self.config.repo_path,
+            capture_output=True,
+            text=True,
+            env={
+                "HF_TOKEN": self.config.hf_token,
+            },
+        )
+
+    def convert_model(
+        self,
+        input_model_id: str,
+        trust_remote_code: bool = False,
+        output_attentions: bool = False,
+        enable_task_inference: bool = True,
+    ) -> Tuple[bool, Optional[str]]:
+        """Convert a Hugging Face model to ONNX format.
+
+        Args:
+            input_model_id: Hugging Face model repository ID
+            trust_remote_code: Whether to trust and execute remote code from the model
+            output_attentions: Whether to output attention weights (required for some tasks)
+            enable_task_inference: Whether to pass the task argument to the conversion script based on the model's pipeline tag
+
+        Returns:
+            Tuple containing:
+            - bool: True if conversion succeeded, False otherwise
+            - Optional[str]: Error message if failed, or conversion log if succeeded
+        """
+        try:
+            conversion_args: List[str] = []
+
+            # Handle trust_remote_code option (requires user token for security)
+            if trust_remote_code:
+                if not self.config.is_using_user_token:
+                    raise Exception(
+                        "Trust Remote Code requires your own HuggingFace token."
+                    )
+                conversion_args.append("--trust_remote_code")
+
+            # Handle output_attentions option (needed for word-level timestamps in Whisper)
+            if output_attentions:
+                conversion_args.append("--output_attentions")
+
+            if enable_task_inference:
+                try:
+                    info = model_info(
+                        repo_id=input_model_id, token=self.config.hf_token
+                    )
+                    pipeline_tag = getattr(info, "pipeline_tag", None)
+                    task = self._normalize_pipeline_tag(pipeline_tag)
+                    if task:
+                        conversion_args.extend(["--task", task])
+                except Exception:
+                    pass
+
+            # Run the conversion
+            result = self._run_conversion_subprocess(
+                input_model_id, extra_args=conversion_args or None
+            )
+
+            # Check if conversion succeeded
+            if result.returncode != 0:
+                return False, result.stderr
+
+            return True, result.stderr
+
+        except Exception as e:
+            return False, str(e)
+
+    # ============================================================================
+    # Upload Methods
+    # ============================================================================
+
+    def upload_model(self, input_model_id: str, output_model_id: str) -> Optional[str]:
+        """Upload the converted ONNX model to Hugging Face Hub.
+
+        This method:
+        1. Creates the target repository (if it doesn't exist)
+        2. Generates an enhanced README with merged metadata
+        3. Uploads all model files to the repository
+        4. Cleans up local files after upload
+
+        Args:
+            input_model_id: Original model repository ID
+            output_model_id: Target repository ID for the ONNX model
+
+        Returns:
+            Optional[str]: Error message if upload failed, None if successful
+        """
+        model_folder_path = self.config.repo_path / "models" / input_model_id
+
+        try:
+            # Create the target repository (public by default)
+            self.api.create_repo(output_model_id, exist_ok=True, private=False)
+
+            # Generate and write the enhanced README
+            readme_path = model_folder_path / "README.md"
+            readme_content = self.generate_readme(input_model_id)
+            readme_path.write_text(readme_content, encoding="utf-8")
+
+            # Upload all files from the model folder
+            self.api.upload_folder(
+                folder_path=str(model_folder_path), repo_id=output_model_id
+            )
+
+            return None  # Success
+
+        except Exception as e:
+            return str(e)
+        finally:
+            # Always clean up local files, even if upload failed
+            shutil.rmtree(model_folder_path, ignore_errors=True)
+
+    # ============================================================================
+    # README Generation Methods
+    # ============================================================================
+
+    def generate_readme(self, input_model_id: str) -> str:
+        """Generate an enhanced README for the ONNX model.
+
+        This method creates a README that:
+        1. Merges metadata from the original model with ONNX-specific metadata
+        2. Adds a description and link to the conversion space
+        3. Includes usage instructions with links to Transformers.js docs
+        4. Appends the original model's README content
+
+        Args:
+            input_model_id: Original model repository ID
+
+        Returns:
+            str: Complete README content in Markdown format with YAML frontmatter
+        """
+        # Fetch pipeline tag from model metadata (if available)
+        try:
+            info = model_info(repo_id=input_model_id, token=self.config.hf_token)
+            pipeline_tag = getattr(info, "pipeline_tag", None)
+        except Exception:
+            pipeline_tag = None
+
+        # Fetch and parse the original README
+        original_text = self._fetch_original_readme(input_model_id)
+        original_meta, original_body = self._extract_yaml_frontmatter(original_text)
+        original_body = (
+            original_body or self._strip_yaml_frontmatter(original_text)
+        ).strip()
+
+        # Merge original metadata with our ONNX-specific metadata (ours take precedence)
+        merged_meta = {}
+        if isinstance(original_meta, dict):
+            merged_meta.update(original_meta)
+        merged_meta["library_name"] = "transformers.js"
+        merged_meta["base_model"] = [input_model_id]
+        if pipeline_tag is not None:
+            merged_meta["pipeline_tag"] = pipeline_tag
+
+        # Generate YAML frontmatter
+        frontmatter_yaml = yaml.safe_dump(merged_meta, sort_keys=False).strip()
+        header = f"---\n{frontmatter_yaml}\n---\n\n"
+
+        # Build README sections
+        readme_sections: List[str] = []
+        readme_sections.append(header)
+
+        # Add title
+        model_name = input_model_id.split("/")[-1]
+        readme_sections.append(f"# {model_name} (ONNX)\n")
+
+        # Add description
+        readme_sections.append(
+            f"This is an ONNX version of [{input_model_id}](https://huggingface.co/{input_model_id}). "
+            "It was automatically converted and uploaded using "
+            "[this Hugging Face Space](https://huggingface.co/spaces/onnx-community/convert-to-onnx)."
+        )
+
+        # Add usage section with Transformers.js docs link
+        docs_url = self._get_pipeline_docs_url(pipeline_tag)
+        if docs_url:
+            readme_sections.append("\n## Usage with Transformers.js\n")
+            if pipeline_tag:
+                readme_sections.append(
+                    f"See the pipeline documentation for `{pipeline_tag}`: {docs_url}"
+                )
+            else:
+                readme_sections.append(f"See the pipelines documentation: {docs_url}")
+
+        # Append original README content (if available)
+        if original_body:
+            readme_sections.append("\n---\n")
+            readme_sections.append(original_body)
+
+        return "\n\n".join(readme_sections) + "\n"
+
+
+def main():
+    """Main application entry point for the Streamlit interface.
+
+    This function:
+    1. Initializes configuration and converter
+    2. Displays the UI for model input and options
+    3. Handles the conversion workflow
+    4. Shows progress and results to the user
+    """
+    st.write("## Convert a Hugging Face model to ONNX")
+
+    try:
+        # Initialize configuration and converter
+        config = Config.from_env()
+        converter = ModelConverter(config)
+        converter.setup_repository()
+
+        # Get model ID from user
+        input_model_id = st.text_input(
+            "Enter the Hugging Face model ID to convert. Example: `EleutherAI/pythia-14m`"
+        )
+
+        if not input_model_id:
+            return
+
+        # Optional: User token input
+        st.text_input(
+            "Optional: Your Hugging Face write token. Fill it if you want to upload the model under your account.",
+            type="password",
+            key="user_hf_token",
+        )
+
+        # Optional: Trust remote code toggle (requires user token)
+        trust_remote_code = st.toggle("Optional: Trust Remote Code.")
+        if trust_remote_code:
+            st.warning(
+                "This option should only be enabled for repositories you trust and in which you have read the code, as it will execute arbitrary code present in the model repository. When this option is enabled, you must use your own Hugging Face write token."
+            )
+
+        # Optional: Output attentions (for Whisper models)
+        output_attentions = False
+        if "whisper" in input_model_id.lower():
+            output_attentions = st.toggle(
+                "Whether to output attentions from the Whisper model. This is required for word-level (token) timestamps."
+            )
+
+        # Optional: Task inference toggle
+        enable_task_inference = st.toggle(
+            "Optional: Base the 'task' argument from the conversion script on the model's pipeline tag",
+            value=False,
+            help="This can make the conversion of some models work, but may cause issues for others. It's recommended to first try converting the model with this option disabled, and only enable it if the conversion fails.",
+        )
+
+        # Determine output repository
+        # If user owns the model, allow uploading to the same repo
+        if config.hf_username == input_model_id.split("/")[0]:
+            same_repo = st.checkbox(
+                "Upload the ONNX weights to the existing repository"
+            )
+        else:
+            same_repo = False
+
+        model_name = input_model_id.split("/")[-1]
+        output_model_id = f"{config.hf_username}/{model_name}"
+
+        # Add -ONNX suffix if creating a new repository
+        if not same_repo:
+            output_model_id += "-ONNX"
+
+        output_model_url = f"{config.hf_base_url}/{output_model_id}"
+
+        # Check if model already exists
+        if not same_repo and converter.api.repo_exists(output_model_id):
+            st.write("This model has already been converted! 🎉")
+            st.link_button(f"Go to {output_model_id}", output_model_url, type="primary")
+            return
+
+        # Show where the model will be uploaded
+        st.write("URL where the model will be converted and uploaded to:")
+        st.code(output_model_url, language="plaintext")
+
+        # Wait for user confirmation before proceeding
+        if not st.button(label="Proceed", type="primary"):
+            return
+
+        # Step 1: Convert the model to ONNX
+        with st.spinner("Converting model..."):
+            success, stderr = converter.convert_model(
+                input_model_id,
+                trust_remote_code=trust_remote_code,
+                output_attentions=output_attentions,
+                enable_task_inference=enable_task_inference,
+            )
+            if not success:
+                st.error(f"Conversion failed: {stderr}")
+                return
+
+            st.success("Conversion successful!")
+            st.code(stderr)
+
+        # Step 2: Upload the converted model to Hugging Face
+        with st.spinner("Uploading model..."):
+            error = converter.upload_model(input_model_id, output_model_id)
+            if error:
+                st.error(f"Upload failed: {error}")
+                return
+
+            st.success("Upload successful!")
+            st.write("You can now go and view the model on Hugging Face!")
+            st.link_button(f"Go to {output_model_id}", output_model_url, type="primary")
+
+    except Exception as e:
+        logger.exception("Application error")
+        st.error(f"An error occurred: {str(e)}")
+
+
+if __name__ == "__main__":
+    main()

docker-compose.yml

@@ -0,0 +1,7 @@
+services:
+  app:
+    build: .
+    ports:
+      - "8501:8501"
+    environment:
+      - HF_TOKEN=${HF_TOKEN}

license.txt

@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

requirements.txt

@@ -0,0 +1,8 @@
+huggingface_hub==0.35.3
+streamlit==1.50.0
+PyYAML==6.0.2
+onnxscript==0.5.4
+onnxconverter_common==1.16.0
+onnx_graphsurgeon==0.5.8
+torch==2.5.1
+torchtitan