Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* 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
+examples/apple_pie.jpg filter=lfs diff=lfs merge=lfs -text

README.md

@@ -1,14 +1,29 @@
 ---
-title: Food Classifier Comparison
-emoji: 📚
+title: Food Classifier with Model Comparison
+emoji: 🍔
 colorFrom: green
-colorTo: green
+colorTo: blue
 sdk: gradio
-sdk_version: 5.39.0
+sdk_version: 4.19.2
 app_file: app.py
 pinned: false
-license: mit
-short_description: Comparing two different model speed and accuracy
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🍔 Food Classifier: Accuracy vs. Speed
+
+This Gradio demo allows you to classify food images using two different transformer-based models and visually compare their performance.
+
+## How to Use
+
+1.  **Upload an Image**: Drag and drop a food image or click to upload one. You can also use one of the examples below.
+2.  **Choose a Model**: Select either the ViT or Swin model from the dropdown.
+3.  **Click Classify**: The model will predict the food item.
+
+## The Comparison Feature
+
+The key feature of this demo is the **performance comparison chart**:
+
+-   **Benchmark Accuracy**: This chart shows the reported accuracy of each model on the Food101 test set. The Swin model is generally more accurate.
+-   **Inference Time**: This chart shows the *actual time* it took for the selected model to process *your* uploaded image. You can see the speed trade-off firsthand. The ViT model is often faster.
+
+This allows you to understand the classic machine learning trade-off between a model's accuracy and its computational cost (speed).

app.py

@@ -0,0 +1,152 @@
+
+import gradio as gr
+import time
+import torch
+from transformers import pipeline
+from PIL import Image
+import pandas as pd
+import matplotlib.pyplot as plt
+import io
+
+# --- 1. Model Configuration & Metadata ---
+DEVICE = "cuda:0" if torch.cuda.is_available() else "cpu"
+
+MODEL_INFO = {
+    "ViT (eslamxm/vit-base-food101)": {
+        "model_id": "eslamxm/vit-base-food101",
+        "benchmark_accuracy": 90.68,
+        "pipeline": None
+    },
+    "Swin (aspis/swin-finetuned-food101)": {
+        "model_id": "aspis/swin-finetuned-food101",
+        "benchmark_accuracy": 93.81,
+        "pipeline": None
+    }
+}
+
+# --- 2. Lazy Loading of Models ---
+def load_pipeline(model_name):
+    """Loads a model pipeline only when it's first needed."""
+    if MODEL_INFO[model_name]["pipeline"] is None:
+        print(f"Loading model: {model_name}...")
+        model_id = MODEL_INFO[model_name]["model_id"]
+        MODEL_INFO[model_name]["pipeline"] = pipeline(task="image-classification", model=model_id, device=DEVICE)
+        print(f"Model '{model_name}' loaded on {DEVICE}.")
+    return MODEL_INFO[model_name]["pipeline"]
+
+# --- 3. Function to Generate Comparison Chart ---
+def create_comparison_chart(selected_model_name, current_inference_time):
+    """Generates a bar chart comparing model accuracy and inference time."""
+    data = {'Model': [], 'Metric': [], 'Value': []}
+    for name, info in MODEL_INFO.items():
+        data['Model'].append(name)
+        data['Metric'].append('Benchmark Accuracy (%)')
+        data['Value'].append(info['benchmark_accuracy'])
+
+    data['Model'].append(selected_model_name)
+    data['Metric'].append('Current Inference Time (s)')
+    data['Value'].append(current_inference_time)
+
+    df = pd.DataFrame(data)
+
+    fig, ax = plt.subplots(1, 2, figsize=(12, 5))
+    fig.suptitle('Model Performance Comparison', fontsize=16)
+
+    acc_df = df[df['Metric'] == 'Benchmark Accuracy (%)']
+    colors_acc = ['#4c72b0' if model != selected_model_name else '#2ca02c' for model in acc_df['Model']]
+    acc_plot = acc_df.plot(kind='bar', x='Model', y='Value', ax=ax[0], color=colors_acc, legend=None)
+    ax[0].set_title('Benchmark Accuracy')
+    ax[0].set_ylabel('Accuracy (%)')
+    ax[0].set_xlabel('')
+    ax[0].set_ylim(0, 100)
+    ax[0].tick_params(axis='x', rotation=10)
+    for p in acc_plot.patches:
+        ax[0].annotate(f"{p.get_height():.2f}%", (p.get_x() + p.get_width() / 2., p.get_height()),
+                       ha='center', va='center', xytext=(0, 9), textcoords='offset points')
+
+    time_df = df[df['Metric'] == 'Current Inference Time (s)']
+    time_plot = time_df.plot(kind='bar', x='Model', y='Value', ax=ax[1], color=['#d62728'])
+    ax[1].set_title('Inference Time for This Image')
+    ax[1].set_ylabel('Time (seconds)')
+    ax[1].set_xlabel('')
+    ax[1].tick_params(axis='x', rotation=0)
+    for p in time_plot.patches:
+        ax[1].annotate(f"{p.get_height():.4f}s", (p.get_x() + p.get_width() / 2., p.get_height()),
+                       ha='center', va='center', xytext=(0, 9), textcoords='offset points')
+
+    plt.tight_layout(rect=[0, 0.03, 1, 0.95])
+    return fig
+
+# --- 4. The Core Classification Function ---
+def classify_image(image, model_name):
+    """
+    Takes an image and model name, returns predictions, inference time,
+    and a comparison chart.
+    """
+    if image is None:
+        return {}, "Please upload an image first.", None, "Please upload an image to see a comparison."
+
+    pipe = load_pipeline(model_name)
+    start_time = time.time()
+    predictions = pipe(Image.fromarray(image))
+    end_time = time.time()
+
+    inference_time = end_time - start_time
+
+    top_5_preds = {p['label'].replace("_", " ").title(): p['score'] for p in predictions[:5]}
+    comparison_fig = create_comparison_chart(model_name, inference_time)
+
+    buf = io.BytesIO()
+    comparison_fig.savefig(buf, format='png', bbox_inches='tight')
+    buf.seek(0)
+    comparison_img = Image.open(buf)
+    plt.close(comparison_fig)
+
+    return (
+        top_5_preds,
+        f"Inference Time: {inference_time:.4f} seconds",
+        comparison_img,
+        f"Chart shows accuracy for all models and the inference time for the **{model_name}** model on this specific image."
+    )
+
+# --- 5. Gradio Interface Definition ---
+with gr.Blocks(theme=gr.themes.Soft(), css="footer {display: none !important}") as demo:
+    gr.Markdown("# 🍔 Food Classifier: Accuracy vs. Speed")
+    gr.Markdown(
+        "Compare two different models for classifying food images from the Food101 dataset. "
+        "Notice the trade-off: the **Swin** model is more accurate but might be slower, while the **ViT** model is faster but slightly less accurate."
+    )
+
+    with gr.Row(variant="panel"):
+        with gr.Column(scale=1):
+            image_input = gr.Image(type="numpy", label="Upload a food picture")
+            model_dropdown = gr.Dropdown(
+                choices=list(MODEL_INFO.keys()),
+                value=list(MODEL_INFO.keys())[0],
+                label="Choose a Model"
+            )
+            classify_button = gr.Button("Classify Image", variant="primary")
+
+            gr.Examples(
+                examples=[
+                    ["examples/sushi.jpg", list(MODEL_INFO.keys())[1]],
+                    ["examples/pizza.jpg", list(MODEL_INFO.keys())[0]],
+                    ["examples/apple_pie.jpg", list(MODEL_INFO.keys())[1]],
+                ],
+                inputs=[image_input, model_dropdown],
+            )
+
+        with gr.Column(scale=2):
+            output_label = gr.Label(num_top_classes=5, label="Top 5 Predictions")
+            output_time = gr.Textbox(label="Performance")
+            output_chart = gr.Image(type="pil", label="Model Comparison Chart")
+            chart_info = gr.Markdown()
+
+    classify_button.click(
+        fn=classify_image,
+        inputs=[image_input, model_dropdown],
+        outputs=[output_label, output_time, output_chart, chart_info]
+    )
+
+if __name__ == "__main__":
+    demo.launch()

requirements.txt

@@ -0,0 +1,8 @@
+gradio==4.19.2
+transformers==4.38.1
+torch==2.1.2
+torchvision==0.16.2
+pandas==2.1.4
+matplotlib==3.8.0
+accelerate==0.27.2
+Pillow==10.2.0