pushing to hf spaces

Dockerfile

@@ -0,0 +1,37 @@
+# Use slim Python base
+FROM python:3.10-slim
+
+# Set environment variables
+ENV PYTHONDONTWRITEBYTECODE 1
+ENV PYTHONUNBUFFERED 1
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    git ffmpeg libsm6 libxext6 libgl1 && \
+    apt-get clean && rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Copy only relevant files
+COPY requirements.txt .
+
+# Install Python dependencies first (leverages Docker cache)
+RUN pip install --upgrade pip && pip install -r requirements.txt
+
+# Now copy the rest of the code (after installing deps for better caching)
+COPY . .
+
+# ✅ Explicitly copy the pretrained model weights if you're using them
+COPY models/ models/
+
+# Streamlit environment config
+ENV STREAMLIT_SERVER_HEADLESS=true
+ENV STREAMLIT_SERVER_PORT=7860
+ENV STREAMLIT_SERVER_ADDRESS=0.0.0.0
+
+# Expose the port used by Streamlit
+EXPOSE 7860
+
+# Start the app
+CMD ["streamlit", "run", "app.py"]

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Akshath
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,12 +1,17 @@
----
-title: D And W
-emoji: 🐨
-colorFrom: gray
-colorTo: pink
-sdk: docker
-pinned: false
-license: mit
-short_description: an application.
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# doors-and-windows
+an application that serves inference to detect doors and windows from architecture / floor plans. 
+
+step 0: learn to read architecture plans to distinguish between doors and windows. (DONE)
+
+1. annotate data and save the labels. (DONE)
+2. train the model, explain the difference between yolov8n and yolov8s, show which one is better. (DONE)
+4. api development: will be a little hard. (DONE)
+5. full cleanup (DONE) + streamlit setup (DONE)
+6. deployment onto hf spaces + docker.
+
+extras:
+
+1. linting + formatting.
+2. mention model stats, like inference time, precision, etc.
+3. add visualization by integrating wandb / tensorboard (user choice)
+4. smooth web app and create api contract.

app.py

@@ -0,0 +1,67 @@
+# streamlit_app.py
+
+import streamlit as st
+from PIL import Image, ImageDraw
+import numpy as np
+import io
+from src.config import AVAILABLE_MODELS, DEFAULT_MODEL
+from src.detection import load_model, read_image_bytes, run_detection
+
+st.set_page_config(page_title="Blueprint Object Detection", layout="centered")
+
+st.title("Door & Window Detection from Blueprints")
+st.markdown("Upload a floorplan and select a model to detect doors and windows.")
+
+# Sidebar - Model selection
+model_choice = st.sidebar.selectbox("Choose YOLOv8 Model", AVAILABLE_MODELS, index=AVAILABLE_MODELS.index(DEFAULT_MODEL))
+
+# Upload image
+uploaded_file = st.file_uploader("Upload a blueprint image", type=["jpg", "jpeg", "png"])
+
+import os
+os.environ["TORCH_HOME"] = "/tmp/torch_home"  # Optional, to reduce torch path issues
+
+import warnings
+warnings.filterwarnings("ignore", category=UserWarning)
+
+
+if uploaded_file:
+    # Show the uploaded image
+    image = Image.open(uploaded_file).convert("RGB")
+    st.image(image, caption="Uploaded Image", use_container_width=True)
+
+    if st.button("🔍 Run Detection"):
+        # Inference - Use the run_detection function instead
+        image_bytes = uploaded_file.getvalue()
+        results = run_detection(image_bytes, uploaded_file.name, model_choice)
+        detections = results["detections"]
+
+        # Draw bounding boxes
+        draw = ImageDraw.Draw(image)
+        for det in detections:
+            label = det["label"]
+            conf = det["confidence"]
+            bbox = det["bbox"]
+            # bbox is in format [x1, y1, x2, y2]
+            draw.rectangle([(bbox[0], bbox[1]), (bbox[2], bbox[3])], outline="red", width=2)
+            draw.text((bbox[0], bbox[1] - 10), f"{label} ({conf:.2f})", fill="red")
+
+        st.image(image, caption="Detections", use_container_width=True)
+
+        # Show detection results
+        st.markdown("### Detection Results")
+        if detections:
+            st.success(f"Found {len(detections)} detections!")
+            st.dataframe(detections)
+        else:
+            st.warning("No detections found. This could be due to:")
+            st.write("- Low confidence threshold")
+            st.write("- Model not trained on this type of image")
+            st.write("- Image quality or resolution issues")
+            st.write("- Objects too small or unclear in the image")
+            
+            # Add some debugging info
+            st.markdown("### Debug Information")
+            st.write(f"Image size: {image.size}")
+            st.write(f"Model: {model_choice}")
+            st.write("Try adjusting the confidence threshold in your config file.")

config.yaml

@@ -0,0 +1,18 @@
+model_paths:
+  yolov8n: models/pt/yolov8n.pt
+  yolov8s: models/pt/yolov8s.pt
+  yolov8m: models/pt/yolov8m.pt
+
+gflops_map:
+  YOLOv8n: 8.1
+  YOLOv8s: 28.4
+  YOLOv8m: 78.7
+
+dataset:
+  input_dir: ./images/
+  annos_dir: ./annotations/
+  output_dir: ./dataset/
+  data_yaml: ./dataset/data.yaml
+
+params: 
+  confidence_threshold: 0.1

model_comparison.txt

@@ -0,0 +1,44 @@
+========================================
+YOLOv8n Validation Results
+========================================
+Parameters: 3006038
+GFLOPs: 8.1
+Speed (inference): 32.65 ms/image
+
+Class     | Precision | Recall
+0          | 0.945     | 0.206
+1          | 1.000     | 0.000
+
+Overall:
+mAP@50: 0.231
+mAP@50-95: 0.119
+
+========================================
+YOLOv8s Validation Results
+========================================
+Parameters: 11126358
+GFLOPs: 28.4
+Speed (inference): 74.78 ms/image
+
+Class     | Precision | Recall
+0          | 0.682     | 0.559
+1          | 0.290     | 0.267
+
+Overall:
+mAP@50: 0.411
+mAP@50-95: 0.239
+
+========================================
+YOLOv8m Validation Results
+========================================
+Parameters: 25840918
+GFLOPs: 78.7
+Speed (inference): 158.06 ms/image
+
+Class     | Precision | Recall
+0          | 0.807     | 0.559
+1          | 0.165     | 0.433
+
+Overall:
+mAP@50: 0.406
+mAP@50-95: 0.235

models/onnx/yolov8m.onnx

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

models/onnx/yolov8n.onnx

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

models/onnx/yolov8s.onnx

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

models/pt/yolov8m.pt

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

models/pt/yolov8n.pt

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

models/pt/yolov8s.pt

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

render.yaml

@@ -0,0 +1,7 @@
+services:
+  - type: web
+    name: doors-and-windows
+    env: python
+    plan: free
+    buildCommand: pip install -r requirements.txt
+    startCommand: streamlit run app.py

requirements.txt

@@ -0,0 +1,9 @@
+streamlit
+ultralytics
+opencv-python
+opencv-python-headless
+Pillow
+numpy
+onnx
+fastapi
+python-dotenv

spaces.yaml

@@ -0,0 +1 @@
+sdk: docker

src/config.py

@@ -0,0 +1,23 @@
+import os
+import yaml
+
+from pathlib import Path
+from dotenv import load_dotenv
+load_dotenv()
+
+# Load YAML config
+CONFIG_PATH = Path(__file__).resolve().parents[1] / "config.yaml"
+with open(CONFIG_PATH, "r") as f:
+    config = yaml.safe_load(f)
+
+# YOLO model paths
+MODEL_PATHS = config.get("model_paths", {})
+DEFAULT_MODEL = next(iter(MODEL_PATHS), "yolov8n")  # Use first model if none explicitly set
+AVAILABLE_MODELS = list(MODEL_PATHS.keys())
+
+CONFIDENCE_THRESHOLD = config.get("params", {}).get("confidence_threshold")
+DATASET_CONFIG = config.get("palcode-ai-1", {})
+ROBOFLOW_API = os.getenv("ROBOFLOW_API")
+WORKSPACE_NAME = os.getenv("WORKSPACE_NAME")
+PROJECT_NAME = os.getenv("PROJECT_NAME")
+DEBUG = True

src/detection.py

@@ -0,0 +1,88 @@
+# app/detection.py
+
+from ultralytics import YOLO
+import numpy as np
+import cv2
+from io import BytesIO
+from PIL import Image
+from typing import List, Dict, Any
+from .config import MODEL_PATHS, CONFIDENCE_THRESHOLD
+
+# Global model cache
+MODEL_CACHE = {}
+
+def load_model(model_name: str) -> YOLO:
+    """
+    Load and cache a YOLO model.
+
+    Args:
+        model_name (str): Key name of the model.
+
+    Returns:
+        YOLO: Loaded YOLO model instance.
+    """
+    if model_name not in MODEL_CACHE:
+        model_path = MODEL_PATHS.get(model_name)
+        if model_path is None:
+            raise ValueError(f"Model path for {model_name} not found.")
+        MODEL_CACHE[model_name] = YOLO(model_path)
+
+    return MODEL_CACHE[model_name]
+
+def read_image_bytes(image_bytes: bytes) -> np.ndarray:
+    """
+    Converts uploaded image bytes to a NumPy array.
+
+    Args:
+        image_bytes (bytes): Image file bytes.
+
+    Returns:
+        np.ndarray: OpenCV-compatible image array (BGR).
+    """
+    image = Image.open(BytesIO(image_bytes)).convert("RGB")
+    return cv2.cvtColor(np.array(image), cv2.COLOR_RGB2BGR)
+
+def run_detection(image_bytes: bytes, filename: str, model_name: str, conf_threshold: float = None) -> Dict[str, Any]:
+    """
+    Perform detection using a YOLO model.
+    
+    Args:
+        image_bytes (bytes): Image file bytes.
+        filename (str): Name of the uploaded file.
+        model_name (str): Name of the model to use.
+        conf_threshold (float, optional): Confidence threshold. Uses config default if None.
+    
+    Returns:
+        Dict[str, Any]: Detection results with filename and detections list.
+    """
+    model = load_model(model_name)
+    image = read_image_bytes(image_bytes)
+    
+    # Use provided threshold or fall back to config
+    threshold = conf_threshold if conf_threshold is not None else CONFIDENCE_THRESHOLD
+    
+    # Run inference with lower confidence to see if there are any detections
+    results = model.predict(image, conf=threshold, verbose=True)
+
+    detections = []
+    for result in results:
+        if result.boxes is not None and len(result.boxes) > 0:
+            num_boxes = len(result.boxes)
+            for i in range(num_boxes):
+                cls_id = int(result.boxes.cls[i].item())
+                conf = float(result.boxes.conf[i].item())
+                bbox = result.boxes.xyxy[i].tolist()
+
+                detections.append({
+                    "label": model.names[cls_id],
+                    "confidence": round(conf, 3),
+                    "bbox": [round(coord, 2) for coord in bbox]
+                })
+
+    return {
+        "filename": filename,
+        "detections": detections,
+        "total_detections": len(detections),
+        "confidence_threshold": threshold,
+        "image_shape": image.shape
+    }

src/main.py

@@ -0,0 +1,40 @@
+# app/main.py
+
+from fastapi import FastAPI, File, UploadFile, HTTPException, Query
+from fastapi.responses import JSONResponse
+from detection import run_detection
+from .config import AVAILABLE_MODELS, DEFAULT_MODEL
+
+app = FastAPI(title="Blueprint Object Detector", version="1.0")
+
+@app.post("/detect")
+async def detect(
+    image: UploadFile = File(...),
+    model_name: str = Query(DEFAULT_MODEL, description="Choose model variant")
+):
+    """
+    Endpoint to detect doors/windows in uploaded blueprint image.
+
+    Args:
+        image (UploadFile): Uploaded blueprint image.
+        model_name (str): YOLO model name (e.g., 'yolov8n', 'yolov8s').
+
+    Returns:
+        JSONResponse: Formatted detection output.
+    """
+    if model_name not in AVAILABLE_MODELS:
+        raise HTTPException(
+            status_code=400,
+            detail=f"Invalid model name. Available: {AVAILABLE_MODELS}"
+        )
+
+    if not image.content_type.startswith("image/"):
+        raise HTTPException(status_code=400, detail="Invalid file type. Upload an image.")
+
+    image_bytes = await image.read()
+
+    try:
+        result = run_detection(image_bytes, filename=image.filename, model_name=model_name)
+        return JSONResponse(content=result)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Detection failed: {str(e)}")

src/utils.py

@@ -0,0 +1,93 @@
+import os
+import shutil
+import random
+from pathlib import Path
+from typing import Union, Dict
+from ultralytics import YOLO
+import onnx
+from .config import DATASET_CONFIG, MODEL_PATHS, WORKSPACE_NAME, PROJECT_NAME, ROBOFLOW_API
+
+random.seed(42)
+
+def create_dataset(val_split: float = 0.2):
+    input_dir = Path(DATASET_CONFIG.get("input_dir", "images/"))
+    annos_dir = Path(DATASET_CONFIG.get("annos_dir", "annotations/"))
+    output_dir = Path(DATASET_CONFIG.get("output_dir", "dataset/"))
+
+    for split in ["train", "val"]:
+        (output_dir / split / "images").mkdir(parents=True, exist_ok=True)
+        (output_dir / split / "labels").mkdir(parents=True, exist_ok=True)
+
+    image_files = list(input_dir.glob("*.jpg")) + list(input_dir.glob("*.png"))
+    random.shuffle(image_files)
+
+    split_index = int(len(image_files) * (1 - val_split))
+    train_images = image_files[:split_index]
+    val_images = image_files[split_index:]
+
+    def process(images, split):
+        for img_path in images:
+            label_path = annos_dir / (img_path.stem + ".txt")
+            if not label_path.exists():
+                print(f"[WARNING] Missing label for: {img_path.name}")
+                continue
+            shutil.copy2(img_path, output_dir / split / "images" / img_path.name)
+            shutil.copy2(label_path, output_dir / split / "labels" / label_path.name)
+
+    process(train_images, "train")
+    process(val_images, "val")
+
+    print(f"[DONE] Dataset created at: {output_dir}")
+    print(f" - Training images: {len(train_images)}")
+    print(f" - Validation images: {len(val_images)}")
+
+
+def log_model_comparisons(gflops_map: Dict[str, float], log_file: str = "model_comparison_log.txt"):
+    data_yaml = DATASET_CONFIG.get("data_yaml", "./dataset/data.yaml")
+
+    with open(log_file, "w") as f:
+        for name, path in MODEL_PATHS.items():
+            print(f"Validating model: {name}, path: {path}")
+            model = YOLO(path)
+            metrics = model.val(data=data_yaml)
+
+            f.write(f"\n{'='*40}\n{name} Validation Results\n{'='*40}\n")
+            f.write(f"Parameters: {sum(p.numel() for p in model.model.parameters())}\n")
+            f.write(f"GFLOPs: {gflops_map.get(name, 'N/A')}\n")
+            f.write(f"Speed (inference): {metrics.speed['inference']:.2f} ms/image\n\n")
+
+            f.write("Class     | Precision | Recall\n")
+            for i, cls in enumerate(model.model.names):
+                prec = metrics.box.p[i].item()
+                rec = metrics.box.r[i].item()
+                f.write(f"{cls:<10} | {prec:.3f}     | {rec:.3f}\n")
+
+            f.write("\nOverall:\n")
+            f.write(f"mAP@50: {metrics.box.map50:.3f}\n")
+            f.write(f"mAP@50-95: {metrics.box.map:.3f}\n")
+
+
+def export_models_to_weights_dir(output_dir: str = "weights"):
+    os.makedirs(output_dir, exist_ok=True)
+
+    for model_name, model_path in MODEL_PATHS.items():
+        print(f"\nExporting {model_name} from {model_path}...")
+
+        model = YOLO(model_path)
+
+        # Copy .pt file
+        pt_dest = os.path.join(output_dir, f"{model_name.lower()}.pt")
+        shutil.copy(model_path, pt_dest)
+        print(f"Saved: {pt_dest}")
+
+        # Export to ONNX format
+        onnx_path = model.export(format="onnx")
+        exported_onnx_path = os.path.join(output_dir, f"{model_name.lower()}.onnx")
+        shutil.move(onnx_path, exported_onnx_path)
+        print(f"Saved: {exported_onnx_path}")
+
+def init_roboflow(): 
+    from roboflow import Roboflow
+    rf = Roboflow(api_key=ROBOFLOW_API)
+    project = rf.workspace(WORKSPACE_NAME).project(PROJECT_NAME)
+    dataset = project.version(1).download("yolov5")

weights/yolo11n.pt

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

weights/yolov8n.pt

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