Clean history: code-only (no models)

.dockerignore

@@ -0,0 +1,64 @@
+# Git and version control
+.git
+.gitignore
+.gitattributes
+
+# Python cache and virtual environments
+__pycache__/
+*.pyc
+*.pyo
+*.pyd
+.Python
+.venv/
+venv/
+.env
+
+# Documentation and development files
+docs/
+references/
+reports/
+notebooks/
+tests/
+
+# Data files (too large for Docker image)
+data/
+mlruns/
+models/*.pth
+
+# Development and configuration files
+.pytest_cache/
+.coverage
+.mypy_cache/
+.ruff_cache/
+*.log
+
+# IDE and editor files
+.vscode/
+.idea/
+*.swp
+*.swo
+*~
+
+# OS files
+.DS_Store
+Thumbs.db
+
+# Build artifacts
+build/
+dist/
+*.egg-info/
+
+# Streamlit specific
+.streamlit/
+
+# Project specific
+Makefile
+LICENSE
+streamlit/README.md
+
+# Deployment scripts
+deploy_to_hf.sh
+COMMANDS.md
+
+# Food101 HF Space (don't include in Docker)
+Food101/

.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

Dockerfile

@@ -0,0 +1,55 @@
+# Use Python 3.10 slim image for smaller size
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install uv
+RUN pip install uv
+
+# Copy dependency files first (for better caching)
+COPY pyproject.toml ./
+COPY uv.lock ./
+COPY README.md ./
+
+# Install dependencies using uv (creates .venv)
+RUN uv sync --frozen
+
+# Use /tmp for all caches and Streamlit config to avoid permission issues in read-only paths
+ENV HOME=/tmp \
+	XDG_CACHE_HOME=/tmp/.cache \
+	UV_CACHE_DIR=/tmp/.cache/uv \
+	PIP_CACHE_DIR=/tmp/.cache/pip \
+	HF_HOME=/tmp/.cache/huggingface \
+	TRANSFORMERS_CACHE=/tmp/.cache/huggingface/transformers \
+	TORCH_HOME=/tmp/.cache/torch \
+	STREAMLIT_CONFIG_DIR=/tmp/.streamlit \
+	STREAMLIT_BROWSER_GATHER_USAGE_STATS=false
+RUN mkdir -p \
+	  /tmp/.cache/uv \
+	  /tmp/.cache/pip \
+	  /tmp/.cache/huggingface/transformers \
+	  /tmp/.cache/torch \
+	  /tmp/.streamlit \
+	&& chmod -R 777 /tmp/.cache /tmp/.streamlit
+
+# Copy application code
+COPY src/ ./src/
+COPY app.py ./
+COPY config.toml ./
+
+# Copy models
+COPY models/ ./models/
+
+# Expose Streamlit port (Hugging Face Spaces uses 7860)
+EXPOSE 7860
+
+# Set environment variables for Streamlit
+ENV STREAMLIT_SERVER_PORT=7860
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
+ENV STREAMLIT_SERVER_HEADLESS=true
+ENV STREAMLIT_SERVER_ENABLE_XSRF_PROTECTION=false
+
+# Run the application using the created virtual environment
+ENV PATH="/app/.venv/bin:${PATH}"
+CMD ["python", "-m", "streamlit", "run", "app.py", "--server.port=7860", "--server.address=0.0.0.0"]

README.md

@@ -0,0 +1,12 @@
+---
+title: Food101 Streamlit
+emoji: 👁
+colorFrom: yellow
+colorTo: pink
+sdk: docker
+pinned: false
+license: mit
+short_description: Space for Detecting the Type of Dish in an Image
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,275 @@
+import streamlit as st
+from PIL import Image
+import io
+import os
+import time
+import tempfile
+from pathlib import Path
+
+from src.models.model_discovery import discover_models
+from src.labels import LABELS
+
+
+def load_model(model_info):
+    """Load and cache the selected model with proper error handling."""
+    model_class = model_info["class"]
+    model_name = model_info["class_name"]
+
+    # Set up custom cache directory to avoid permission issues
+    custom_cache = Path(tempfile.gettempdir()) / "tikka_masalai_cache"
+    custom_cache.mkdir(exist_ok=True)
+
+    # Set HuggingFace cache directory (use HF_HOME instead of deprecated TRANSFORMERS_CACHE)
+    os.environ["HF_HOME"] = str(custom_cache)
+    os.environ["TRANSFORMERS_CACHE"] = str(
+        custom_cache
+    )  # Keep for backward compatibility
+
+    try:
+        # Use a placeholder for the loading message that we can clear
+        loading_placeholder = st.empty()
+        loading_placeholder.info(f"Loading {model_name} model...")
+
+        # Try to load the model - handle different model initialization patterns
+        if "prithiv" in model_name.lower():
+            # PrithivML model with specific initialization
+            model = model_class()
+        elif "resnet" in model_name.lower():
+            # ResNet model - check if it needs specific paths
+            try:
+                model = model_class()
+            except TypeError:
+                # Try with default parameters if it requires them
+                model = model_class(
+                    preprocessor_path="microsoft/resnet-18",
+                    model_path="microsoft/resnet-18",
+                )
+        elif "vgg" in model_name.lower():
+            # VGG model with default parameters
+            model = model_class()
+        else:
+            # Generic model initialization
+            try:
+                model = model_class()
+            except TypeError:
+                # Skip models that require specific parameters we don't know about
+                raise RuntimeError(
+                    f"Model {model_name} requires specific initialization parameters"
+                )
+
+        # Show success message briefly, then clear it
+        loading_placeholder.success(f"{model_name} model loaded successfully!")
+        time.sleep(1.5)  # Show success message for 1.5 seconds
+        loading_placeholder.empty()  # Clear the message
+        return model
+
+    except PermissionError as e:
+        st.error(f"❌ Permission error: {str(e)}")
+        if "cache" in str(e).lower():
+            st.info(
+                "💡 This is likely a cache permission issue. Please refresh the page and try again."
+            )
+        return None
+
+    except Exception as e:
+        error_msg = str(e)
+        st.error(f"❌ Error loading {model_name} model: {error_msg}")
+        st.info("💡 Possible solutions:")
+        st.info("1. Refresh the page and try again")
+        st.info("2. Check if HuggingFace services are available")
+        st.info("3. Try a different model")
+        return None
+
+
+def predict_food(model, image_bytes):
+    """Make a prediction on the uploaded image."""
+    try:
+        # Get prediction index
+        prediction_idx = model.classify(image_bytes)
+
+        # Get the label name
+        if 0 <= prediction_idx < len(LABELS):
+            prediction_label = LABELS[prediction_idx]
+            return prediction_idx, prediction_label
+        else:
+            return None, "Unknown"
+    except Exception as e:
+        st.error(f"Error during prediction: {str(e)}")
+        return None, "Error"
+
+
+def main():
+    """Main Streamlit application."""
+    st.set_page_config(
+        page_title="TikkaMasalAI Food Classifier", page_icon="🍽️", layout="centered"
+    )
+
+    st.title("🍽️ TikkaMasalAI Food Classifier")
+    st.markdown("Upload an image of food and let our AI identify what it is!")
+
+    # Discover available models
+    try:
+        available_models = discover_models()
+    except Exception as e:
+        st.error(f"❌ Error discovering models: {str(e)}")
+        st.info("Make sure the src/models directory contains valid model files.")
+        return
+
+    if not available_models:
+        st.error("❌ No compatible models found in the src/models directory!")
+        st.info("Make sure there are models that inherit from FoodClassificationModel.")
+        return
+
+    # Model selection in sidebar
+    with st.sidebar:
+        st.header("🤖 Model Selection")
+        selected_model_name = st.selectbox(
+            "Choose a model:",
+            options=list(available_models.keys()),
+            help="Select which AI model to use for food classification",
+        )
+
+        selected_model_info = available_models[selected_model_name]
+
+        # Show model information
+        st.info(f"**Selected:** {selected_model_name}")
+        st.write(f"**Class:** `{selected_model_info['class_name']}`")
+        st.write(f"**Module:** `{selected_model_info['module']}`")
+
+    # Show app status
+    status_container = st.container()
+
+    # Load model with better UX
+    with status_container:
+        model_status = st.empty()
+        progress_bar = st.progress(0)
+
+        model_status.info("🔄 Initializing AI model...")
+        progress_bar.progress(25)
+
+        model = load_model(selected_model_info)
+        progress_bar.progress(100)
+
+        if model is None:
+            model_status.error("❌ Failed to load the model.")
+            st.error("### 🚨 Model Loading Failed")
+            st.markdown(
+                f"""
+            **Failed to load:** {selected_model_name}
+            
+            **Possible causes:**
+            - Model-specific initialization requirements
+            - Missing dependencies for this model
+            - Temporary HuggingFace services issue
+            - Model cache conflicts in HF Spaces
+            - Network connectivity problems
+            
+            **Solutions:**
+            1. **Try a different model** from the sidebar
+            2. **Refresh the page** and try again
+            3. **Wait 2-3 minutes** for any background downloads to complete
+            4. If the issue persists, the model will automatically retry
+            """
+            )
+
+            # Add a retry button
+            if st.button("🔄 Retry Loading Model"):
+                st.experimental_rerun()
+
+            return
+
+        model_status.success(f"✅ {selected_model_name} loaded and ready!")
+        progress_bar.empty()
+
+    # File uploader
+    uploaded_file = st.file_uploader(
+        "Choose a food image...",
+        type=["png", "jpg", "jpeg"],
+        help="Upload an image of food to classify",
+    )
+
+    if uploaded_file is not None:
+        # Read image bytes
+        image_bytes = uploaded_file.read()
+
+        # Display the uploaded image
+        col1, col2 = st.columns([1, 1])
+
+        with col1:
+            st.subheader("📸 Uploaded Image")
+            image = Image.open(io.BytesIO(image_bytes))
+            st.image(image, caption="Your uploaded image", use_container_width=True)
+
+        with col2:
+            st.subheader("🔍 Prediction Results")
+
+            # Make prediction
+            with st.spinner("Analyzing your image..."):
+                prediction_idx, prediction_label = predict_food(model, image_bytes)
+
+            if prediction_idx is not None:
+                # Display results
+                st.success("Classification complete!")
+
+                # Format the label for display
+                display_label = prediction_label.replace("_", " ").title()
+
+                st.markdown(f"### 🏷️ **{display_label}**")
+                st.markdown(f"**Class Index:** {prediction_idx}")
+
+                # Show confidence bar (placeholder since the model doesn't return probabilities)
+                st.markdown("**Prediction Details:**")
+                st.info(f"The AI model identified this image as **{display_label}**")
+
+                # Show additional info
+                with st.expander("ℹ️ About this classification"):
+                    st.write(f"- **Model:** {selected_model_name}")
+                    st.write(f"- **Classes:** {len(LABELS)} different food types")
+                    st.write(f"- **Raw label:** `{prediction_label}`")
+                    st.write(f"- **Index:** {prediction_idx}")
+            else:
+                st.error("Failed to classify the image. Please try another image.")
+
+    # Sidebar with information
+    with st.sidebar:
+        st.header("📋 About")
+        st.write(
+            f"""
+        This app uses the **{selected_model_name}** model to classify food images into one of 101 different food categories.
+        """
+        )
+
+        st.header("🎯 How to use")
+        st.write(
+            """
+        1. Choose a model from the dropdown above
+        2. Upload an image of food using the file uploader
+        3. Wait for the AI to analyze your image
+        4. View the classification results
+        """
+        )
+
+        st.header("🍕 Supported Foods")
+        st.write(
+            f"The model can recognize **{len(LABELS)}** different types of food including:"
+        )
+
+        # Show a sample of labels
+        sample_labels = [label.replace("_", " ").title() for label in LABELS[:10]]
+        for label in sample_labels:
+            st.write(f"• {label}")
+        st.write(f"... and {len(LABELS) - 10} more!")
+
+        st.header("🔧 Technical Details")
+        st.write(
+            f"""
+        - **Selected Model:** {selected_model_name}
+        - **Available Models:** {len(available_models)}
+        - **Dataset:** Food-101
+        - **Framework:** PyTorch + Transformers
+        """
+        )
+
+
+if __name__ == "__main__":
+    main()

config.toml

@@ -0,0 +1,24 @@
+[global]
+developmentMode = false
+
+[server]
+port = 7860
+address = "0.0.0.0"
+headless = true
+enableCORS = false
+enableXsrfProtection = false
+
+[browser]
+gatherUsageStats = false
+
+[client]
+toolbarMode = "minimal"
+
+[runner]
+magicEnabled = true
+installTracer = false
+fixMatplotlib = true
+
+[logger]
+level = "info"
+messageFormat = "%(asctime)s %(message)s"

pyproject.toml

@@ -0,0 +1,70 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "tikka-masalai"
+version = "0.0.1"
+description = "MLOPS project FIB"
+authors = [
+  { name = "Team Tikka MasalAI" },
+]
+
+readme = "README.md"
+classifiers = [
+    "Programming Language :: Python :: 3",
+]
+dependencies = [
+    "dagshub>=0.6.3",
+    "datasets<4.1.1",
+    "dvc>=3.63.0",
+    "dvc-s3>=3.2.2",
+    "huggingface-hub>=0.35.0",
+    "ipykernel>=6.30.1",
+    "ipywidgets>=8.1.7",
+    "matplotlib>=3.10.6",
+    "mlflow>=2,<3",
+    "numpy>=2.2.6",
+    "pandas>=2.3.2",
+    "pillow>=11.3.0",
+    "polars>=1.0.0",
+    "pyarrow>=4.0.0,<20.0.0",
+    "pytest",
+    "python-dotenv",
+    "ruff",
+    "streamlit>=1.31.0",
+    "torch>=2.8.0",
+    "torchvision>=0.23.0",
+    "tqdm>=4.67.1",
+    "transformers>=4.56.2",
+]
+requires-python = ">=3.10"
+
+[project.optional-dependencies]
+dev = []
+
+
+# This makes src/ discoverable as a package
+[tool.hatch.build.targets.wheel]
+packages = ["src"]
+
+
+[tool.ruff]
+line-length = 99
+src = ["src"]
+include = ["pyproject.toml", "src/**/*.py"]
+
+[tool.ruff.lint]
+extend-select = ["I"]  # Add import sorting
+
+[tool.ruff.lint.isort]
+known-first-party = ["src"]
+force-sort-within-sections = true
+
+[dependency-groups]
+dev = [
+    "black>=25.1.0",
+    "pylint>=3.3.8",
+    "pytest>=8.4.2",
+]
+

src/__init__.py

@@ -0,0 +1,8 @@
+"""
+TikkaMasalAI source package.
+"""
+
+# Export commonly used utilities
+from .models.model_discovery import discover_models, get_model_names, get_model_info
+
+__all__ = ["discover_models", "get_model_names", "get_model_info"]

src/data/download_data.py

@@ -0,0 +1,8 @@
+from huggingface_hub import snapshot_download
+
+snapshot_download(
+    repo_id="ethz/food101",
+    repo_type="dataset",
+    local_dir="./data/raw/food101",
+    local_dir_use_symlinks=False,  # ensures actual files, not symlinks
+)

src/eval/eval.py

@@ -0,0 +1,67 @@
+#!/usr/bin/env python3
+"""
+Example script demonstrating how to evaluate multiple models on different datasets.
+
+This script shows how to use the enhanced evaluation framework
+with different model implementations including VGG16, ResNet18, and PrithivMlFood101.
+"""
+from src.models.vgg16 import VGG16
+from src.models.resnet18 import Resnet18
+from src.models.prithiv_ml_food101 import PrithivMlFood101
+from src.eval.evaluate_food101 import Food101Evaluator
+from src.models.food_classification_model import FoodClassificationModel
+
+
+def evaluate_food101(
+    model: FoodClassificationModel,
+    experiment_name: str = "food101_evaluation",
+    sample_limit: int = 50,
+    random_seed: int = 42,
+    run_name: str = None,
+):
+    """Main evaluation function."""
+    evaluator = Food101Evaluator(
+        model, experiment_name, sample_limit, random_seed, run_name
+    )
+    evaluator.run_evaluation()
+
+
+def main():
+    """Demonstrate evaluation with multiple model architectures."""
+
+    print("=" * 90)
+    print("Multi-Model Evaluation: VGG16 vs ResNet-18 vs PrithivMlFood101")
+
+    # Food101 Evaluations
+    print("\n=== Food101 Evaluations ===")
+
+    print("\n1. Evaluating PrithivMlFood101 on Food101...")
+    prithiv_model = PrithivMlFood101()
+    evaluate_food101(
+        experiment_name="Food101_Model_Comparison",
+        run_name="PrithivML_Baseline_50samples",
+        sample_limit=50,  # Small sample for demonstration
+        model=prithiv_model,
+    )
+
+    print("\n2. Evaluating ResNet-18 on Food101 ...")
+    resnet18_food_model = Resnet18()
+    evaluate_food101(
+        experiment_name="Food101_Model_Comparison",
+        run_name="ResNet18_Transfer_50samples",
+        sample_limit=50,  # Small sample for demonstration
+        model=resnet18_food_model,
+    )
+
+    print("\n3. Evaluating VGG16 on Food101 ...")
+    vgg16_food_model = VGG16()
+    evaluate_food101(
+        experiment_name="Food101_Model_Comparison",
+        run_name="VGG16_Transfer_50samples",
+        sample_limit=50,  # Small sample for demonstration
+        model=vgg16_food_model,
+    )
+
+
+if __name__ == "__main__":
+    main()

src/eval/evaluate_food101.py

@@ -0,0 +1,326 @@
+#!/usr/bin/env python3
+"""
+Food101 evaluation script for model evaluation with MLflow tracking.
+
+This script evaluates models on the Food101 dataset with MLflow experiment tracking.
+"""
+
+from typing import List, Dict, Tuple, Any, Union
+from pathlib import Path
+import mlflow
+from datetime import datetime
+import pandas as pd
+import glob
+import random
+import dagshub
+
+from src.models.food_classification_model import FoodClassificationModel
+from src.labels import LABELS, index_to_label
+
+dagshub.init(repo_owner="HubertWojcik10", repo_name="TikkaMasalAI", mlflow=True)
+mlflow.autolog()
+
+
+class Food101Evaluator:
+    """Model evaluator for Food101 dataset with MLflow tracking."""
+
+    def __init__(
+        self,
+        model: FoodClassificationModel,
+        experiment_name: str = "food101_evaluation",
+        sample_limit: int = 50,
+        random_seed: int = 42,
+        run_name: str = None,
+    ):
+        """
+        Initialize the Food101 evaluator.
+
+        Args:
+            model: FoodClassificationModel instance to use for evaluation (required)
+            experiment_name: Name of the MLflow experiment
+            sample_limit: Maximum number of samples to evaluate
+            random_seed: Random seed for reproducible sampling
+            run_name: Custom name for the MLflow run (optional)
+        """
+        self.DATASET_NAME = "Food101"
+        self.experiment_name = experiment_name
+        self.sample_limit = sample_limit
+        self.model = model
+        self.random_seed = random_seed
+        self.custom_run_name = run_name
+        self.model_name = self.model.__class__.__name__
+        self.data_dir = (
+            Path(__file__).parent.parent.parent / "data" / "raw" / "food101" / "data"
+        )
+
+    def load_validation_data(self) -> List[Tuple[bytes, int]]:
+        """
+        Load validation data from parquet files with random sampling.
+
+        Returns:
+            List of tuples: (image_bytes, true_index)
+        """
+        random.seed(self.random_seed)
+
+        validation_files = glob.glob(f"{self.data_dir}/validation-*.parquet")
+        print(f"Found {len(validation_files)} validation files")
+
+        # Load all samples first
+        all_samples = []
+
+        for file_path in validation_files:
+            print(f"Loading from {Path(file_path).name}...")
+            df = pd.read_parquet(file_path)
+
+            for _, row in df.iterrows():
+                image_data = row["image"]["bytes"]
+                true_index = row["label"]
+
+                all_samples.append((image_data, true_index))
+
+        print(f"Total available samples: {len(all_samples)}")
+
+        # Randomly sample the requested number of samples
+        if len(all_samples) <= self.sample_limit:
+            selected_samples = all_samples
+            print(f"Using all {len(selected_samples)} available samples")
+        else:
+            selected_samples = random.sample(all_samples, self.sample_limit)
+            print(
+                f"Randomly selected {len(selected_samples)} samples from {len(all_samples)} available"
+            )
+
+        print(f"Random seed used: {self.random_seed}")
+        return selected_samples
+
+    def calculate_accuracy(
+        self, predictions: List[Union[int, str]], ground_truths: List[int]
+    ) -> float:
+        """
+        Calculate exact accuracy for Food101 dataset.
+
+        Args:
+            predictions: List of predicted indices or label names
+            ground_truths: List of true labels
+
+        Returns:
+            Accuracy score as float
+        """
+        if not predictions or not ground_truths:
+            return 0.0
+
+        # Check for exact matches
+        exact_matches = 0
+        for pred, true in zip(predictions, ground_truths):
+            if pred == true:
+                exact_matches += 1
+
+        return exact_matches / len(predictions)
+
+    def evaluate_model(
+        self, samples: List[Tuple[bytes, int]], verbose: bool = True
+    ) -> Dict[str, Any]:
+        """
+        Evaluate the model on the provided samples.
+
+        Args:
+            samples: List of (image_bytes, true_index) tuples
+            verbose: Whether to print detailed results
+
+        Returns:
+            Dictionary with evaluation metrics
+        """
+        print(f"\nEvaluating model on {len(samples)} samples...")
+
+        predictions = []
+        ground_truths = []
+        prediction_examples = []
+        correct_predictions = 0
+
+        for i, (image_bytes, true_index) in enumerate(samples):
+            try:
+                predicted_index = self.model.classify(image_bytes)
+                predictions.append(predicted_index)
+                ground_truths.append(true_index)
+
+                # Check if prediction is correct using dataset-specific logic
+                is_correct = predicted_index == true_index
+                if is_correct:
+                    correct_predictions += 1
+
+                # Convert index to label name for display and logging
+                predicted_label_name = index_to_label(predicted_index)
+
+                # Store first 10 examples for MLflow
+                if i < 10:
+                    prediction_examples.append(
+                        {
+                            "sample_id": i + 1,
+                            "true_label": LABELS[true_index],
+                            "predicted_label": predicted_label_name,
+                            "predicted_index": predicted_index,
+                            "true_index": true_index,
+                            "is_correct": is_correct,
+                        }
+                    )
+
+                if verbose and i < 10:  # Print first 10 predictions
+                    status = "✓" if is_correct else "✗"
+                    print(
+                        f"Sample {i+1:2d}: {status} True='{LABELS[true_index]:25s}' (idx: {true_index}) | Predicted='{predicted_label_name}' (idx: {predicted_index})"
+                    )
+
+            except Exception as e:
+                print(f"Error processing sample {i+1}: {e}")
+                predictions.append("ERROR")
+                ground_truths.append(true_index)
+
+        # Calculate metrics
+        total_samples = len(samples)
+        successful_predictions = len([p for p in predictions if p != "ERROR"])
+
+        # Calculate accuracy using dataset-specific method
+        accuracy = self.calculate_accuracy(predictions, ground_truths)
+        success_rate = (
+            successful_predictions / total_samples if total_samples > 0 else 0
+        )
+
+        results = {
+            "total_samples": total_samples,
+            "successful_predictions": successful_predictions,
+            "correct_predictions": correct_predictions,
+            "success_rate": success_rate,
+            "accuracy": accuracy,
+            "prediction_examples": prediction_examples,
+        }
+
+        return results
+
+    def log_mlflow_metrics(self, results: Dict[str, Any]) -> None:
+        """
+        Log evaluation metrics to MLflow.
+
+        Args:
+            results: The results from the evaluation.
+        """
+        mlflow.log_metric("total_samples", results["total_samples"])
+        mlflow.log_metric("successful_predictions", results["successful_predictions"])
+        mlflow.log_metric("success_rate", results["success_rate"])
+        mlflow.log_metric("correct_predictions", results["correct_predictions"])
+        mlflow.log_metric("accuracy", results["accuracy"])
+
+    def log_mlflow_artifacts(self, results: Dict[str, Any]) -> None:
+        """
+        Log evaluation artifacts to MLflow.
+
+        Args:
+            results: The results from the evaluation.
+
+        """
+        examples_data = []
+        for example in results["prediction_examples"]:
+            status = "✓" if example.get("is_correct", False) else "✗"
+            examples_data.append(
+                f"Sample {example['sample_id']}: {status} {example['true_label']} -> {example['predicted_label']}"
+            )
+
+        examples_text = "\n".join(examples_data)
+        examples_file = f"{self.DATASET_NAME.lower()}_evaluation_examples.txt"
+        with open(examples_file, "w", encoding="utf-8", newline="") as f:
+            f.write(examples_text)
+        mlflow.log_artifact(examples_file)
+
+        model_source = (
+            getattr(self.model, "model_path", "N/A")
+            if hasattr(self.model, "model_path")
+            else "N/A"
+        )
+        summary = f"""{self.model_name} {self.DATASET_NAME} Evaluation Summary
+            ========================================={'=' * len(self.DATASET_NAME)}
+            Model: {self.model_name} ({model_source})
+            Dataset: {self.DATASET_NAME} validation set
+            Samples: {results['total_samples']}
+            Success Rate: {results['success_rate']:.2%}
+            Accuracy: {results['accuracy']:.2%}
+            Correct Predictions: {results['correct_predictions']}
+        """
+
+        summary_file = f"{self.DATASET_NAME.lower()}_evaluation_summary.txt"
+        with open(summary_file, "w", encoding="utf-8", newline="") as f:
+            f.write(summary)
+        mlflow.log_artifact(summary_file)
+
+        # Clean up temporary files
+        Path(examples_file).unlink(missing_ok=True)
+        Path(summary_file).unlink(missing_ok=True)
+
+    def run_evaluation(self) -> None:
+        """Run the complete evaluation pipeline with MLflow tracking."""
+        print("=" * 60)
+        print(f"{self.model_name} {self.DATASET_NAME} Evaluation with MLflow")
+        print("=" * 60)
+
+        mlflow.set_experiment(self.experiment_name)
+
+        # Create descriptive run name
+        if self.custom_run_name:
+            run_name = self.custom_run_name
+        else:
+            timestamp = datetime.now().strftime("%m%d_%H%M")
+            run_name = f"{self.model_name}_Food101_n{self.sample_limit}_seed{self.random_seed}_{timestamp}"
+
+        with mlflow.start_run(run_name=run_name):
+            # Add useful tags for filtering and organization
+            mlflow.set_tag("model_type", self.model_name)
+            mlflow.set_tag("dataset", self.DATASET_NAME)
+            mlflow.set_tag("sample_size", str(self.sample_limit))
+            mlflow.set_tag("evaluation_type", "validation")
+
+            mlflow.log_param("model_name", self.model_name)
+            mlflow.log_param("model_class", self.model.__class__.__name__)
+            mlflow.log_param("dataset", self.DATASET_NAME)
+            mlflow.log_param("sample_limit", self.sample_limit)
+            mlflow.log_param("random_seed", self.random_seed)
+            mlflow.log_param("evaluation_date", datetime.now().isoformat())
+
+            # Log model-specific parameters if available
+            if hasattr(self.model, "model_path"):
+                mlflow.log_param(
+                    "model_source", getattr(self.model, "model_path", "Unknown")
+                )
+            if hasattr(self.model, "preprocessor_path"):
+                mlflow.log_param(
+                    "preprocessor_path",
+                    getattr(self.model, "preprocessor_path", "Unknown"),
+                )
+
+            samples = self.load_validation_data()
+
+            if not samples:
+                print(
+                    f"No validation samples loaded. Check the {self.DATASET_NAME} dataset connection."
+                )
+                mlflow.log_param("status", "failed - no data")
+                return
+
+            mlflow.log_param("samples_loaded", len(samples))
+
+            results = self.evaluate_model(samples, verbose=True)
+
+            self.log_mlflow_metrics(results)
+            self.log_mlflow_artifacts(results)
+
+            self._print_results(results)
+
+    def _print_results(self, results: Dict[str, Any]) -> None:
+        """Print evaluation results to console."""
+        print("\n" + "=" * 60)
+        print("EVALUATION RESULTS")
+        print("=" * 60)
+        print(f"Total samples processed:       {results['total_samples']}")
+        print(f"Successful predictions:        {results['successful_predictions']}")
+        print(f"Success rate:                  {results['success_rate']:.2%}")
+        print(f"Correct predictions:           {results['correct_predictions']}")
+        print(f"Accuracy:                      {results['accuracy']:.2%}")
+
+        print(f"\nMLflow run ID: {mlflow.active_run().info.run_id}")

src/labels.py

@@ -0,0 +1,135 @@
+LABELS = [
+    "apple_pie",
+    "baby_back_ribs",
+    "baklava",
+    "beef_carpaccio",
+    "beef_tartare",
+    "beet_salad",
+    "beignets",
+    "bibimbap",
+    "bread_pudding",
+    "breakfast_burrito",
+    "bruschetta",
+    "caesar_salad",
+    "cannoli",
+    "caprese_salad",
+    "carrot_cake",
+    "ceviche",
+    "cheesecake",
+    "cheese_plate",
+    "chicken_curry",
+    "chicken_quesadilla",
+    "chicken_wings",
+    "chocolate_cake",
+    "chocolate_mousse",
+    "churros",
+    "clam_chowder",
+    "club_sandwich",
+    "crab_cakes",
+    "creme_brulee",
+    "croque_madame",
+    "cup_cakes",
+    "deviled_eggs",
+    "donuts",
+    "dumplings",
+    "edamame",
+    "eggs_benedict",
+    "escargots",
+    "falafel",
+    "filet_mignon",
+    "fish_and_chips",
+    "foie_gras",
+    "french_fries",
+    "french_onion_soup",
+    "french_toast",
+    "fried_calamari",
+    "fried_rice",
+    "frozen_yogurt",
+    "garlic_bread",
+    "gnocchi",
+    "greek_salad",
+    "grilled_cheese_sandwich",
+    "grilled_salmon",
+    "guacamole",
+    "gyoza",
+    "hamburger",
+    "hot_and_sour_soup",
+    "hot_dog",
+    "huevos_rancheros",
+    "hummus",
+    "ice_cream",
+    "lasagna",
+    "lobster_bisque",
+    "lobster_roll_sandwich",
+    "macaroni_and_cheese",
+    "macarons",
+    "miso_soup",
+    "mussels",
+    "nachos",
+    "omelette",
+    "onion_rings",
+    "oysters",
+    "pad_thai",
+    "paella",
+    "pancakes",
+    "panna_cotta",
+    "peking_duck",
+    "pho",
+    "pizza",
+    "pork_chop",
+    "poutine",
+    "prime_rib",
+    "pulled_pork_sandwich",
+    "ramen",
+    "ravioli",
+    "red_velvet_cake",
+    "risotto",
+    "samosa",
+    "sashimi",
+    "scallops",
+    "seaweed_salad",
+    "shrimp_and_grits",
+    "spaghetti_bolognese",
+    "spaghetti_carbonara",
+    "spring_rolls",
+    "steak",
+    "strawberry_shortcake",
+    "sushi",
+    "tacos",
+    "takoyaki",
+    "tiramisu",
+    "tuna_tartare",
+    "waffles",
+]
+
+
+def index_to_label(index: int) -> str:
+    """
+    Convert a class index to its corresponding label name.
+
+    Args:
+        index: The class index (0-based)
+
+    Returns:
+        str: The label name corresponding to the index, or a fallback string if index is out of bounds
+    """
+    if 0 <= index < len(LABELS):
+        return LABELS[index]
+    else:
+        return f"unknown_class_{index}"
+
+
+def label_to_index(label: str) -> int:
+    """
+    Convert a label name to its corresponding class index.
+
+    Args:
+        label: The label name
+
+    Returns:
+        int: The index corresponding to the label, or -1 if label is not found
+    """
+    try:
+        return LABELS.index(label)
+    except ValueError:
+        return -1

src/models/food_classification_model.py

@@ -0,0 +1,17 @@
+from abc import ABC, abstractmethod
+
+
+class FoodClassificationModel(ABC):
+    """Abstract Base Class that serves as a common interface for all models."""
+
+    @abstractmethod
+    def classify(self, image: bytes) -> int:
+        """
+        Abstract method to classify an image into a food category.
+
+        Args:
+            image: The image bytes to classify.
+
+        Returns:
+            int: The index of the predicted class. This returns the class index, not the class name.
+        """

src/models/model_discovery.py

@@ -0,0 +1,121 @@
+"""
+Model discovery utility for dynamically finding all models that inherit from FoodClassificationModel.
+"""
+
+import importlib
+import inspect
+from pathlib import Path
+from typing import Dict, Any
+
+from .food_classification_model import FoodClassificationModel
+
+
+def discover_models(models_dir: Path = None) -> Dict[str, Dict[str, Any]]:
+    """
+    Dynamically discover all models that inherit from FoodClassificationModel.
+
+    Args:
+        models_dir: Path to the models directory. If None, uses the current module's directory.
+
+    Returns:
+        Dict mapping display names to model information containing:
+        - 'class': The model class
+        - 'module': The module name
+        - 'class_name': The class name
+    """
+    if models_dir is None:
+        models_dir = Path(__file__).parent
+
+    available_models = {}
+
+    # Iterate through all Python files in the models directory
+    for py_file in models_dir.glob("*.py"):
+        if (
+            py_file.name.startswith("__")
+            or py_file.name == "food_classification_model.py"
+            or py_file.name == "model_discovery.py"
+        ):
+            continue
+
+        try:
+            # Import the module dynamically
+            module_name = f"src.models.{py_file.stem}"
+            module = importlib.import_module(module_name)
+
+            # Find all classes in the module that inherit from FoodClassificationModel
+            for name, obj in inspect.getmembers(module, inspect.isclass):
+                if (
+                    issubclass(obj, FoodClassificationModel)
+                    and obj != FoodClassificationModel
+                    and obj.__module__ == module_name
+                ):
+
+                    # Create a user-friendly name
+                    display_name = _create_display_name(name)
+
+                    available_models[display_name] = {
+                        "class": obj,
+                        "module": module_name,
+                        "class_name": name,
+                    }
+
+        except Exception as e:
+            # In a non-Streamlit context, we might want to log or handle this differently
+            print(f"Warning: Could not load model from {py_file.name}: {str(e)}")
+            continue
+
+    return available_models
+
+
+def _create_display_name(class_name: str) -> str:
+    """
+    Create a user-friendly display name from a class name.
+
+    Args:
+        class_name: The original class name
+
+    Returns:
+        A user-friendly display name
+    """
+    # Create a user-friendly name
+    display_name = class_name
+
+    if "prithiv" in class_name.lower():
+        display_name = "PrithivML Food-101 (Benchmark)"
+    elif "resnet" in class_name.lower():
+        display_name = "ResNet-18"
+    elif "vgg" in class_name.lower():
+        display_name = "VGG-16"
+    elif "efficientnet" in class_name.lower():
+        display_name = "EfficientNet"
+    elif "mobilenet" in class_name.lower():
+        display_name = "MobileNet"
+    elif "densenet" in class_name.lower():
+        display_name = "DenseNet"
+
+    return display_name
+
+
+def get_model_names() -> list:
+    """
+    Get a list of all available model display names.
+
+    Returns:
+        List of model display names
+    """
+    models = discover_models()
+    return list(models.keys())
+
+
+def get_model_info(display_name: str) -> Dict[str, Any]:
+    """
+    Get model information for a specific model by display name.
+
+    Args:
+        display_name: The display name of the model
+
+    Returns:
+        Model information dictionary or None if not found
+    """
+    models = discover_models()
+    return models.get(display_name)

src/models/prithiv_ml_food101.py

@@ -0,0 +1,89 @@
+import torch
+from transformers import AutoImageProcessor, SiglipForImageClassification
+from PIL import Image
+import io
+import os
+import tempfile
+from pathlib import Path
+
+from src.models.food_classification_model import FoodClassificationModel
+
+
+class PrithivMlFood101(FoodClassificationModel):
+    """
+    Interface for accessing the PrithivML Food-101 model architecture.
+    This model was already trained on the Food-101 dataset and performs well on it.
+    It is supposed to serve as a benchmark for our own model finetuning and potentially
+    as an alternative to be deployed.
+    See it on Huggingface: https://huggingface.co/prithivMLmods/Food-101-93M.
+    """
+
+    def __init__(self, model_name: str = "prithivMLmods/Food-101-93M"):
+        """
+        Load the PrithivML Food-101 model.
+
+        Preference order:
+        1) Load from local repo snapshot at <repo_root>/models/prithivMLmods/Food-101-93M
+        2) If not present, prompt the user to download using Makefile
+           make download-hf-model MODEL_PATH=prithivMLmods/Food-101-93M
+        """
+
+        # Set up proper cache directory for HF Spaces (safe no-op locally)
+        if not os.environ.get("HF_HOME"):
+            cache_dir = Path(tempfile.gettempdir()) / "transformers_cache"
+            cache_dir.mkdir(exist_ok=True)
+            os.environ["HF_HOME"] = str(cache_dir)
+
+        # Resolve repo root robustly from this file's location
+        repo_root = Path(__file__).resolve().parents[2]
+        local_model_dir = repo_root / "models" / "prithivMLmods" / "Food-101-93M"
+
+        # Determine whether a local copy exists (safetensors or bin)
+        local_exists = local_model_dir.exists() and (
+            (local_model_dir / "model.safetensors").exists()
+            or (local_model_dir / "pytorch_model.bin").exists()
+        )
+
+        if not local_exists:
+            # Provide a clear, actionable message to fetch the model snapshot
+            make_cmd = "make download-hf-model MODEL_PATH=prithivMLmods/Food-101-93M"
+            raise RuntimeError(
+                "Local model not found at 'models/prithivMLmods/Food-101-93M'. "
+                "Please download it first using:\n"
+                f"  {make_cmd}\n"
+                "After download completes, re-run your program."
+            )
+
+        # Load from local directory snapshot
+        try:
+            self.model = SiglipForImageClassification.from_pretrained(
+                str(local_model_dir),
+                cache_dir=os.environ.get("HF_HOME"),
+                local_files_only=True,
+                force_download=False,
+            )
+            self.processor = AutoImageProcessor.from_pretrained(
+                str(local_model_dir),
+                cache_dir=os.environ.get("HF_HOME"),
+                local_files_only=True,
+                force_download=False,
+                use_fast=True,  # Use fast processor to avoid warning
+            )
+            self.model_name = str(local_model_dir)
+        except Exception as e:
+            raise RuntimeError(
+                "Failed to load local model from 'models/prithivMLmods/Food-101-93M': "
+                f"{str(e)}"
+            )
+
+    def classify(self, image: bytes) -> int:
+        pil_image = Image.open(io.BytesIO(image)).convert("RGB")
+        inputs = self.processor(images=pil_image, return_tensors="pt")
+
+        with torch.no_grad():
+            outputs = self.model(**inputs)
+            logits = outputs.logits
+            probs = torch.nn.functional.softmax(logits, dim=1).squeeze()
+
+        predicted_idx = torch.argmax(probs).item()
+        return predicted_idx

src/models/resnet18.py

@@ -0,0 +1,63 @@
+import torch
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from PIL import Image
+import io
+import os
+from pathlib import Path
+
+from src.models.food_classification_model import FoodClassificationModel
+
+
+class Resnet18(FoodClassificationModel):
+    """
+    Interface for accessing the Resnet-18 model architecture.
+    See the base model here: https://huggingface.co/microsoft/resnet-18.
+    """
+
+    def __init__(
+        self,
+        preprocessor_path: str = "microsoft/resnet-18",
+        model_path: str = "microsoft/resnet-18",
+    ):
+        """
+        Prefer loading from a local snapshot under models/microsoft/resnet-18.
+        If the local snapshot doesn't exist, prompt the user to download it via Makefile.
+        """
+
+        # Resolve repo root and local model dir
+        repo_root = Path(__file__).resolve().parents[2]
+        local_model_dir = repo_root / "models" / "microsoft" / "resnet-18"
+
+        # Check if a local HF snapshot exists (config + weights)
+        local_exists = local_model_dir.exists() and (
+            (local_model_dir / "pytorch_model.bin").exists()
+            or (local_model_dir / "model.safetensors").exists()
+        )
+
+        if not local_exists:
+            make_cmd = "make download-hf-model MODEL_PATH=microsoft/resnet-18"
+            raise RuntimeError(
+                "Local model not found at 'models/microsoft/resnet-18'. "
+                "Please download it first using:\n"
+                f"  {make_cmd}\n"
+                "After download completes, re-run your program."
+            )
+
+        # Load from local folder
+        self.image_processor = AutoImageProcessor.from_pretrained(str(local_model_dir))
+        self.model = AutoModelForImageClassification.from_pretrained(
+            str(local_model_dir)
+        )
+
+    def classify(self, image: bytes) -> int:
+        pil_image = Image.open(io.BytesIO(image))
+        inputs = self.image_processor(pil_image, return_tensors="pt")
+
+        with torch.no_grad():
+            logits = self.model(**inputs).logits
+
+        # model predicts one of the 101 Food-101 classes (if fine-tuned for Food-101).
+        # If using the default microsoft/resnet-18 weights, this will predict one
+        # of the 1000 ImageNet classes, not Food-101.
+        predicted_label = logits.argmax(-1).item()
+        return predicted_label

src/models/vgg16.py

@@ -0,0 +1,130 @@
+import torch
+import torch.nn as nn
+import torchvision.transforms as transforms
+import torchvision.models as models
+from PIL import Image
+import io
+from pathlib import Path
+from typing import Dict, Any
+from src.models.food_classification_model import FoodClassificationModel
+
+
+class VGG16(FoodClassificationModel):
+    """Interface for accessing the VGG-16 model architecture."""
+
+    def __init__(self, weights: str = "IMAGENET1K_V1", num_classes: int = 101):
+        """
+        Initialize VGG-16. Prefer loading local fine-tuned weights if available.
+
+        Priority:
+        1) Load ImageNet base and replace classifier, then load local fine-tuned checkpoint
+           from <repo_root>/models/vgg16/vgg16-397923af.pth (if exists).
+        2) Otherwise, fall back to ImageNet weights only (not Food-101 trained), and
+           instruct user to provide or train a .pth for Food-101 fine-tuning.
+        """
+        repo_root = Path(__file__).resolve().parents[2]
+        local_weights = repo_root / "models" / "vgg16/vgg16-397923af.pth"
+
+        # Base model with ImageNet weights
+        self.model = models.vgg16(weights=weights)
+
+        num_features = self.model.classifier[6].in_features
+        self.model.classifier[6] = nn.Linear(num_features, num_classes)
+
+        # If local fine-tuned weights exist, load them
+        if local_weights.exists():
+            try:
+                raw_ckpt: Dict[str, Any] = torch.load(local_weights, map_location="cpu")
+
+                # Unwrap common checkpoint formats
+                if isinstance(raw_ckpt, dict) and "state_dict" in raw_ckpt:
+                    ckpt = raw_ckpt["state_dict"]
+                else:
+                    ckpt = raw_ckpt
+
+                # Normalize key prefixes commonly introduced by wrappers
+                def strip_prefix(
+                    sd: Dict[str, torch.Tensor], prefix: str
+                ) -> Dict[str, torch.Tensor]:
+                    if all(k.startswith(prefix) for k in sd.keys()):
+                        return {k[len(prefix) :]: v for k, v in sd.items()}
+                    return sd
+
+                for p in ("module.", "model.", "net."):
+                    ckpt = strip_prefix(ckpt, p)
+
+                # Filter out mismatched keys (e.g., classifier.6 for 1000->101 classes)
+                model_sd = self.model.state_dict()
+                filtered_ckpt = {}
+                skipped = []
+                for k, v in ckpt.items():
+                    if k in model_sd and isinstance(v, torch.Tensor):
+                        if model_sd[k].shape == v.shape:
+                            filtered_ckpt[k] = v
+                        else:
+                            skipped.append(
+                                (k, tuple(v.shape), tuple(model_sd[k].shape))
+                            )
+                    # Silently ignore keys not present in the current model
+
+                missing_before = set(model_sd.keys()) - set(filtered_ckpt.keys())
+                self.model.load_state_dict(filtered_ckpt, strict=False)
+
+                # Optional: print a brief summary to logs for transparency
+                if skipped:
+                    skipped_str = ", ".join(
+                        [f"{k}: {src} -> {dst}" for k, src, dst in skipped[:5]]
+                    )
+                    more = "" if len(skipped) <= 5 else f" (+{len(skipped)-5} more)"
+                    print(
+                        f"[VGG16] Partially loaded checkpoint from '{local_weights}'. "
+                        f"Skipped mismatched keys: {skipped_str}{more}"
+                    )
+
+                if (
+                    "classifier.6.weight" in missing_before
+                    or "classifier.6.bias" in missing_before
+                ):
+                    print(
+                        "[VGG16] Final classifier layer initialized for 101 classes and was not loaded from checkpoint."
+                    )
+
+            except Exception as e:
+                raise RuntimeError(
+                    f"Failed to load local VGG16 weights from '{local_weights}': {e}"
+                )
+        else:
+            # No local fine-tuned weights: keep ImageNet weights but warn with action
+            raise RuntimeError(
+                "Local fine-tuned weights not found at 'models/vgg16/vgg16-397923af.pth'.\n"
+                "Please place your fine-tuned checkpoint there, or train/export one.\n"
+                "Alternatively, switch to a HF model with a Makefile download target."
+            )
+
+        self.model.eval()
+
+        self.transform = transforms.Compose(
+            [
+                transforms.Resize(256),
+                transforms.CenterCrop(224),
+                transforms.ToTensor(),
+                transforms.Normalize(
+                    mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
+                ),
+            ]
+        )
+
+    def classify(self, image: bytes) -> int:
+        pil_image = Image.open(io.BytesIO(image))
+
+        if pil_image.mode != "RGB":
+            pil_image = pil_image.convert("RGB")
+
+        input_tensor = self.transform(pil_image)
+        input_batch = input_tensor.unsqueeze(0)  # Add batch dimension
+
+        with torch.no_grad():
+            outputs = self.model(input_batch)
+            predicted_idx = torch.argmax(outputs).item()
+
+        return predicted_idx