Download app.py from model-deployer/food-classifier-comparison: direct link, hf CLI and curl.
- Browser
- Download file 5.97 kB
-
https://huggingface.co/spaces/model-deployer/food-classifier-comparison/resolve/main/app.py
- Command line
-
hf download hf://spaces/model-deployer/food-classifier-comparison/app.py
-
curl -L -o app.py https://huggingface.co/spaces/model-deployer/food-classifier-comparison/resolve/main/app.py
5.97 kB
| 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() | |