Upload 7 files

.gitattributes

@@ -33,3 +33,7 @@ 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
+example_images/BMW.jpg filter=lfs diff=lfs merge=lfs -text
+example_images/Dodge.jpg filter=lfs diff=lfs merge=lfs -text
+example_images/Ferrari.jpg filter=lfs diff=lfs merge=lfs -text
+example_images/Porsche.jpg filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,163 @@
+import gradio as gr
+from transformers import pipeline
+import openai
+import base64
+import os
+import json
+
+# ---------------------------------------------------------------------------
+# Car brands — must match the classes the ViT model was trained on
+# ---------------------------------------------------------------------------
+CAR_BRANDS = ['BMW', 'Ferrari', 'Ford', 'Jeep', 'Lamborghini', 'Porsche', 'Rolls-Royce', 'Toyota']
+
+# ---------------------------------------------------------------------------
+# Load models (loaded once at startup)
+# ---------------------------------------------------------------------------
+
+# Custom fine-tuned ViT model (trained on Stanford Cars, 8 brand classes)
+# Replace with your actual Hugging Face model ID after training and pushing
+vit_classifier = pipeline(
+    "image-classification",
+    model="nenzilea/car-classification"
+)
+
+# CLIP zero-shot classifier
+clip_classifier = pipeline(
+    model="openai/clip-vit-large-patch14",
+    task="zero-shot-image-classification"
+)
+
+# ---------------------------------------------------------------------------
+# OpenAI helper
+# ---------------------------------------------------------------------------
+
+def encode_image_to_base64(image_path: str) -> str:
+    with open(image_path, "rb") as f:
+        return base64.b64encode(f.read()).decode("utf-8")
+
+
+def classify_with_openai(image_path: str) -> dict:
+    """Send image to GPT-4o and ask it to return confidence scores per brand."""
+    api_key = os.environ.get("OPENAI_API_KEY")
+    client = openai.OpenAI(api_key=api_key)
+
+    ext = os.path.splitext(image_path)[1].lower().lstrip(".")
+    mime_type = "image/jpeg" if ext in ("jpg", "jpeg") else f"image/{ext}"
+    base64_image = encode_image_to_base64(image_path)
+
+    prompt = (
+        f"You are a car classification expert. Classify the car brand shown in this image. "
+        f"The possible classes are: {', '.join(CAR_BRANDS)}. "
+        "Respond ONLY with a valid JSON object where each key is a brand name from the list and "
+        "each value is a confidence score between 0.0 and 1.0. All scores must sum to 1.0. "
+        'Example format: {"BMW": 0.05, "Ferrari": 0.85, "Ford": 0.02, ...}'
+    )
+
+    response = client.chat.completions.create(
+        model="gpt-4o",
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": prompt},
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:{mime_type};base64,{base64_image}"},
+                    },
+                ],
+            }
+        ],
+        max_tokens=300,
+    )
+
+    text = response.choices[0].message.content
+    try:
+        start = text.find("{")
+        end = text.rfind("}") + 1
+        scores = json.loads(text[start:end])
+        return {brand: float(scores.get(brand, 0.0)) for brand in CAR_BRANDS}
+    except Exception:
+        uniform = 1.0 / len(CAR_BRANDS)
+        return {brand: uniform for brand in CAR_BRANDS}
+
+
+# ---------------------------------------------------------------------------
+# Main classification function
+# ---------------------------------------------------------------------------
+
+def classify_car(image):
+    if image is None:
+        return {}, {}, {}
+
+    # Custom ViT — fine-tuned on Stanford Cars
+    vit_results = vit_classifier(image, top_k=len(CAR_BRANDS))
+    vit_output = {r["label"]: round(r["score"], 4) for r in vit_results}
+
+    # CLIP — zero-shot with brand names as candidate labels
+    clip_results = clip_classifier(image, candidate_labels=CAR_BRANDS)
+    clip_output = {r["label"]: round(r["score"], 4) for r in clip_results}
+
+    # OpenAI GPT-4o Vision
+    openai_output = classify_with_openai(image)
+
+    return vit_output, clip_output, openai_output
+
+
+# ---------------------------------------------------------------------------
+# Example images (add representative car images to example_images/)
+# ---------------------------------------------------------------------------
+
+example_images = [
+    ["example_images/ferrari.jpg"],
+    ["example_images/lamborghini.jpg"],
+    ["example_images/bmw.jpg"],
+    ["example_images/jeep.jpg"],
+    ["example_images/ford.jpg"],
+    ["example_images/toyota.jpg"],
+    ["example_images/porsche.jpg"],
+    ["example_images/rolls_royce.jpg"],
+]
+
+# ---------------------------------------------------------------------------
+# Gradio UI
+# ---------------------------------------------------------------------------
+
+with gr.Blocks(title="Car Brand Classification Comparison") as demo:
+    gr.Markdown("# Car Brand Classification — Model Comparison")
+    gr.Markdown(
+        "Upload a car image to compare predictions from three different models:\n\n"
+        "- **Custom ViT** — fine-tuned on Stanford Cars (8 brand classes)\n"
+        "- **CLIP** — zero-shot classification with `openai/clip-vit-large-patch14`\n"
+        "- **OpenAI GPT-4o** — vision LLM classification\n\n"
+        f"**Classes:** {', '.join(CAR_BRANDS)}"
+    )
+
+    with gr.Row():
+        input_image = gr.Image(type="filepath", label="Upload Car Image")
+
+    classify_btn = gr.Button("Classify", variant="primary")
+
+    with gr.Row():
+        with gr.Column():
+            gr.Markdown("### Custom ViT Model")
+            vit_output = gr.Label(num_top_classes=8, label="ViT Predictions")
+        with gr.Column():
+            gr.Markdown("### CLIP Zero-Shot")
+            clip_output = gr.Label(num_top_classes=8, label="CLIP Predictions")
+        with gr.Column():
+            gr.Markdown("### OpenAI GPT-4o Vision")
+            openai_output = gr.Label(num_top_classes=8, label="OpenAI Predictions")
+
+    classify_btn.click(
+        fn=classify_car,
+        inputs=[input_image],
+        outputs=[vit_output, clip_output, openai_output],
+    )
+
+    gr.Examples(
+        examples=example_images,
+        inputs=input_image,
+        label="Example Images",
+    )
+
+demo.launch()

readme_.md

@@ -0,0 +1,71 @@
+# Car Brand Classification App
+
+This app compares 3 image classification approaches on car images:
+
+- Fine-tuned ViT model ([`nenzilea/car-classification`](https://huggingface.co/nenzilea/car-classification))
+- Zero-shot CLIP (`openai/clip-vit-large-patch14`)
+- OpenAI vision model (GPT-4o image classification)
+
+## Dataset Used For Training
+
+- Hugging Face dataset: `tanganke/stanford_cars`
+- The Stanford Cars dataset contains **196 fine-grained classes** (car make/model/year combinations). We group them into **8 brand-level classes** for a cleaner, more visually meaningful classification task.
+- Number of classes: `8`
+- Classes: `BMW`, `Ferrari`, `Ford`, `Jeep`, `Lamborghini`, `Porsche`, `Rolls-Royce`, `Toyota`
+
+### Preprocessing Steps
+
+1. **Brand extraction** — each of the 196 Stanford Cars class names (e.g. `"Ferrari 458 Italia Coupe 2012"`) is mapped to one of 8 brands by substring matching.
+2. **Filtering** — images whose class does not belong to the 8 brands are removed from the dataset.
+3. **Label remapping** — original integer labels (0–195) are re-mapped to brand indices (0–7).
+4. **Train/validation/test split** — the original training split is divided 80/10/10 (train/validation/test) using `train_test_split(test_size=0.2, seed=42)`.
+5. **Image preprocessing** — images are resized to 224×224 and pixel values are normalised to [-1, 1] using `AutoImageProcessor` from `google/vit-base-patch16-224`.
+6. **RGB conversion** — all images are converted to RGB to handle any grayscale or RGBA edge cases.
+
+## Trained Model
+
+- Hugging Face model link: [https://huggingface.co/nenzilea/car-classification](https://huggingface.co/nenzilea/car-classification)
+- Base model: `google/vit-base-patch16-224`
+- Only the final classification head was fine-tuned (all other layers frozen).
+- Trainable parameters: ~4,614 out of ~85.8M total.
+
+## Training Performance
+
+| Training Loss | Epoch | Step | Validation Loss | Accuracy |
+|---:|---:|---:|---:|---:|
+| — | 1.0 | — | — | — |
+| — | 2.0 | — | — | — |
+| — | 3.0 | — | — | — |
+| — | 4.0 | — | — | — |
+| — | 5.0 | — | — | — |
+
+> Fill in the table above with the values printed by the Trainer during training.
+
+## Hugging Face Space
+
+- App link: [https://huggingface.co/spaces/nenzilea/car-classification](https://huggingface.co/spaces/nenzilea/car-classification)
+
+## Example Image Results
+
+The table below reports the true class and Top-3 predictions for ViT, CLIP, and GPT-4o.
+
+| Image | True Class | ViT Top-3 (score) | CLIP Top-3 (score) | OpenAI GPT-4o (label, confidence) |
+|---|---|---|---|---|
+| `ferrari.jpg` | `Ferrari` | — | — | — |
+| `lamborghini.jpg` | `Lamborghini` | — | — | — |
+| `bmw.jpg` | `BMW` | — | — | — |
+| `jeep.jpg` | `Jeep` | — | — | — |
+| `ford.jpg` | `Ford` | — | — | — |
+| `toyota.jpg` | `Toyota` | — | — | — |
+| `porsche.jpg` | `Porsche` | — | — | — |
+| `rolls_royce.jpg` | `Rolls-Royce` | — | — | — |
+
+> Fill in the table above after running the app with the example images.
+
+## Model Comparison Summary
+
+| Model | Approach | Strengths | Weaknesses |
+|---|---|---|---|
+| **Custom ViT** | Supervised fine-tuning on 8 car brands | High accuracy on known brands | Only classifies the 8 trained brands |
+| **CLIP** | Zero-shot with brand name as text prompt | No training needed, flexible labels | Lower accuracy; may confuse visually similar brands |
+| **OpenAI GPT-4o** | LLM vision with natural language prompt | Strong reasoning, handles unusual angles | API cost, latency, black-box |

requirements.txt

@@ -0,0 +1,5 @@
+transformers
+torch
+gradio
+openai
+Pillow