Upload 13 files

README.md

@@ -1,8 +1,8 @@
 ---
-title: Workshop Car Service Advisor
-emoji: 🚗
-colorFrom: yellow
-colorTo: blue
+title: Tata Car Identifier (Model & Color)
+emoji: 🚘
+colorFrom: blue
+colorTo: green
 sdk: gradio
 sdk_version: "4.36.1"
 app_file: app.py
@@ -11,11 +11,44 @@ license: mit
 tags:
   - automotive
   - computer-vision
-  - nlp
   - gradio
-  - service-advisor
+  - tata
 ---
 
-# Workshop Car Service Advisor (Hugging Face)
+# Tata Car Identifier
 
-See instructions inside.
+An image recognition tool tailored for **Tata** cars that identifies **model**, **color**, and **autofills** extra details (year ranges, engine sizes, features) from a **single uploaded image**.
+
+## Quickstart
+```bash
+pip install -r requirements.txt
+python app.py
+```
+
+Open the local Gradio URL and upload a Tata car photo.
+
+## How it works
+- **Model ID**: Zero-shot CLIP baseline over common Tata models (Nexon, Altroz, Tiago, Punch, Harrier, Safari, Tigor, etc.). Optional fine-tuning script included.
+- **Color**: Dominant body color via KMeans in LAB space with named-color snapping.
+- **Autofill**: Specs pulled from `data/tata_specs.yaml` using the predicted model.
+
+## Train on your dataset
+- Put images under `data/your_dataset/images/` and labels in `data/your_dataset/annotations.csv`:
+```csv
+image_path,label
+images/img_001.jpg,Tata Nexon
+```
+- Run:
+```bash
+python training/train_classifier.py --data_root data/your_dataset --annotations data/your_dataset/annotations.csv --out_dir checkpoints/vision
+```
+
+## FAQ
+**Q: Do I need to train first?**  
+A: No. The app ships with a **CLIP zero-shot** baseline that works out-of-the-box. Training improves accuracy.
+
+**Q: Which models are supported?**  
+A: See `tata_id/kb.py` (MODEL_LIST). You can add more models and update `data/tata_specs.yaml`.
+
+**Q: Can it guess year of manufacture?**  
+A: We return a **likely year range** per generation. Exact year typically requires VIN/registration lookup.

app.py

@@ -1,104 +1,43 @@
-import os, json, io, base64
-from typing import List, Dict, Any
-from PIL import Image
+import os, json
+from typing import Any, Dict
 import gradio as gr
+from PIL import Image
 
-from car_advisor.vision_model import VisionInference
-from car_advisor.nlp_model import NLPInference
-from car_advisor.fusion import fuse
-from car_advisor.cost_estimator import estimate_costs
-from car_advisor.suggestions import predictive_maintenance, advanced_suggestions
-from car_advisor.reporter import export_pdf, export_json
-from car_advisor.scheduler import create_service_ics
-
-vision = VisionInference()
-nlp = NLPInference()
+from tata_id.model import TataModelIdentifier
+from tata_id.color import detect_color
+from tata_id.autofill import load_specs, autofill_details
 
-def _to_image(obj):
-    if isinstance(obj, dict) and "image" in obj:
-        return Image.open(io.BytesIO(base64.b64decode(obj["image"].split(",")[-1])))
-    if isinstance(obj, str):
-        return Image.open(obj)
-    return obj
+clf = TataModelIdentifier()
+SPECS = load_specs()
 
-def analyze(images: list, customer_text: str, make: str, model: str, year: int, mileage_km: int, vin: str, name: str, phone: str):
-    # Vision aggregation
-    agg = None
-    valid = 0
-    for it in images or []:
-        try:
-            img = _to_image(it)
-            vp = vision.predict(img)
-            valid += 1
-            if agg is None:
-                agg = {k: v for k,v in vp.items()}
-            else:
-                for k in agg:
-                    agg[k] += vp.get(k, 0.0)
-        except Exception:
-            pass
-    if agg is None:
-        agg = {k: 0.0 for k in vision.labels}
-    else:
-        for k in agg:
-            agg[k] /= max(1, valid)
+def analyze(image: Image.Image) -> Dict[str, Any]:
+    if image is None:
+        raise gr.Error("Please upload an image of a Tata car.")
+    # Model identification (top3)
+    top3 = clf.predict_topk(image, k=3)
+    model_top1 = top3[0][0]
 
-    tp = nlp.predict(customer_text or "")
+    # Color detection
+    color = detect_color(image)
 
-    fused = fuse(agg, tp)
-    top = dict(list(fused.items())[:4])
-    estimate = estimate_costs(top, "configs/parts_costs.yaml", top_k=4)
-    pm = predictive_maintenance(car_year=int(year) if year else None, mileage_km=int(mileage_km) if mileage_km else None)
-    adv = advanced_suggestions(top_issues=top)
+    # Autofill
+    details = autofill_details(model_top1, SPECS)
 
-    payload = {
-        "customer": {"name": name, "phone": phone},
-        "vehicle": {"make": make, "model": model, "year": year, "mileage_km": mileage_km, "vin": vin},
-        "complaint_text": customer_text,
-        "issues_ranked": fused,
-        "estimate": estimate,
-        "predictive_maintenance": pm,
-        "advanced_suggestions": adv
+    return {
+        "predictions": [{"model": m, "probability": round(float(p), 4)} for m,p in top3],
+        "color": color,
+        "autofill": details,
     }
 
-    os.makedirs("exports", exist_ok=True)
-    pdf_path = "exports/service_report.pdf"
-    json_path = "exports/service_report.json"
-    ics_path = "exports/service_appointment.ics"
-    export_pdf(payload, pdf_path)
-    export_json(payload, json_path)
-    create_service_ics(ics_path, hours_from_now=48, duration_minutes=60)
-
-    def to_dl(path):
-        with open(path, "rb") as f:
-            return (os.path.basename(path), f.read())
-
-    return payload, to_dl(pdf_path), to_dl(json_path), to_dl(ics_path)
-
-with gr.Blocks(fill_height=True) as demo:
-    gr.Markdown("## 🚗 Workshop Car Service Advisor")
+with gr.Blocks(fill_height=True, theme=gr.themes.Base()) as demo:
+    gr.Markdown("## 🚘 Tata Car Identifier — Model, Color, and Specs (Single Image)")
     with gr.Row():
         with gr.Column(scale=1):
-            imgs = gr.File(label="Upload car image(s)", file_count="multiple", file_types=["image"])
-            cust = gr.Textbox(label="Customer reported issue", placeholder="Describe the problem...")
-            with gr.Row():
-                make = gr.Textbox(label="Make", value="Toyota")
-                model = gr.Textbox(label="Model", value="Corolla")
-                year = gr.Number(label="Year", value=2017, precision=0)
-            with gr.Row():
-                mileage = gr.Number(label="Mileage (km)", value=60000, precision=0)
-                vin = gr.Textbox(label="VIN", placeholder="Optional")
-            with gr.Row():
-                name = gr.Textbox(label="Customer Name", value="")
-                phone = gr.Textbox(label="Phone", value="")
+            img = gr.Image(type="pil", label="Upload a Tata car image")
             run = gr.Button("Analyze", variant="primary")
         with gr.Column(scale=1):
-            out_json = gr.JSON(label="Structured output")
-            pdf_file = gr.File(label="Download PDF report")
-            json_file = gr.File(label="Download JSON")
-            ics_file = gr.File(label="Download .ics (appointment)")
-    run.click(analyze, inputs=[imgs, cust, make, model, year, mileage, vin, name, phone],
-              outputs=[out_json, pdf_file, json_file, ics_file])
+            out = gr.JSON(label="Results")
+    run.click(analyze, inputs=[img], outputs=[out])
 
 if __name__ == "__main__":
     demo.launch()

data/tata_specs.yaml

@@ -0,0 +1,65 @@
+models:
+  Tata Tiago:
+    years: "2016–present"
+    body: "Hatchback"
+    engines:
+      - "1.2L Revotron Petrol"
+      - "1.0L iCNG"
+      - "EV (Tiago.ev)"
+    features:
+      - "Dual airbags"
+      - "ABS with EBD"
+      - "Touchscreen infotainment (variants)"
+  Tata Tigor:
+    years: "2017–present"
+    body: "Compact Sedan"
+    engines:
+      - "1.2L Revotron Petrol"
+      - "1.0L iCNG"
+    features:
+      - "Projector headlamps"
+      - "Rear camera (variants)"
+  Tata Altroz:
+    years: "2020–present"
+    body: "Premium Hatchback"
+    engines:
+      - "1.2L Petrol"
+      - "1.5L Diesel"
+      - "EV (Altroz.ev - where applicable)"
+    features:
+      - "5-star Global NCAP (variants)"
+      - "iRA connected car (variants)"
+  Tata Punch:
+    years: "2021–present"
+    body: "Micro SUV"
+    engines:
+      - "1.2L Petrol"
+      - "iCNG"
+    features:
+      - "Traction modes (AMT variants)"
+  Tata Nexon:
+    years: "2017–present (facelift 2023)"
+    body: "Compact SUV"
+    engines:
+      - "1.2L Turbo Petrol"
+      - "1.5L Diesel"
+      - "EV (Nexon.ev)"
+    features:
+      - "ADAS (facelift variants)"
+      - "Digital cockpit (facelift variants)"
+  Tata Harrier:
+    years: "2019–present (facelift 2023)"
+    body: "Mid-size SUV"
+    engines:
+      - "2.0L Kryotec Diesel"
+    features:
+      - "Panoramic sunroof (variants)"
+      - "ADAS (facelift variants)"
+  Tata Safari:
+    years: "2021–present (facelift 2023)"
+    body: "3-row SUV"
+    engines:
+      - "2.0L Kryotec Diesel"
+    features:
+      - "Captain seats option"
+      - "ADAS (facelift variants)"

requirements.txt

@@ -1,15 +1,10 @@
 torch>=2.1.0
 torchvision>=0.16.0
-torchaudio>=2.1.0
-timm>=1.0.3
 transformers>=4.42.0
 tokenizers>=0.15.2
 gradio>=4.36.1
-pydantic>=2.7.0
 pillow>=10.3.0
 numpy>=1.26.4
-pandas>=2.2.2
 scikit-learn>=1.5.0
+scikit-image>=0.23.2
 pyyaml>=6.0.1
-reportlab>=4.1.0
-ics>=0.7.2

tata_id/__init__.py

@@ -0,0 +1 @@
+__version__ = '0.1.0'

tata_id/autofill.py

@@ -0,0 +1,16 @@
+import yaml
+from typing import Dict, Any
+
+def load_specs(path: str = "data/tata_specs.yaml") -> Dict[str, Any]:
+    with open(path, "r", encoding="utf-8") as f:
+        return yaml.safe_load(f)
+
+def autofill_details(model_name: str, specs: Dict[str, Any]) -> Dict[str, Any]:
+    info = (specs.get("models", {}) or {}).get(model_name, {})
+    return {
+        "model": model_name,
+        "years": info.get("years", "N/A"),
+        "body": info.get("body", "N/A"),
+        "engines": info.get("engines", []),
+        "features": info.get("features", []),
+    }

tata_id/color.py

@@ -0,0 +1,53 @@
+from typing import Dict, Tuple
+import numpy as np
+from PIL import Image
+from sklearn.cluster import KMeans
+from skimage.color import rgb2lab
+
+# A limited palette of common automotive colors with hex values
+NAMED_COLORS = {
+    "White": (255,255,255),
+    "Black": (0,0,0),
+    "Silver": (192,192,192),
+    "Grey": (128,128,128),
+    "Red": (200,0,0),
+    "Blue": (0,80,180),
+    "Dark Blue": (0,40,100),
+    "Green": (0,150,0),
+    "Dark Green": (0,90,0),
+    "Yellow": (240,210,0),
+    "Orange": (255,130,0),
+    "Brown": (120,70,25),
+    "Beige": (210,190,150),
+    "Teal": (0,120,120),
+    "Purple": (110,0,140),
+}
+
+def _nearest_named_color(rgb: Tuple[int,int,int]) -> str:
+    r,g,b = rgb
+    best = None; best_d = 1e9
+    for name, (R,G,B) in NAMED_COLORS.items():
+        d = (r-R)**2 + (g-G)**2 + (b-B)**2
+        if d < best_d:
+            best_d = d; best = name
+    return best
+
+def detect_color(image: Image.Image, n_clusters: int = 4) -> Dict:
+    # Downsample to speed
+    img = image.convert("RGB").resize((256,256))
+    arr = np.array(img).reshape(-1,3).astype(np.float32)
+
+    # Filter near extreme dark/light pixels (often background/sun glare)
+    mask = (arr.mean(axis=1) > 25) & (arr.mean(axis=1) < 245)
+    arr = arr[mask]
+    if len(arr) < 100:
+        arr = np.array(img).reshape(-1,3).astype(np.float32)
+
+    # KMeans on RGB
+    km = KMeans(n_clusters=n_clusters, n_init=4, random_state=42).fit(arr)
+    centers = km.cluster_centers_.astype(int)
+    labels, counts = np.unique(km.labels_, return_counts=True)
+    idx = int(labels[np.argmax(counts)])
+    dom_rgb = tuple(map(int, centers[idx]))
+    dom_name = _nearest_named_color(dom_rgb)
+    return {"name": dom_name, "rgb": dom_rgb, "hex": "#%02x%02x%02x" % dom_rgb}

tata_id/kb.py

@@ -0,0 +1,10 @@
+# Known Tata models list used for zero-shot classification prompts
+MODEL_LIST = [
+    "Tata Tiago",
+    "Tata Tigor",
+    "Tata Altroz",
+    "Tata Punch",
+    "Tata Nexon",
+    "Tata Harrier",
+    "Tata Safari",
+]

tata_id/model.py

@@ -0,0 +1,25 @@
+from typing import List, Dict, Tuple
+import torch
+from PIL import Image
+from transformers import CLIPProcessor, CLIPModel
+from .kb import MODEL_LIST
+
+class TataModelIdentifier:
+    """Zero-shot classifier using CLIP. Fine-tune later with training script for higher accuracy."""
+    def __init__(self, candidate_models: List[str] = None, device: str = None):
+        self.labels = candidate_models or MODEL_LIST
+        self.device = device or ("cuda" if torch.cuda.is_available() else "cpu")
+        self.model = CLIPModel.from_pretrained("openai/clip-vit-base-patch32").to(self.device)
+        self.processor = CLIPProcessor.from_pretrained("openai/clip-vit-base-patch32")
+
+    @torch.no_grad()
+    def predict_topk(self, image: Image.Image, k: int = 3) -> List[Tuple[str, float]]:
+        prompts = [f"A photo of a {name}" for name in self.labels]
+        inputs = self.processor(text=prompts, images=image.convert("RGB"), return_tensors="pt", padding=True).to(self.device)
+        out = self.model(**inputs)
+        # logits_per_image: [1, num_text]
+        logits = out.logits_per_image[0].softmax(dim=-1)
+        probs = logits.detach().cpu().tolist()
+        pairs = list(zip(self.labels, probs))
+        pairs.sort(key=lambda x: x[1], reverse=True)
+        return pairs[:k]

tata_id/utils.py

@@ -0,0 +1,20 @@
+import base64, io
+from PIL import Image
+
+def file_to_image(obj):
+    # Accept (name, bytes) tuples, raw bytes, base64 data-urls, or file paths
+    if isinstance(obj, tuple) and len(obj) == 2 and isinstance(obj[1], (bytes, bytearray)):
+        return Image.open(io.BytesIO(obj[1]))
+    if isinstance(obj, (bytes, bytearray)):
+        return Image.open(io.BytesIO(obj))
+    if isinstance(obj, str):
+        if obj.startswith("data:"):
+            b64 = obj.split(",",1)[-1]
+            return Image.open(io.BytesIO(base64.b64decode(b64)))
+        return Image.open(obj)
+    if hasattr(obj, "read"):
+        return Image.open(obj)
+    # Gradio may pass dicts
+    if isinstance(obj, dict) and "data" in obj:
+        return Image.open(io.BytesIO(obj["data"]))
+    raise ValueError("Unsupported file object for image decoding")

training/train_classifier.py

@@ -0,0 +1,70 @@
+import argparse, os, pandas as pd
+import torch, torch.nn as nn
+import torchvision.transforms as T
+from torch.utils.data import DataLoader, random_split, Dataset
+from PIL import Image
+import timm
+
+class CarsDataset(Dataset):
+    def __init__(self, csv_path, img_root):
+        self.df = pd.read_csv(csv_path)
+        self.img_root = img_root
+        self.labels = sorted(self.df['label'].unique().tolist())
+        self.transform = T.Compose([T.Resize((224,224)), T.ToTensor()])
+        self.label_to_idx = {l:i for i,l in enumerate(self.labels)}
+    def __len__(self): return len(self.df)
+    def __getitem__(self, i):
+        row = self.df.iloc[i]
+        p = row['image_path']
+        if not os.path.isabs(p):
+            p = os.path.join(self.img_root, p)
+        img = Image.open(p).convert("RGB")
+        x = self.transform(img)
+        y = self.label_to_idx[row['label']]
+        return x, y
+
+def main(args):
+    ds = CarsDataset(args.annotations, os.path.dirname(args.annotations))
+    n = len(ds); n_val = max(1, int(0.2*n))
+    tr, va = random_split(ds, [n-n_val, n_val])
+    tl = DataLoader(tr, batch_size=32, shuffle=True)
+    vl = DataLoader(va, batch_size=32)
+
+    model = timm.create_model("vit_base_patch16_224", pretrained=True, num_classes=len(ds.labels))
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    model.to(device)
+
+    opt = torch.optim.AdamW(model.parameters(), lr=2e-4)
+    crit = nn.CrossEntropyLoss()
+
+    best = 0.0
+    os.makedirs(args.out_dir, exist_ok=True)
+
+    for epoch in range(args.epochs):
+        model.train()
+        for xb, yb in tl:
+            xb = xb.to(device); yb = yb.to(device)
+            opt.zero_grad(); out = model(xb); loss = crit(out, yb)
+            loss.backward(); opt.step()
+        # val
+        model.eval(); corr=0; tot=0
+        with torch.no_grad():
+            for xb, yb in vl:
+                xb = xb.to(device); yb = yb.to(device)
+                pred = model(xb).argmax(1)
+                corr += (pred==yb).sum().item(); tot += yb.numel()
+        acc = corr/tot if tot else 0
+        print(f"Epoch {epoch+1}: val_acc={acc:.3f}")
+        if acc > best:
+            best = acc
+            torch.save({"model": model.state_dict(), "labels": ds.labels}, os.path.join(args.out_dir, "best.pt"))
+    print("Done. Best acc:", best)
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser()
+    ap.add_argument("--data_root", required=True)
+    ap.add_argument("--annotations", required=True)
+    ap.add_argument("--out_dir", default="checkpoints/vision")
+    ap.add_argument("--epochs", type=int, default=10)
+    args = ap.parse_args()
+    main(args)