Sync from GitHub to Hugging Face

space_repo/requirements.txt

@@ -17,3 +17,5 @@ ipython
 
 seaborn
 gitpython
+
+opencv-python-headless

space_repo/space_repo/space_repo/app.py

@@ -23,68 +23,133 @@ with open("YOLO.ipynb", "r", encoding="utf-8") as f:
     nb = nbformat.read(f, as_version=4)
 
 # ---------------------------
-# Robust: extract only the essential notebook cells and write yolo_converted.py
+# Robust dynamic extraction from YOLO.ipynb (safer)
 # ---------------------------
-import nbformat, re, runpy, os, json
-
-# indices of the important cells found in your YOLO.ipynb
-important_cell_indices = [2, 4, 6, 7]
+import re, runpy
 
 with open("YOLO.ipynb", "r", encoding="utf-8") as f:
     nb_all = nbformat.read(f, as_version=4)
 
-# safe patterns to remove (Colab magics / upload/demo lines)
+# Patterns that indicate a cell is important (we'll include any cell that matches any marker)
+IMPORTANT_MARKERS = [
+    r"torch\.hub\.load\(",          # yolo loader cell
+    r"models\.resnet18",            # classifier architecture
+    r"model\.load_state_dict",      # checkpoint load
+    r"transform\(",                 # transform definition
+    r"transforms\.",                # torchvision transforms usage
+    r"def get_color_name",          # color helper
+    r"def detect_and_classify",     # the pipeline function (must be preserved)
+    r"import numpy",                # numpy import
+    r"import torch",                # torch import
+    r"from torchvision",            # torchvision imports
+    r"from PIL import",             # PIL imports
+    r"import cv2",                  # optional cv usage
+]
+
+# Lines we will strip from included cells (Colab magics / file upload demos)
 BAD_LINE_PATTERNS = [
     r'^\s*!',         # shell commands
     r'^\s*%',         # magics
-    'google.colab',
-    'files.upload',
+    r'google\.colab',
+    r'files.upload',
     r'\buploaded\b',
     r'\bimg_path\b',
-    # note: do NOT ban 'detect_and_classify(' so the function def stays intact
 ]
 
-collected_cells = []
-for idx in important_cell_indices:
-    if idx < 0 or idx >= len(nb_all.cells):
+# Collect unique cells that match any important marker or imports
+selected_cells = []
+seen_indices = set()
+for i, cell in enumerate(nb_all.cells):
+    if cell.cell_type != "code":
         continue
-    cell = nb_all.cells[idx]
+    src = cell.source or ""
+    # include if any important marker matches
+    if any(re.search(p, src, flags=re.I) for p in IMPORTANT_MARKERS):
+        if i not in seen_indices:
+            seen_indices.add(i)
+            selected_cells.append((i, src))
+
+# If we didn't find the function, as a fallback include any cell that looks like it contains function words
+if not any("def detect_and_classify" in src for (_, src) in selected_cells):
+    for i, cell in enumerate(nb_all.cells):
+        if cell.cell_type != "code":
+            continue
+        src = cell.source or ""
+        if any(k in src.lower() for k in ["def detect", "def classify", "def predict", "detect_and_classify"]):
+            if i not in seen_indices:
+                seen_indices.add(i)
+                selected_cells.append((i, src))
+
+# Also ensure import cells appear first
+import_cells = []
+for i, cell in enumerate(nb_all.cells):
     if cell.cell_type != "code":
         continue
-    lines = []
-    for line in cell.source.splitlines():
+    src = cell.source or ""
+    if re.search(r'^\s*(import |from )', src, flags=re.M):
+        if i not in seen_indices:
+            import_cells.append((i, src))
+            seen_indices.add(i)
+
+# Sort selected cells by original order: imports first, then selected_cells by index
+selected_cells_sorted = sorted(import_cells + selected_cells, key=lambda tup: tup[0])
+
+# Clean each selected cell, but keep any cell that contains the function header intact.
+cleaned_cells = []
+for idx, src in selected_cells_sorted:
+    # If this cell contains the function definition, keep it largely intact
+    if "def detect_and_classify" in src:
+        lines = []
+        for line in src.splitlines():
+            # remove only Colab magics / shell commands, but keep everything else
+            if re.match(r'^\s*!', line) or re.match(r'^\s*%', line):
+                continue
+            # keep the def line and body exactly as-is otherwise
+            lines.append(line)
+        cleaned_src = "\n".join(lines).rstrip()
+        if cleaned_src:
+            cleaned_cells.append(cleaned_src)
+        continue
+
+    # Otherwise, perform conservative cleaning: remove magics, uploads, and *top-level* test calls
+    cleaned_lines = []
+    for line in src.splitlines():
+        # drop Colab magics / shell commands and file picker demo lines
         if any(re.search(p, line) for p in BAD_LINE_PATTERNS):
-            # skip Colab-only or demo lines inside the important cell
             continue
-        lines.append(line)
-    # only append non-empty cell content
-    if any(l.strip() for l in lines):
-        collected_cells.append("\n".join(lines))
+        # drop top-level calls to detect_and_classify() in non-function cells (prevents auto-run)
+        if re.search(r'\bdetect_and_classify\s*\(', line):
+            continue
+        cleaned_lines.append(line)
+    cleaned_src = "\n".join(cleaned_lines).rstrip()
+    if cleaned_src:
+        cleaned_cells.append(cleaned_src)
 
-# join with explicit separators (makes debugging easier)
-safe_code = "\n\n# ---- cell boundary ----\n\n".join(collected_cells)
+# Join cells into script (imports / helpers first by sorted index)
+safe_code = "\n\n# ---- cell boundary ----\n\n".join(cleaned_cells)
 
-# small normalization: remove any top-of-file stray "pass  # skipped..." left by earlier attempts
-safe_code = re.sub(r'^\s*pass  # skipped during conversion\s*', '', safe_code, count=1, flags=re.M)
-# ensure top-level code does not start with an indented 'pass'
-safe_code = re.sub(r'^[ \t]+pass  # skipped during conversion\s*$', 'pass  # skipped during conversion\n', safe_code, flags=re.M)
-
-# Ensure numpy is available (some extracted cells use np)
+# Ensure numpy is available if used
 if not re.search(r'(^|\n)\s*(import numpy\b|import numpy as\b|from numpy\b)', safe_code):
     safe_code = "import numpy as np\n\n" + safe_code
 
+# Sanitize stray placeholders
+safe_code = re.sub(r'^\s*pass  # skipped during conversion\s*', '', safe_code, count=1, flags=re.M)
+safe_code = re.sub(r'^[ \t]+pass  # skipped during conversion\s*$', 'pass  # skipped during conversion\n', safe_code, flags=re.M)
+
+# Write converted file
 with open("yolo_converted.py", "w", encoding="utf-8") as fh:
     fh.write(safe_code)
 
-# quick log (first 800 chars) to help debug in HF logs
 print("Wrote yolo_converted.py — preview:")
-print(safe_code[:800].replace("\n", "\\n"))
+print(safe_code[:1000].replace("\n", "\\n"))
+# ---------------------------
+# End dynamic extraction block
+# ---------------------------
 
-# Try to load it
+# --- Try to import and run the converted module ---
 try:
     mod = runpy.run_path("yolo_converted.py")
 except Exception as e:
-    # show snippet to help debugging
     head = ""
     try:
         with open("yolo_converted.py", "r", encoding="utf-8") as fh:
@@ -96,12 +161,8 @@ except Exception as e:
 # pull the function
 detect_and_classify = mod.get("detect_and_classify")
 if not detect_and_classify:
-    raise RuntimeError("detect_and_classify() not found in the extracted cells. Please ensure cell indices are correct.")
+    raise RuntimeError("detect_and_classify() not found in the extracted cells. Please ensure your notebook defines it.")
 print("✅ detect_and_classify() found and loaded.")
-# ---------------------------
-# End extraction block
-# ---------------------------
-
 
 # --- Load class names (optional, cached to file) ---
 try:

space_repo/space_repo/space_repo/space_repo/space_repo/app.py

@@ -24,12 +24,10 @@ with open("YOLO.ipynb", "r", encoding="utf-8") as f:
 
 # ---------------------------
 # Robust: extract only the essential notebook cells and write yolo_converted.py
-# (this block was inserted per your request)
 # ---------------------------
 import nbformat, re, runpy, os, json
 
 # indices of the important cells found in your YOLO.ipynb
-# (these came from inspecting the uploaded notebook)
 important_cell_indices = [2, 4, 6, 7]
 
 with open("YOLO.ipynb", "r", encoding="utf-8") as f:
@@ -43,6 +41,7 @@ BAD_LINE_PATTERNS = [
     'files.upload',
     r'\buploaded\b',
     r'\bimg_path\b',
+    # note: do NOT ban 'detect_and_classify(' so the function def stays intact
 ]
 
 collected_cells = []
@@ -70,6 +69,10 @@ safe_code = re.sub(r'^\s*pass  # skipped during conversion\s*', '', safe_code, c
 # ensure top-level code does not start with an indented 'pass'
 safe_code = re.sub(r'^[ \t]+pass  # skipped during conversion\s*$', 'pass  # skipped during conversion\n', safe_code, flags=re.M)
 
+# Ensure numpy is available (some extracted cells use np)
+if not re.search(r'(^|\n)\s*(import numpy\b|import numpy as\b|from numpy\b)', safe_code):
+    safe_code = "import numpy as np\n\n" + safe_code
+
 with open("yolo_converted.py", "w", encoding="utf-8") as fh:
     fh.write(safe_code)
 
@@ -96,7 +99,7 @@ if not detect_and_classify:
     raise RuntimeError("detect_and_classify() not found in the extracted cells. Please ensure cell indices are correct.")
 print("✅ detect_and_classify() found and loaded.")
 # ---------------------------
-# End inserted extraction block
+# End extraction block
 # ---------------------------
 
 

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/app.py

@@ -1,103 +1,114 @@
-# -*- coding: utf-8 -*-
-"""GradioUI.ipynb
-
-Automatically generated by Colab.
-
-Original file is located at
-    https://colab.research.google.com/drive/1gTrf304mzjGMheD47oHDhnYTIrEyf4qp
-"""
-
+# app.py - Hugging Face ready
 import os
-os.system("pip install seaborn --quiet")
+import re
+import json
+import runpy
+import nbformat
+from nbconvert import PythonExporter
 
+# Prefer dependencies via requirements.txt. Small one-off installs if needed:
+# os.system("pip install seaborn --quiet")
 
-import json
 import torch
 import gradio as gr
 from PIL import Image
-import nbformat
-from nbconvert import PythonExporter
-import runpy
 from datasets import load_dataset
 
-# --- Convert YOLO notebook to Python ---
+# --- Ensure YOLO notebook exists ---
 if not os.path.exists("YOLO.ipynb"):
     raise FileNotFoundError("YOLO.ipynb not found in app directory!")
 
-# Read YOLO.ipynb
-with open("YOLO.ipynb") as f:
+# --- Read notebook ---
+with open("YOLO.ipynb", "r", encoding="utf-8") as f:
     nb = nbformat.read(f, as_version=4)
 
-# Remove or skip Google Colab imports and magic commands (! or %) or google colab file picker
-# --- Patch the YOLO notebook code to skip testing lines safely ---
-for cell in nb.cells:
-    if cell.cell_type == "code":
-        lines = []
-        for line in cell.source.splitlines():
-            bad_patterns = [
-                "!", "%",
-                "google.colab",
-                "files.upload",
-                "uploaded",
-                "img_path",
-                "detect_and_classify(",
-                "print(",
-                "display("
-            ]
-            if any(p in line for p in bad_patterns):
-                # Keep Python structure valid (avoid empty if-blocks)
-                lines.append("    pass  # skipped during conversion")
-                continue
-            lines.append(line)
-        cell.source = "\n".join(lines)
-
-
-# --- Export cleaned notebook to Python (via nbformat export) ---
-py_exporter = PythonExporter()
-(code, _) = py_exporter.from_notebook_node(nb)
-
-# write initial converted file
-with open("yolo_converted.py", "w") as f:
-    f.write(code)
-
-# --- Post-process the generated file to fix indentation issues from removed lines ---
-import re
-
-with open("yolo_converted.py", "r") as f:
-    conv_code = f.read()
-
-# 1) Replace any lines that are only indented 'pass  # skipped during conversion'
-#    with an unindented version so they don't break top-level structure.
-conv_code = re.sub(r'^[ \t]+pass  # skipped during conversion\s*$', 'pass  # skipped during conversion\n', conv_code, flags=re.M)
-
-# 2) If any 'pass  # skipped during conversion' directly follows a top-level statement
-#    with incorrect indentation, keep them as 'pass' but ensure indentation matches previous block.
-#    (This is conservative; we only normalize leading whitespace for the placeholder)
-#    Already handled by the regex above.
-
-# 3) Remove any leading 'pass  # skipped...' at the very top of the file (if present)
-conv_code = re.sub(r'^\s*pass  # skipped during conversion\s*', '', conv_code, count=1, flags=re.M)
-
-# Save cleaned code back
-with open("yolo_converted.py", "w") as f:
-    f.write(conv_code)
+# ---------------------------
+# Robust: extract only the essential notebook cells and write yolo_converted.py
+# (this block was inserted per your request)
+# ---------------------------
+import nbformat, re, runpy, os, json
+
+# indices of the important cells found in your YOLO.ipynb
+# (these came from inspecting the uploaded notebook)
+important_cell_indices = [2, 4, 6, 7]
+
+with open("YOLO.ipynb", "r", encoding="utf-8") as f:
+    nb_all = nbformat.read(f, as_version=4)
+
+# safe patterns to remove (Colab magics / upload/demo lines)
+BAD_LINE_PATTERNS = [
+    r'^\s*!',         # shell commands
+    r'^\s*%',         # magics
+    'google.colab',
+    'files.upload',
+    r'\buploaded\b',
+    r'\bimg_path\b',
+]
+
+collected_cells = []
+for idx in important_cell_indices:
+    if idx < 0 or idx >= len(nb_all.cells):
+        continue
+    cell = nb_all.cells[idx]
+    if cell.cell_type != "code":
+        continue
+    lines = []
+    for line in cell.source.splitlines():
+        if any(re.search(p, line) for p in BAD_LINE_PATTERNS):
+            # skip Colab-only or demo lines inside the important cell
+            continue
+        lines.append(line)
+    # only append non-empty cell content
+    if any(l.strip() for l in lines):
+        collected_cells.append("\n".join(lines))
+
+# join with explicit separators (makes debugging easier)
+safe_code = "\n\n# ---- cell boundary ----\n\n".join(collected_cells)
+
+# small normalization: remove any top-of-file stray "pass  # skipped..." left by earlier attempts
+safe_code = re.sub(r'^\s*pass  # skipped during conversion\s*', '', safe_code, count=1, flags=re.M)
+# ensure top-level code does not start with an indented 'pass'
+safe_code = re.sub(r'^[ \t]+pass  # skipped during conversion\s*$', 'pass  # skipped during conversion\n', safe_code, flags=re.M)
+
+with open("yolo_converted.py", "w", encoding="utf-8") as fh:
+    fh.write(safe_code)
+
+# quick log (first 800 chars) to help debug in HF logs
+print("Wrote yolo_converted.py — preview:")
+print(safe_code[:800].replace("\n", "\\n"))
+
+# Try to load it
+try:
+    mod = runpy.run_path("yolo_converted.py")
+except Exception as e:
+    # show snippet to help debugging
+    head = ""
+    try:
+        with open("yolo_converted.py", "r", encoding="utf-8") as fh:
+            head = fh.read(2000)
+    except Exception:
+        head = "<could not read yolo_converted.py>"
+    raise RuntimeError(f"Failed to run yolo_converted.py: {e}\n--- head of converted file ---\n{head}")
 
-# --- Run the converted YOLO script ---
-mod = runpy.run_path("yolo_converted.py")
+# pull the function
 detect_and_classify = mod.get("detect_and_classify")
 if not detect_and_classify:
-    raise RuntimeError("detect_and_classify() not found in YOLO.ipynb")
+    raise RuntimeError("detect_and_classify() not found in the extracted cells. Please ensure cell indices are correct.")
+print("✅ detect_and_classify() found and loaded.")
+# ---------------------------
+# End inserted extraction block
+# ---------------------------
 
-print("✅ YOLO pipeline loaded successfully")
 
-# --- Load class names ---
+# --- Load class names (optional, cached to file) ---
 try:
     ds = load_dataset("tanganke/stanford_cars")
     class_names = ds["train"].features["label"].names
-    with open("class_names.json", "w") as f:
+    with open("class_names.json", "w", encoding="utf-8") as f:
         json.dump(class_names, f)
+    print(f"✅ Loaded {len(class_names)} class names")
 except Exception as e:
-    print("Warning: Could not load dataset class names.", e)
+    print("⚠️ Could not load dataset class names:", e)
     class_names = None
 
 # --- Gradio UI ---
@@ -106,24 +117,28 @@ def gradio_interface(image):
         return "Please upload an image."
     temp_path = "temp_image.png"
     image.save(temp_path)
-
     try:
         results = detect_and_classify(temp_path)
     except Exception as e:
         return f"❌ Error running YOLO pipeline: {e}"
     finally:
-        os.remove(temp_path)
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
 
     if not results:
         return "No cars detected."
 
     lines = [f"Cars detected: {len(results)}"]
     for i, item in enumerate(results, start=1):
-        if len(item) == 4:
-            crop, pred, color, conf = item
-        else:
-            crop, pred, color = item
+        # item may be (crop, pred_idx, color) or (crop, pred_idx, color, conf)
+        if isinstance(item, (list, tuple)) and len(item) == 4:
+            _, pred, color, conf = item
+        elif isinstance(item, (list, tuple)) and len(item) >= 3:
+            _, pred, color = item[:3]
             conf = None
+        else:
+            lines.append(f"Car {i}: {item}")
+            continue
 
         if isinstance(pred, int) and class_names and 0 <= pred < len(class_names):
             name = class_names[pred]

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/requirements.txt

@@ -12,3 +12,8 @@ datasets
 
 nbformat
 nbconvert
+
+ipython
+
+seaborn
+gitpython

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/app.py

@@ -52,12 +52,36 @@ for cell in nb.cells:
         cell.source = "\n".join(lines)
 
 
-# --- Export cleaned notebook to Python ---
+# --- Export cleaned notebook to Python (via nbformat export) ---
 py_exporter = PythonExporter()
 (code, _) = py_exporter.from_notebook_node(nb)
+
+# write initial converted file
 with open("yolo_converted.py", "w") as f:
     f.write(code)
 
+# --- Post-process the generated file to fix indentation issues from removed lines ---
+import re
+
+with open("yolo_converted.py", "r") as f:
+    conv_code = f.read()
+
+# 1) Replace any lines that are only indented 'pass  # skipped during conversion'
+#    with an unindented version so they don't break top-level structure.
+conv_code = re.sub(r'^[ \t]+pass  # skipped during conversion\s*$', 'pass  # skipped during conversion\n', conv_code, flags=re.M)
+
+# 2) If any 'pass  # skipped during conversion' directly follows a top-level statement
+#    with incorrect indentation, keep them as 'pass' but ensure indentation matches previous block.
+#    (This is conservative; we only normalize leading whitespace for the placeholder)
+#    Already handled by the regex above.
+
+# 3) Remove any leading 'pass  # skipped...' at the very top of the file (if present)
+conv_code = re.sub(r'^\s*pass  # skipped during conversion\s*', '', conv_code, count=1, flags=re.M)
+
+# Save cleaned code back
+with open("yolo_converted.py", "w") as f:
+    f.write(conv_code)
+
 # --- Run the converted YOLO script ---
 mod = runpy.run_path("yolo_converted.py")
 detect_and_classify = mod.get("detect_and_classify")

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/app.py

@@ -29,28 +29,29 @@ with open("YOLO.ipynb") as f:
     nb = nbformat.read(f, as_version=4)
 
 # Remove or skip Google Colab imports and magic commands (! or %) or google colab file picker
-# --- Patch the YOLO notebook code to skip testing lines ---
+# --- Patch the YOLO notebook code to skip testing lines safely ---
 for cell in nb.cells:
     if cell.cell_type == "code":
         lines = []
         for line in cell.source.splitlines():
-                  if (
-                line.strip().startswith("!") or
-                line.strip().startswith("%") or
-                "google.colab" in line or
-                "files.upload" in line or
-                "uploaded" in line or
-                "img_path" in line or                 
-                "detect_and_classify(" in line or         # skip auto test calls
-                "print(" in line or                       # skip print-only outputs
-                "display(" in line                        # skip Jupyter displays
-            ):
+            bad_patterns = [
+                "!", "%",
+                "google.colab",
+                "files.upload",
+                "uploaded",
+                "img_path",
+                "detect_and_classify(",
+                "print(",
+                "display("
+            ]
+            if any(p in line for p in bad_patterns):
+                # Keep Python structure valid (avoid empty if-blocks)
+                lines.append("    pass  # skipped during conversion")
                 continue
             lines.append(line)
         cell.source = "\n".join(lines)
 
 
-
 # --- Export cleaned notebook to Python ---
 py_exporter = PythonExporter()
 (code, _) = py_exporter.from_notebook_node(nb)

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/app.py

@@ -29,21 +29,28 @@ with open("YOLO.ipynb") as f:
     nb = nbformat.read(f, as_version=4)
 
 # Remove or skip Google Colab imports and magic commands (! or %) or google colab file picker
+# --- Patch the YOLO notebook code to skip testing lines ---
 for cell in nb.cells:
     if cell.cell_type == "code":
         lines = []
         for line in cell.source.splitlines():
-            if (
+                  if (
                 line.strip().startswith("!") or
                 line.strip().startswith("%") or
                 "google.colab" in line or
-                "files.upload" in line
+                "files.upload" in line or
+                "uploaded" in line or
+                "img_path" in line or                 
+                "detect_and_classify(" in line or         # skip auto test calls
+                "print(" in line or                       # skip print-only outputs
+                "display(" in line                        # skip Jupyter displays
             ):
                 continue
             lines.append(line)
         cell.source = "\n".join(lines)
 
 
+
 # --- Export cleaned notebook to Python ---
 py_exporter = PythonExporter()
 (code, _) = py_exporter.from_notebook_node(nb)

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/app.py

@@ -8,6 +8,9 @@ Original file is located at
 """
 
 import os
+os.system("pip install seaborn --quiet")
+
+
 import json
 import torch
 import gradio as gr
@@ -25,15 +28,21 @@ if not os.path.exists("YOLO.ipynb"):
 with open("YOLO.ipynb") as f:
     nb = nbformat.read(f, as_version=4)
 
-# --- Clean notebook magic commands (!pip, !git, %cd, etc.) ---
+# Remove or skip Google Colab imports and magic commands (! or %) or google colab file picker
 for cell in nb.cells:
     if cell.cell_type == "code":
-        cleaned_lines = []
+        lines = []
         for line in cell.source.splitlines():
-            if line.strip().startswith(("!", "%")):
+            if (
+                line.strip().startswith("!") or
+                line.strip().startswith("%") or
+                "google.colab" in line or
+                "files.upload" in line
+            ):
                 continue
-            cleaned_lines.append(line)
-        cell.source = "\n".join(cleaned_lines)
+            lines.append(line)
+        cell.source = "\n".join(lines)
+
 
 # --- Export cleaned notebook to Python ---
 py_exporter = PythonExporter()

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/app.py

@@ -21,14 +21,27 @@ from datasets import load_dataset
 if not os.path.exists("YOLO.ipynb"):
     raise FileNotFoundError("YOLO.ipynb not found in app directory!")
 
-# Convert YOLO.ipynb → yolo_converted.py
+# Read YOLO.ipynb
 with open("YOLO.ipynb") as f:
     nb = nbformat.read(f, as_version=4)
+
+# --- Clean notebook magic commands (!pip, !git, %cd, etc.) ---
+for cell in nb.cells:
+    if cell.cell_type == "code":
+        cleaned_lines = []
+        for line in cell.source.splitlines():
+            if line.strip().startswith(("!", "%")):
+                continue
+            cleaned_lines.append(line)
+        cell.source = "\n".join(cleaned_lines)
+
+# --- Export cleaned notebook to Python ---
 py_exporter = PythonExporter()
 (code, _) = py_exporter.from_notebook_node(nb)
 with open("yolo_converted.py", "w") as f:
     f.write(code)
 
+# --- Run the converted YOLO script ---
 mod = runpy.run_path("yolo_converted.py")
 detect_and_classify = mod.get("detect_and_classify")
 if not detect_and_classify:

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/requirements.txt

@@ -9,3 +9,6 @@ opencv-python
 timm
 transformers
 datasets
+
+nbformat
+nbconvert

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/app.py

@@ -7,146 +7,75 @@ Original file is located at
     https://colab.research.google.com/drive/1gTrf304mzjGMheD47oHDhnYTIrEyf4qp
 """
 
+import os
+import json
+import torch
 import gradio as gr
 from PIL import Image
-import torch
-import os
-
-import os
-from google.colab import files
-
-if not os.path.exists('YOLO.ipynb'):
-    print("Please upload YOLO.ipynb (the script exported from your YOLO notebook).")
-    uploaded = files.upload()  # upload YOLO.ipynb
-    print("Uploaded:", list(uploaded.keys()))
-else:
-    print("YOLO.ipynb already present.")
-
-!ls /content
-
 import nbformat
 from nbconvert import PythonExporter
 import runpy
+from datasets import load_dataset
 
-# Convert YOLO.ipynb to a .py script dynamically
+# --- Convert YOLO notebook to Python ---
+if not os.path.exists("YOLO.ipynb"):
+    raise FileNotFoundError("YOLO.ipynb not found in app directory!")
+
+# Convert YOLO.ipynb → yolo_converted.py
 with open("YOLO.ipynb") as f:
     nb = nbformat.read(f, as_version=4)
-
-# Find the cell that loads car_classifier.pth and modify the path
-# Also, remove any code that tries to open the notebook file as an image
-modified_cells = []
-for cell in nb.cells:
-    if cell.cell_type == 'code':
-        # This is a heuristic: look for lines containing 'car_classifier.pth'
-        if 'car_classifier.pth' in cell.source:
-            cell.source = cell.source.replace("'car_classifier.pth'", "'/content/car_classifier.pth'")
-            cell.source = cell.source.replace('"car_classifier.pth"', '"/content/car_classifier.pth"')
-
-        # Heuristic to remove code that might try to open the notebook as an image
-        if 'Image.open(' in cell.source and 'YOLO.ipynb' in cell.source:
-             cell.source = '# Removed potential image loading of notebook file:\n#' + cell.source
-
 py_exporter = PythonExporter()
 (code, _) = py_exporter.from_notebook_node(nb)
-
-# Save temporarily as script
 with open("yolo_converted.py", "w") as f:
     f.write(code)
 
-# Now safely import detect_and_classify() from that converted script
 mod = runpy.run_path("yolo_converted.py")
 detect_and_classify = mod.get("detect_and_classify")
-
 if not detect_and_classify:
-    raise RuntimeError("Function detect_and_classify not found in YOLO.ipynb")
+    raise RuntimeError("detect_and_classify() not found in YOLO.ipynb")
 
-print("✅ YOLO function imported successfully")
+print("✅ YOLO pipeline loaded successfully")
 
-import torch, os, json
-pth = "/content/car_classifier.pth"
-print("Exists:", os.path.exists(pth))
-ckpt = torch.load(pth, map_location="cpu")
-print("Type:", type(ckpt))
-
-if isinstance(ckpt, dict):
-    keys = list(ckpt.keys())
-    print("Checkpoint keys (first 20):", keys[:20])
-    # If it's a pure state_dict, it will look like parameter names (e.g. 'conv1.weight')
-    # If it's a wrapped checkpoint, it may contain 'model_state_dict' or 'class_names'
-else:
-    print("Checkpoint is not a dict; it's probably a raw model object.")
-
-!pip install -q datasets
-
-from datasets import load_dataset
-ds = load_dataset("tanganke/stanford_cars")
-# HF dataset provides label names in the train feature
-class_names = ds["train"].features["label"].names
-print("Loaded", len(class_names), "class names. Sample:", class_names[:10])
-
-# Save to disk for reuse
-import json
-with open("class_names.json", "w") as f:
-    json.dump(class_names, f, indent=2)
-print("Saved class_names.json")
-
-import json, os
-if os.path.exists("class_names.json"):
-    with open("class_names.json") as f:
-        class_names = json.load(f)
-    print("Loaded class_names from file, len =", len(class_names))
-else:
-    print("class_names.json not found; run the HF cell above.")
-
-import gradio as gr
-import os
-
-# ensure class_names exists in the notebook (from previous cell)
+# --- Load class names ---
 try:
-    assert class_names is not None and len(class_names) > 0
-    print("Using class_names with", len(class_names), "entries")
-except Exception:
+    ds = load_dataset("tanganke/stanford_cars")
+    class_names = ds["train"].features["label"].names
+    with open("class_names.json", "w") as f:
+        json.dump(class_names, f)
+except Exception as e:
+    print("Warning: Could not load dataset class names.", e)
     class_names = None
-    print("class_names not available; will show numeric labels")
 
-def gradio_interface(image, *args, **kwargs):
+# --- Gradio UI ---
+def gradio_interface(image):
     if image is None:
         return "Please upload an image."
-
     temp_path = "temp_image.png"
     image.save(temp_path)
 
     try:
-        results = detect_and_classify(temp_path)  # your notebook function
+        results = detect_and_classify(temp_path)
     except Exception as e:
         return f"❌ Error running YOLO pipeline: {e}"
     finally:
-        if os.path.exists(temp_path):
-            os.remove(temp_path)
+        os.remove(temp_path)
 
     if not results:
         return "No cars detected."
 
     lines = [f"Cars detected: {len(results)}"]
-
     for i, item in enumerate(results, start=1):
-        # handle both 3-tuple and 4-tuple safely
         if len(item) == 4:
             crop, pred, color, conf = item
         else:
             crop, pred, color = item
             conf = None
 
-        # map pred -> human name if possible
-        if isinstance(pred, int):
-            if class_names and 0 <= pred < len(class_names):
-                name = class_names[pred]
-            else:
-                name = f"Class {pred}"
+        if isinstance(pred, int) and class_names and 0 <= pred < len(class_names):
+            name = class_names[pred]
         else:
             name = str(pred)
 
-        # Format with confidence if available
         if conf is not None:
             lines.append(f"Car {i}: {color} {name} ({conf*100:.1f}% confident)")
         else:
@@ -154,28 +83,13 @@ def gradio_interface(image, *args, **kwargs):
 
     return "\n".join(lines)
 
-# Launch Gradio Interface
 iface = gr.Interface(
     fn=gradio_interface,
     inputs=gr.Image(type="pil", label="Upload an Image"),
     outputs=gr.Textbox(label="Detection & Classification Results"),
     title="Car Detector + Classifier (YOLO)",
-    description="Upload a car image and get its color, model, and confidence score.",
+    description="Upload a car image and get its color, model, and confidence score."
 )
-iface.launch(share=True)
-
-# Test the gradio_interface function with the venza.jpg image
-image_path = "/content/venza.jpg"
-try:
-    # Open the image file
-    image = Image.open(image_path)
-    # Call the gradio_interface function, passing class_names
-    test_output = gradio_interface(image, class_names)
-    # Print the output
-    print(test_output)
-except FileNotFoundError:
-    print(f"Error: Image file not found at {image_path}")
-except Exception as e:
-    print(f"An error occurred: {e}")
 
-!grep -n "results" YOLO.ipynb
+if __name__ == "__main__":
+    iface.launch()

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/app.py

@@ -7,9 +7,9 @@ Original file is located at
     https://colab.research.google.com/drive/1gTrf304mzjGMheD47oHDhnYTIrEyf4qp
 """
 
-!pip install gradio --quiet
 import gradio as gr
 from PIL import Image
+import torch
 import os
 
 import os
@@ -178,4 +178,4 @@ except FileNotFoundError:
 except Exception as e:
     print(f"An error occurred: {e}")
 
-!grep -n "results" YOLO.ipynb
+!grep -n "results" YOLO.ipynb

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/car_classifier.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:df2189a3b9547272dd7a962f5d05e15a0155c57f7b1e6fee41fb4e698d32666e
+size 45188363

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/requirements.txt

@@ -1 +1,11 @@
-trackio<1.0
+torch
+torchvision
+ultralytics
+gradio
+pillow
+numpy
+matplotlib
+opencv-python
+timm
+transformers
+datasets

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/.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

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/README.md

@@ -0,0 +1,91 @@
+---
+title: Car Classifier Model
+emoji: 🚗
+colorFrom: blue
+colorTo: purple
+sdk: gradio
+sdk_version: "4.0.0"
+app_file: app.py
+pinned: false
+---
+
+# AiModelCarClassifier
+Creating and Running a Car Classifier Model...
+
+## Car Detector(YOLO + Custom Model)
+
+This project uses **YOLOv5** for car detection and a **custom-trained classifier** for car model recognition and color identification.  
+It takes in any image (JPEG/PNG), detects cars, classifies the car make & model, and outputs color and confidence scores.
+
+Example output:
+- **Cars detected: 1**
+- **Car 1: Gray/Silver Dodge Dakota Crew Cab 2010 (98.7% confident)**
+
+---
+
+## Overview
+
+This project combines **object detection** and **image classification** in one simple pipeline:
+
+1. **YOLOv5** detects cars in the image.  
+2. The detected car regions are cropped and passed into a **PyTorch classifier** (`car_classifier.pth`).  
+3. A small color recognition helper determines the car’s dominant color.  
+4. Results are displayed through a simple **Gradio UI** (or any frontend, e.g. HTML + Flask).
+
+---
+
+## Project Structure
+
+│
+├── YOLO.ipynb # Main notebook for YOLO + classification logic
+├── car_classifier.pth # Trained PyTorch model for car model recognition
+├── app.py # Gradio (or Flask) app for running the interface
+├── class_names.json # (Optional) Human-readable class labels
+├── requirements.txt # Python dependencies
+└── README.md # Project description
+
+---
+
+---
+
+## Works steps
+
+1. **Image Upload** → User uploads an image.  
+2. **YOLOv5 Detection** → Detects car bounding boxes.  
+3. **Classification** → Each car crop is classified using `car_classifier.pth`.  
+4. **Color Recognition** → Extracts car color from the cropped region.  
+5. **Output** → Displays model name, color, and confidence percentage.
+
+---
+## Model Details
+
+- **YOLOv5**: Handles object detection (pretrained on COCO dataset).  
+- **Car Classifier (`car_classifier.pth`)**: Fine-tuned model trained on [Stanford Cars Dataset](https://www.kaggle.com/datasets/jessicali9530/stanford-cars).  
+- **Color Extractor**: Uses average RGB values to estimate color.
+
+---
+## install depencies
+```
+pip install -r requirements.txt
+```
+
+
+Then open the Gradio or local web interface that appears in your console.
+---
+
+## Setup & Run
+
+Clone the repo:
+
+Then open the Gradio or local web interface that appears in your console.
+```bash
+https://github.com/<Your-Username>/AiModelCarClassifier.git
+cd car-detector-classifier
+```
+
+
+
+## run the app
+```
+python app.py
+```

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/app.py

@@ -0,0 +1,181 @@
+# -*- coding: utf-8 -*-
+"""GradioUI.ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1gTrf304mzjGMheD47oHDhnYTIrEyf4qp
+"""
+
+!pip install gradio --quiet
+import gradio as gr
+from PIL import Image
+import os
+
+import os
+from google.colab import files
+
+if not os.path.exists('YOLO.ipynb'):
+    print("Please upload YOLO.ipynb (the script exported from your YOLO notebook).")
+    uploaded = files.upload()  # upload YOLO.ipynb
+    print("Uploaded:", list(uploaded.keys()))
+else:
+    print("YOLO.ipynb already present.")
+
+!ls /content
+
+import nbformat
+from nbconvert import PythonExporter
+import runpy
+
+# Convert YOLO.ipynb to a .py script dynamically
+with open("YOLO.ipynb") as f:
+    nb = nbformat.read(f, as_version=4)
+
+# Find the cell that loads car_classifier.pth and modify the path
+# Also, remove any code that tries to open the notebook file as an image
+modified_cells = []
+for cell in nb.cells:
+    if cell.cell_type == 'code':
+        # This is a heuristic: look for lines containing 'car_classifier.pth'
+        if 'car_classifier.pth' in cell.source:
+            cell.source = cell.source.replace("'car_classifier.pth'", "'/content/car_classifier.pth'")
+            cell.source = cell.source.replace('"car_classifier.pth"', '"/content/car_classifier.pth"')
+
+        # Heuristic to remove code that might try to open the notebook as an image
+        if 'Image.open(' in cell.source and 'YOLO.ipynb' in cell.source:
+             cell.source = '# Removed potential image loading of notebook file:\n#' + cell.source
+
+py_exporter = PythonExporter()
+(code, _) = py_exporter.from_notebook_node(nb)
+
+# Save temporarily as script
+with open("yolo_converted.py", "w") as f:
+    f.write(code)
+
+# Now safely import detect_and_classify() from that converted script
+mod = runpy.run_path("yolo_converted.py")
+detect_and_classify = mod.get("detect_and_classify")
+
+if not detect_and_classify:
+    raise RuntimeError("Function detect_and_classify not found in YOLO.ipynb")
+
+print("✅ YOLO function imported successfully")
+
+import torch, os, json
+pth = "/content/car_classifier.pth"
+print("Exists:", os.path.exists(pth))
+ckpt = torch.load(pth, map_location="cpu")
+print("Type:", type(ckpt))
+
+if isinstance(ckpt, dict):
+    keys = list(ckpt.keys())
+    print("Checkpoint keys (first 20):", keys[:20])
+    # If it's a pure state_dict, it will look like parameter names (e.g. 'conv1.weight')
+    # If it's a wrapped checkpoint, it may contain 'model_state_dict' or 'class_names'
+else:
+    print("Checkpoint is not a dict; it's probably a raw model object.")
+
+!pip install -q datasets
+
+from datasets import load_dataset
+ds = load_dataset("tanganke/stanford_cars")
+# HF dataset provides label names in the train feature
+class_names = ds["train"].features["label"].names
+print("Loaded", len(class_names), "class names. Sample:", class_names[:10])
+
+# Save to disk for reuse
+import json
+with open("class_names.json", "w") as f:
+    json.dump(class_names, f, indent=2)
+print("Saved class_names.json")
+
+import json, os
+if os.path.exists("class_names.json"):
+    with open("class_names.json") as f:
+        class_names = json.load(f)
+    print("Loaded class_names from file, len =", len(class_names))
+else:
+    print("class_names.json not found; run the HF cell above.")
+
+import gradio as gr
+import os
+
+# ensure class_names exists in the notebook (from previous cell)
+try:
+    assert class_names is not None and len(class_names) > 0
+    print("Using class_names with", len(class_names), "entries")
+except Exception:
+    class_names = None
+    print("class_names not available; will show numeric labels")
+
+def gradio_interface(image, *args, **kwargs):
+    if image is None:
+        return "Please upload an image."
+
+    temp_path = "temp_image.png"
+    image.save(temp_path)
+
+    try:
+        results = detect_and_classify(temp_path)  # your notebook function
+    except Exception as e:
+        return f"❌ Error running YOLO pipeline: {e}"
+    finally:
+        if os.path.exists(temp_path):
+            os.remove(temp_path)
+
+    if not results:
+        return "No cars detected."
+
+    lines = [f"Cars detected: {len(results)}"]
+
+    for i, item in enumerate(results, start=1):
+        # handle both 3-tuple and 4-tuple safely
+        if len(item) == 4:
+            crop, pred, color, conf = item
+        else:
+            crop, pred, color = item
+            conf = None
+
+        # map pred -> human name if possible
+        if isinstance(pred, int):
+            if class_names and 0 <= pred < len(class_names):
+                name = class_names[pred]
+            else:
+                name = f"Class {pred}"
+        else:
+            name = str(pred)
+
+        # Format with confidence if available
+        if conf is not None:
+            lines.append(f"Car {i}: {color} {name} ({conf*100:.1f}% confident)")
+        else:
+            lines.append(f"Car {i}: {color} {name}")
+
+    return "\n".join(lines)
+
+# Launch Gradio Interface
+iface = gr.Interface(
+    fn=gradio_interface,
+    inputs=gr.Image(type="pil", label="Upload an Image"),
+    outputs=gr.Textbox(label="Detection & Classification Results"),
+    title="Car Detector + Classifier (YOLO)",
+    description="Upload a car image and get its color, model, and confidence score.",
+)
+iface.launch(share=True)
+
+# Test the gradio_interface function with the venza.jpg image
+image_path = "/content/venza.jpg"
+try:
+    # Open the image file
+    image = Image.open(image_path)
+    # Call the gradio_interface function, passing class_names
+    test_output = gradio_interface(image, class_names)
+    # Print the output
+    print(test_output)
+except FileNotFoundError:
+    print(f"Error: Image file not found at {image_path}")
+except Exception as e:
+    print(f"An error occurred: {e}")
+
+!grep -n "results" YOLO.ipynb

space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/space_repo/requirements.txt

@@ -0,0 +1 @@
+trackio<1.0

yolo_module.py

@@ -0,0 +1,173 @@
+# yolo_module.py
+# A small, standalone wrapper for YOLOv5 detection + a saved PyTorch classifier.
+# Designed to be imported by app.py (Hugging Face / Gradio).
+
+import os
+from PIL import Image
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torchvision import transforms, models
+import torch.nn as nn
+
+# Load YOLOv5 model (uses torch.hub — Ultralytics repo)
+# NOTE: this will download yolov5s.pt the first time (cached in environment).
+yolo = None
+try:
+    yolo = torch.hub.load('ultralytics/yolov5', 'yolov5s', pretrained=True)
+except Exception as e:
+    # If users want to use ultralytics package or different method, handle gracefully.
+    print("Warning: could not load yolov5 via torch.hub:", e)
+    yolo = None
+
+# -- Classifier model (ResNet18, 196 classes) --
+model = None
+transform = None
+def _load_classifier():
+    global model, transform
+    # architecture
+    model = models.resnet18(pretrained=False)
+    model.fc = nn.Linear(model.fc.in_features, 196)
+    # find the checkpoint saved in repo or /content folder
+    model_path = "car_classifier.pth"
+    if not os.path.exists(model_path):
+        alt = os.path.join("content", "car_classifier.pth")
+        if os.path.exists(alt):
+            model_path = alt
+    if not os.path.exists(model_path):
+        # If missing, we keep model=None and later return an error
+        print("Warning: car_classifier.pth not found at root or /content. Classifier disabled.")
+        model = None
+        transform = transforms.Compose([transforms.Resize((224,224)), transforms.ToTensor()])
+        return
+
+    ckpt = torch.load(model_path, map_location="cpu")
+    # ckpt might be a full dict or a state_dict — handle both cases
+    if isinstance(ckpt, dict):
+        # common keys: "model_state_dict" or bare state_dict
+        if "model_state_dict" in ckpt:
+            state = ckpt["model_state_dict"]
+        elif any(k.startswith('conv1') for k in ckpt.keys()):
+            state = ckpt
+        else:
+            # unknown dict structure — try to find a nested state dict
+            possible = None
+            for v in ckpt.values():
+                if isinstance(v, dict) and any(k.startswith('conv1') for k in v.keys()):
+                    possible = v
+                    break
+            state = possible or ckpt
+    else:
+        # ckpt directly is probably a state_dict
+        state = ckpt
+
+    try:
+        model.load_state_dict(state)
+        model.eval()
+        print("✅ Loaded classifier from", model_path)
+    except Exception as e:
+        print("Warning: failed to load state_dict cleanly:", e)
+        model = None
+
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+    ])
+
+# Try to load on import
+_load_classifier()
+
+
+# Simple color extractor (dominant-ish color)
+def get_color_name(image_pil):
+    try:
+        img = image_pil.resize((50, 50))
+        arr = np.array(img).reshape(-1, 3)
+        avg = arr.mean(axis=0)
+        r, g, b = avg
+        # simple thresholds
+        if r > 150 and g < 100 and b < 100:
+            return "Red"
+        if b > 150 and r < 100 and g < 100:
+            return "Blue"
+        if g > 150 and r < 100 and b < 100:
+            return "Green"
+        if r > 200 and g > 200 and b > 200:
+            return "White"
+        if r < 50 and g < 50 and b < 50:
+            return "Black"
+        if r > 200 and g > 200 and b < 100:
+            return "Yellow"
+        return "Gray/Silver"
+    except Exception:
+        return "Unknown"
+
+# The pipeline function expected by app.py
+def detect_and_classify(img_path):
+    """
+    Input: img_path (str)
+    Output: list of tuples (PIL.Image crop, pred_class_idx (int), color_name (str), classifier_confidence (float or None))
+    If classifier not available, pred_class_idx may be integer index (if you still have names elsewhere) or None.
+    """
+    if not os.path.exists(img_path):
+        raise FileNotFoundError(f"Image not found: {img_path}")
+
+    # If YOLO not available, return helpful error
+    if yolo is None:
+        raise RuntimeError("YOLO model not loaded (yolo is None). Check logs for earlier warning.")
+
+    img = Image.open(img_path).convert("RGB")
+    # Run YOLO detection
+    results = yolo(img_path)  # Ultralytics API: passing path or PIL works
+
+    # results.xyxy[0] is an Nx6 array: x1,y1,x2,y2,conf,cls
+    try:
+        dets = results.xyxy[0].cpu().numpy()
+    except Exception:
+        # fallback: try to convert via .pandas().xyxy[0]
+        try:
+            dets = results.pandas().xyxy[0].values
+        except Exception:
+            dets = []
+
+    preds = []
+    for det in dets:
+        try:
+            x1, y1, x2, y2, conf_det, cls = det
+        except Exception:
+            # if det is dict-like from pandas
+            try:
+                x1 = float(det[0]); y1 = float(det[1]); x2 = float(det[2]); y2 = float(det[3])
+                conf_det = float(det[4]); cls = float(det[5])
+            except Exception:
+                continue
+
+        if int(cls) != 2:  # COCO class 2 == car
+            continue
+
+        # crop with PIL (ensure integer coords and within bounds)
+        x1i, y1i, x2i, y2i = map(int, [max(0, x1), max(0, y1), max(0, x2), max(0, y2)])
+        crop = img.crop((x1i, y1i, x2i, y2i))
+
+        # classifier
+        class_idx = None
+        class_conf = None
+        if model is not None:
+            try:
+                t = transform(crop).unsqueeze(0)  # batch 1
+                with torch.no_grad():
+                    out = model(t)
+                    probs = F.softmax(out, dim=1)
+                    class_conf = float(probs.max().item())
+                    class_idx = int(probs.argmax().item())
+            except Exception as e:
+                # if classifier fails, leave class_idx None
+                class_idx = None
+                class_conf = None
+
+        # color
+        color = get_color_name(crop)
+
+        preds.append((crop, class_idx, color, class_conf))
+
+    return preds