Upload 7 files

Damage_Classifier_Resnet_18.pth

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

Dockerfile

@@ -0,0 +1,27 @@
+FROM python:3.10-slim
+
+# Prevent Python from writing pyc files
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+WORKDIR /app
+
+# Install system dependencies (required for sklearn / xgboost)
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    gcc \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy and install dependencies first (better caching)
+COPY requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip \
+    && pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Hugging Face expects port 7860
+EXPOSE 7860
+
+# Start FastAPI
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,19 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from predict_helper import predict_image
+from PIL import Image
+
+app = FastAPI(title="Car Damage Detection API", version="1.0")
+
+@app.get("/")
+def read_root():
+    return {"status": "API is running"}
+
+@app.post("/predict")
+async def predict(image: UploadFile = File(...)):
+    try:
+        img = Image.open(image.file)
+    except Exception:
+        raise HTTPException(status_code=400, detail="Invalid image file")
+
+    prediction = predict_image(img)
+    return prediction

main.py

@@ -0,0 +1,23 @@
+import gradio as gr
+from app import app as fastapi_app
+
+# ---------------------------
+# Root Gradio App
+# ---------------------------
+with gr.Blocks() as demo:
+    gr.Markdown(
+        """
+        # Car Damage Detector
+
+        Use the API endpoints directly.
+        """
+    )
+
+# ---------------------------
+# Mount FastAPI INSIDE Gradio
+# ---------------------------
+app = gr.mount_gradio_app(
+    demo,            # Gradio must be the ROOT app
+    fastapi_app,     # FastAPI is mounted inside it
+    path="/"         # API available at /
+)

predict_helper.py

@@ -0,0 +1,94 @@
+from torchvision import transforms
+from PIL import Image
+import torch
+import torch.nn as nn
+import torchvision.models as models
+
+# Image transformation for inference
+transform = transforms.Compose([
+    transforms.Resize((224, 224)),              # Resize to model input size
+    transforms.ToTensor(),                      # Convert PIL image to tensor
+    transforms.Normalize(
+        mean=[0.485, 0.456, 0.406],              # ImageNet mean
+        std=[0.229, 0.224, 0.225]                # ImageNet std
+    )
+])
+
+def preprocess_image(image_path):
+    image = Image.open(image_path).convert("RGB")
+    image = transform(image)
+    image = image.unsqueeze(0)  # Add batch dimension
+    return image
+
+# Initializing the model
+
+class Car_Classifier_Resnet(nn.Module):
+    def __init__(self, num_classes):
+        super().__init__()
+
+        self.model = models.resnet18(weights="DEFAULT")
+
+        for param in self.model.parameters():
+            param.requires_grad = False
+
+        for param in self.model.layer4.parameters():
+            param.requires_grad = True
+
+        for module in self.model.modules():
+            if isinstance(module, nn.BatchNorm2d):
+                for param in module.parameters():
+                    param.requires_grad = True
+
+        self.model.fc = nn.Sequential(
+            nn.Dropout(0.4),
+            nn.Linear(self.model.fc.in_features, num_classes)
+        )
+
+
+    def forward(self, x):
+        return self.model(x)
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+num_classes = 6
+model = Car_Classifier_Resnet(num_classes).to(device)
+
+model.load_state_dict(torch.load("Damage_Classifier_Resnet_18.pth", map_location=device))
+
+# Prediction Function
+
+class_names = [
+    "F_Breakage",
+    "F_Crushed",
+    "F_Normal",
+    "R_Breakage",
+    "R_Crushed",
+    "R_Normal"
+]
+
+# Prediction Function
+def predict_image(image: Image.Image):
+    model.eval()
+
+    image = image.convert("RGB")
+    image = transform(image).unsqueeze(0).to(device)
+
+    with torch.no_grad():
+        outputs = model(image)
+        probs = torch.softmax(outputs, dim=1)
+        conf, pred = torch.max(probs, dim=1)
+
+    pred_idx = pred.item()
+    confidence = conf.item()
+
+    if class_names:
+        return {
+            "class_index": pred_idx,
+            "class_name": class_names[pred_idx],
+            "confidence": round(confidence, 4)
+        }
+    else:
+        return {
+            "class_index": pred_idx,
+            "confidence": round(confidence, 4)
+        }

requirements.txt

@@ -0,0 +1,6 @@
+fastapi~=0.122.0
+pillow~=12.0.0
+torch~=2.9.1
+torchvision~=0.24.1
+protobuf~=6.33.1
+scikit-learn~=1.4.2