Upload 8 files

Dockerfile

@@ -0,0 +1,15 @@
+# Base image with Python
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Copy files
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app ./app
+
+# Expose port (HF listens on $PORT)
+ENV PORT 7860
+CMD ["uvicorn", "app.app:app", "--host", "0.0.0.0", "--port", "7860"]

app.py

@@ -0,0 +1,68 @@
+from fastapi import FastAPI, UploadFile, File, HTTPException
+from fastapi.responses import RedirectResponse
+from typing import Dict
+import torch
+import io
+import os
+from PIL import Image
+
+# Local imports
+from ocr_proc import extract_meter_info
+from inference_roof_type import RoofClassifierCNN, transform, CLASS_NAMES, DEVICE
+
+# FastAPI app
+app = FastAPI(
+    title="Electric Meter + Roof Classifier API",
+    description="Electric Meter OCR and Roof Type Classification",
+    version="1.0.0",
+    docs_url="/docs",
+    redoc_url="/redoc",
+    openapi_url="/openapi.json"
+)
+
+# Redirect root to Swagger UI
+@app.get("/", include_in_schema=False)
+async def root():
+    return RedirectResponse(url="/docs")
+
+@app.get("/health", tags=["Health"])
+async def health_check():
+    return {"status": "healthy", "message": "API is running"}
+
+# Load the roof model once (on cold start)
+roof_model = RoofClassifierCNN().to(DEVICE)
+roof_model.load_state_dict(torch.load("roof_type_cnn_best.pth", map_location=DEVICE))
+roof_model.eval()
+
+@app.post("/ocr/meter", tags=["OCR"])
+async def extract_ocr_data(file: UploadFile = File(...)) -> Dict:
+    try:
+        contents = await file.read()
+        extracted_info = extract_meter_info(contents)
+        return {"success": True, "data": extracted_info}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"OCR processing failed: {str(e)}")
+
+@app.post("/roof/classify", tags=["Roof Type Classifier"])
+async def classify_roof(file: UploadFile = File(...)) -> Dict:
+    try:
+        image = Image.open(io.BytesIO(await file.read())).convert("RGB")
+        img_tensor = transform(image).unsqueeze(0).to(DEVICE)
+
+        with torch.no_grad():
+            outputs = roof_model(img_tensor)
+            _, predicted = torch.max(outputs, 1)
+            class_idx = predicted.item()
+            confidence = torch.softmax(outputs, dim=1)[0][class_idx].item()
+
+        return {
+            "success": True,
+            "predicted_roof_type": CLASS_NAMES[class_idx],
+            "confidence": f"{confidence * 100:.2f}%"
+        }
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Roof classification failed: {str(e)}")
+
+# ✅ DO NOT add `if __name__ == "__main__"` block here.
+# Render will run `uvicorn main:app --host 0.0.0.0 --port 10000`

inference_roof_type.py

@@ -0,0 +1,92 @@
+import torch
+import torch.nn as nn
+from torchvision import transforms
+from PIL import Image
+import sys
+
+# -------------------------------
+# CONFIG
+# -------------------------------
+IMG_SIZE = 128
+MODEL_PATH = "roof_type_cnn_best.pth"
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+CLASS_NAMES = ['flat', 'pitched']  # Must match training order
+
+# -------------------------------
+# MODEL ARCHITECTURE (same as training)
+# -------------------------------
+class RoofClassifierCNN(nn.Module):
+    def __init__(self):
+        super(RoofClassifierCNN, self).__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(3, 16, kernel_size=3, padding=1),
+            nn.BatchNorm2d(16),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+
+            nn.Conv2d(16, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.MaxPool2d(2),
+        )
+        self.fc = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(64 * 16 * 16, 128),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(128, 2)
+        )
+
+    def forward(self, x):
+        x = self.net(x)
+        return self.fc(x)
+
+# -------------------------------
+# TRANSFORMS
+# -------------------------------
+transform = transforms.Compose([
+    transforms.Resize((IMG_SIZE, IMG_SIZE)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.5]*3, [0.5]*3)
+])
+
+# -------------------------------
+# LOAD MODEL
+# -------------------------------
+model = RoofClassifierCNN().to(DEVICE)
+model.load_state_dict(torch.load(MODEL_PATH, map_location=DEVICE))
+model.eval()
+
+# -------------------------------
+# PREDICTION FUNCTION
+# -------------------------------
+def predict(image_path):
+    try:
+        image = Image.open(image_path).convert('RGB')
+    except:
+        print(f"❌ Failed to open image: {image_path}")
+        return
+
+    img_tensor = transform(image).unsqueeze(0).to(DEVICE)
+
+    with torch.no_grad():
+        outputs = model(img_tensor)
+        _, predicted = torch.max(outputs, 1)
+        class_idx = predicted.item()
+        confidence = torch.softmax(outputs, dim=1)[0][class_idx].item()
+
+    print(f"✅ Prediction: {CLASS_NAMES[class_idx]} (Confidence: {confidence*100:.2f}%)")
+
+# -------------------------------
+# MAIN
+# -------------------------------
+if __name__ == "__main__":
+    if len(sys.argv) != 2:
+        print("Usage: python inference_roof_type.py <image_path>")
+    else:
+        predict(sys.argv[1])

ocr_proc.py

@@ -0,0 +1,74 @@
+import easyocr
+import cv2
+import numpy as np
+import re
+
+reader = easyocr.Reader(['en'])
+
+def preprocess_image(image):
+
+    gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
+    thresh = cv2.adaptiveThreshold(
+        gray, 255,
+        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        cv2.THRESH_BINARY_INV,
+        11, 2
+    )
+    return thresh
+
+def extract_meter_info(image_bytes):
+
+    np_img = np.frombuffer(image_bytes, np.uint8)
+    image = cv2.imdecode(np_img, cv2.IMREAD_COLOR)
+    processed_image = preprocess_image(image)
+    results = reader.readtext(processed_image)
+    print("[OCR Results]")
+    for bbox, text, conf in results:
+        print(f"Text: {text}, Confidence: {conf:.2f}")
+
+
+    extracted_info = {
+        "kh": None,
+        "frequency": None,
+        "voltage": None,
+        "serial_number": None,
+        "other_specs": []
+    }
+
+
+    kh_pattern = re.compile(r"\bK\s*H\s*[:=]?\s*([0-9.]+)", re.IGNORECASE)
+    freq_pattern = re.compile(r"\b([4-6]0)\s*(hz)?\b", re.IGNORECASE)
+    volt_pattern = re.compile(r"\b([1-4][0-9]{2})\s*(v|volt|volts)?\b", re.IGNORECASE)
+    serial_pattern = re.compile(r"\b(?:S/N|SN|Serial\s*(?:No|Number)?[:\s]*)?(\d{6,})\b", re.IGNORECASE)
+
+    for (_, text, _) in results:
+        text_clean = text.strip()
+
+        if not extracted_info["kh"]:
+            if kh_match := kh_pattern.search(text_clean):
+                extracted_info["kh"] = kh_match.group(1)
+
+        if not extracted_info["frequency"]:
+            if freq_match := freq_pattern.search(text_clean):
+                extracted_info["frequency"] = freq_match.group(1)
+
+        if not extracted_info["voltage"]:
+            if volt_match := volt_pattern.search(text_clean):
+                extracted_info["voltage"] = volt_match.group(1)
+
+        if not extracted_info["serial_number"]:
+            if serial_match := serial_pattern.search(text_clean):
+                if not re.search(r"hz|v|kh", text_clean.lower()):
+                    extracted_info["serial_number"] = serial_match.group(1)
+
+        extracted_info["other_specs"].append(text_clean)
+
+    # Normalize output units
+    if extracted_info["voltage"]:
+        extracted_info["voltage"] += " V"
+    if extracted_info["frequency"]:
+        extracted_info["frequency"] += " Hz"
+    if extracted_info["kh"]:
+        extracted_info["kh"] += " Kh"
+
+    return extracted_info

one_shot_model.py

@@ -0,0 +1,124 @@
+import os
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torchvision import datasets, transforms
+from torch.utils.data import DataLoader, random_split
+
+# -------------------------------
+# CONFIGURATION
+# -------------------------------
+DATA_DIR = "training"  # Your root dir with 'flat/' and 'pitched/'
+BATCH_SIZE = 16
+EPOCHS = 20
+LR = 0.001
+IMG_SIZE = 128
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# -------------------------------
+# TRANSFORMS
+# -------------------------------
+transform = transforms.Compose([
+    transforms.Resize((IMG_SIZE, IMG_SIZE)),
+    transforms.ToTensor(),
+    transforms.Normalize([0.5]*3, [0.5]*3)  # RGB normalization
+])
+
+# -------------------------------
+# DATASET AND LOADERS
+# -------------------------------
+dataset = datasets.ImageFolder(root=DATA_DIR, transform=transform)
+train_len = int(0.8 * len(dataset))
+val_len = len(dataset) - train_len
+train_set, val_set = random_split(dataset, [train_len, val_len])
+train_loader = DataLoader(train_set, batch_size=BATCH_SIZE, shuffle=True)
+val_loader = DataLoader(val_set, batch_size=BATCH_SIZE, shuffle=False)
+
+# -------------------------------
+# FINAL CNN MODEL
+# -------------------------------
+class RoofClassifierCNN(nn.Module):
+    def __init__(self):
+        super(RoofClassifierCNN, self).__init__()
+        self.net = nn.Sequential(
+            nn.Conv2d(3, 16, kernel_size=3, padding=1),
+            nn.BatchNorm2d(16),
+            nn.ReLU(),
+            nn.MaxPool2d(2),  # -> 16x64x64
+
+            nn.Conv2d(16, 32, kernel_size=3, padding=1),
+            nn.BatchNorm2d(32),
+            nn.ReLU(),
+            nn.MaxPool2d(2),  # -> 32x32x32
+
+            nn.Conv2d(32, 64, kernel_size=3, padding=1),
+            nn.BatchNorm2d(64),
+            nn.ReLU(),
+            nn.MaxPool2d(2),  # -> 64x16x16
+        )
+        self.fc = nn.Sequential(
+            nn.Flatten(),
+            nn.Linear(64 * 16 * 16, 128),
+            nn.ReLU(),
+            nn.Dropout(0.3),
+            nn.Linear(128, 2)
+        )
+
+    def forward(self, x):
+        x = self.net(x)
+        x = self.fc(x)
+        return x
+
+model = RoofClassifierCNN().to(DEVICE)
+
+# -------------------------------
+# LOSS & OPTIMIZER
+# -------------------------------
+criterion = nn.CrossEntropyLoss()
+optimizer = optim.Adam(model.parameters(), lr=LR)
+
+# -------------------------------
+# TRAINING LOOP
+# -------------------------------
+for epoch in range(EPOCHS):
+    model.train()
+    total_loss, correct, total = 0.0, 0, 0
+
+    for imgs, labels in train_loader:
+        imgs, labels = imgs.to(DEVICE), labels.to(DEVICE)
+        optimizer.zero_grad()
+        outputs = model(imgs)
+        loss = criterion(outputs, labels)
+        loss.backward()
+        optimizer.step()
+
+        total_loss += loss.item()
+        _, predicted = outputs.max(1)
+        total += labels.size(0)
+        correct += predicted.eq(labels).sum().item()
+
+    acc = 100 * correct / total
+    print(f"Epoch {epoch+1:02d}/{EPOCHS} - Loss: {total_loss:.4f} - Accuracy: {acc:.2f}%")
+
+# -------------------------------
+# VALIDATION
+# -------------------------------
+model.eval()
+correct = 0
+total = 0
+with torch.no_grad():
+    for imgs, labels in val_loader:
+        imgs, labels = imgs.to(DEVICE), labels.to(DEVICE)
+        outputs = model(imgs)
+        _, predicted = outputs.max(1)
+        total += labels.size(0)
+        correct += predicted.eq(labels).sum().item()
+
+val_acc = 100 * correct / total
+print(f"\n✅ Final Validation Accuracy: {val_acc:.2f}%")
+
+# -------------------------------
+# SAVE MODEL
+# -------------------------------
+torch.save(model.state_dict(), "roof_type_cnn_best.pth")
+print("🧠 Model saved as roof_type_cnn_best.pth")

package.json

@@ -0,0 +1,8 @@
+{
+  "builds": [
+    { "src": "main.py", "use": "@vercel/python" }
+  ],
+  "routes": [
+    { "src": "/(.*)", "dest": "main.py" }
+  ]
+}

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn
+pillow
+numpy
+easyocr
+torch
+torchvision

roof_type_cnn_best.pth

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