Add Gradio app with model_api inference and LFS-tracked models

.gitignore

@@ -0,0 +1,14 @@
+venv/
+.venv/
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+*.so
+*.egg
+*.egg-info/
+dist/
+build/
+.env
+.DS_Store

README.md

@@ -1,5 +1,5 @@
 ---
-title: Model Api
+title: Resnet with OpenVINO and model_api
 emoji: 📚
 colorFrom: red
 colorTo: blue
@@ -7,7 +7,7 @@ sdk: gradio
 sdk_version: 6.1.0
 app_file: app.py
 pinned: false
-short_description: Model API UI demo
+short_description: Detection example using model_api
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,247 @@
+"""
+Object Detection with model_api - Gradio Application
+Copyright (C) 2025
+"""
+
+import gradio as gr
+import numpy as np
+from pathlib import Path
+from PIL import Image
+import time
+from typing import Tuple, Optional
+import glob
+
+from model_api.models import Model
+from model_api.visualizer import Visualizer
+
+
+# Global variables for model caching
+current_model = None
+current_model_name = None
+visualizer = Visualizer()
+
+
+def get_available_models():
+    """
+    Scan the models folder for .xml files and return list of model names.
+    
+    Returns:
+        list: List of model names (without .xml extension)
+    """
+    models_dir = Path("models")
+    if not models_dir.exists():
+        return []
+    
+    xml_files = list(models_dir.glob("*.xml"))
+    model_names = [f.stem for f in xml_files]
+    return sorted(model_names)
+
+
+def load_model(model_name: str, device: str = "CPU"):
+    """
+    Load OpenVINO model using model_api.
+    
+    Args:
+        model_name: Name of the model (without .xml extension)
+        device: Inference device (CPU, GPU, etc.)
+    
+    Returns:
+        Model instance from model_api
+    """
+    global current_model, current_model_name
+    
+    # Check if model is already loaded
+    if current_model is not None and current_model_name == model_name:
+        return current_model
+    
+    model_path = Path("models") / f"{model_name}.xml"
+    
+    if not model_path.exists():
+        raise FileNotFoundError(f"Model not found: {model_path}")
+    
+    print(f"Loading model: {model_name}")
+    model = Model.create_model(str(model_path), device=device)
+    
+    # Warm-up inference
+    print("Warming up model...")
+    dummy_image = np.ones((224, 224, 3), dtype=np.uint8)
+    for _ in range(3):
+        _ = model(dummy_image)
+    
+    # Reset metrics after warm-up
+    model.get_performance_metrics().reset()
+    
+    current_model = model
+    current_model_name = model_name
+    
+    print(f"Model {model_name} loaded successfully")
+    return model
+
+
+def classify_image(
+    image: np.ndarray,
+    model_name: str,
+    confidence_threshold: float
+) -> Tuple[Image.Image, str, str]:
+    """
+    Perform image classification and return visualized result with metrics.
+    
+    Args:
+        image: Input image as numpy array
+        model_name: Name of the model to use
+        confidence_threshold: Confidence threshold for filtering predictions
+    
+    Returns:
+        Tuple of (visualized_image, detections_text, metrics_text)
+    """
+    try:
+        # Load model
+        model = load_model(model_name)
+        
+        # Convert numpy array to PIL Image if needed
+        if isinstance(image, np.ndarray):
+            pil_image = Image.fromarray(image)
+        else:
+            pil_image = image
+        
+        # Convert PIL to numpy for model_api
+        image_np = np.array(pil_image)
+        
+        # Run inference
+        result = model(image_np)
+        
+        # Get performance metrics
+        metrics = model.get_performance_metrics()
+        inference_time = metrics.get_inference_time()
+        preprocess_time = metrics.get_preprocess_time()
+        postprocess_time = metrics.get_postprocess_time()
+        fps = metrics.get_fps()
+        
+        # Format metrics text
+        metrics_text = f"""⚡ Performance Metrics:
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+🔄 Preprocessing:  {preprocess_time.mean()*1000:.2f} ms
+⚙️  Inference:      {inference_time.mean()*1000:.2f} ms
+📊 Postprocessing: {postprocess_time.mean()*1000:.2f} ms
+━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
+⏱️  Total Time:     {(preprocess_time.mean() + inference_time.mean() + postprocess_time.mean())*1000:.2f} ms
+🎯 FPS:            {fps:.2f}
+📈 Total Frames:   {inference_time.count}
+"""
+        
+        # Filter predictions by confidence threshold
+        detections_text = "🔍 Detected Objects:\n"
+        detections_text += "━" * 50 + "\n"
+        
+        if result.top_labels and len(result.top_labels) > 0:
+            filtered_labels = [
+                label for label in result.top_labels 
+                if label.confidence >= confidence_threshold
+            ]
+            
+            if filtered_labels:
+                for i, label in enumerate(filtered_labels, 1):
+                    detections_text += f"{i}. {label.name}: {label.confidence:.3f}\n"
+            else:
+                detections_text += f"No detections above confidence threshold {confidence_threshold:.2f}\n"
+        else:
+            detections_text += "No detections found\n"
+        
+        # Visualize results using model_api's visualizer
+        visualized_image = visualizer.render(pil_image, result)
+        
+        return visualized_image, detections_text, metrics_text
+        
+    except Exception as e:
+        error_msg = f"Error during inference: {str(e)}"
+        print(error_msg)
+        return image, error_msg, "Error: Could not compute metrics"
+
+
+def create_gradio_interface():
+    """
+    Create and configure the Gradio interface.
+    
+    Returns:
+        gr.Blocks: Configured Gradio interface
+    """
+    available_models = get_available_models()
+    
+    if not available_models:
+        print("Warning: No models found in models/ folder")
+        available_models = ["No models available"]
+    
+    with gr.Blocks(title="Object Detection with model_api") as demo:
+        gr.Markdown("# 🎯 Object Detection with model_api")
+        gr.Markdown("Upload an image and select a model to perform object detection using OpenVINO and model_api")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                input_image = gr.Image(
+                    label="Input Image",
+                    type="numpy",
+                    height=400
+                )
+                
+                model_dropdown = gr.Dropdown(
+                    choices=available_models,
+                    value=available_models[0] if available_models else None,
+                    label="Select Model",
+                    info="Choose a model from the models/ folder"
+                )
+                
+                confidence_slider = gr.Slider(
+                    minimum=0.0,
+                    maximum=1.0,
+                    value=0.3,
+                    step=0.05,
+                    label="Confidence Threshold",
+                    info="Minimum confidence for displaying predictions"
+                )
+                
+                classify_btn = gr.Button("🚀 Run Inference", variant="primary")
+            
+            with gr.Column(scale=1):
+                output_image = gr.Image(
+                    label="Detection Result",
+                    type="pil",
+                    height=400
+                )
+                
+                detections_output = gr.Textbox(
+                    label="Detected Objects",
+                    lines=8,
+                    max_lines=15
+                )
+                
+                metrics_output = gr.Textbox(
+                    label="Performance Metrics",
+                    lines=8,
+                    max_lines=15
+                )
+        
+        # Examples section
+        gr.Markdown("## 📸 Examples")
+        gr.Examples(
+            examples=[
+                ["examples/image1.jpg", available_models[0] if available_models else "resnet18", 0.3],
+            ],
+            inputs=[input_image, model_dropdown, confidence_slider],
+            outputs=[output_image, detections_output, metrics_output],
+            fn=classify_image,
+            cache_examples=False
+        )
+        
+        # Connect the button to the inference function
+        classify_btn.click(
+            fn=classify_image,
+            inputs=[input_image, model_dropdown, confidence_slider],
+            outputs=[output_image, detections_output, metrics_output]
+        )
+    
+    return demo
+
+
+if __name__ == "__main__":
+    demo = create_gradio_interface()
+    demo.launch(share=False)

models/resnet18.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:17fa954b5cc16f10937920e13aa386ec681d76429df5d0d3069d2187fdf06cb4
+size 23369472

models/resnet50.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:079dcebdec571c1b6beedc9399a67a30b4e8e2a7c248df13f11984cf56c35ec9
+size 51060992

requirements.txt

@@ -0,0 +1,5 @@
+gradio>=4.0.0
+numpy>=1.21.0
+pillow>=9.0.0
+openvino>=2024.0.0
+git+https://github.com/open-edge-platform/model_api.git