Vision#

Most computer vision projects stop at model training.

This project focuses on the full operational chain required to make a detection model usable in practice:

• Prepare and organize the dataset
• Train a YOLO-based detector
• Package the trained model for inference
• Expose predictions through a REST API
• Containerize the service with Docker
• Deploy it to Azure Container Apps
• Provide a reusable deployment runbook for scale-out operations

Project Attributes#

Post Files#

1
src/content/posts/
2
└── end-to-end-yolo-key-detection/
3
    ├── cover.png
4
    └── index.mdx
5

6
GitHub Repo: dranubhaparashar/End-to-End-YOLO-Key-Detection-System-Training-API-Deployment-and-Azure-Container-Apps/
7
├── dataset/
8
│   └── EV_Keys_2/
9
├── gis-key-detection-func/
10
│   ├── app.py
11
│   ├── Dockerfile
12
│   ├── requirements.txt
13
│   └── best.pt
14
├── runs/
15
│   └── detect/
16
│       └── train14/
17
└── README.md

Why This Matters#

NOTE

A computer vision model becomes useful only when it is servable, testable, and deployable.

IMPORTANT

This project covers the missing middle between training notebook outputs and production-ready inference delivery.

TIP

The same structure can be reused for other object detection use cases with minimal changes to the dataset and model artifacts.

WARNING

Model quality alone is not sufficient — deployment, runtime packaging, security, and observability matter just as much.

CAUTION

Any public demo should avoid exposing production secrets, internal endpoints, or unrestricted inference access.

What This System Does#

Runtime Request Flow#

Core Capabilities#

• YOLO-based object detection for keys
• FastAPI-based REST inference service
• Health endpoint for runtime verification
• API-key protected prediction endpoint
• Dockerized inference packaging
• Cloud deployment to Azure Container Apps
• Public demo surface through Hugging Face Spaces
• Reusable technical documentation and runbook structure

Bento Overview#

Detection and Serving Stack#

Inference Service#

1
from fastapi import FastAPI, UploadFile, File, Header, HTTPException
2
from ultralytics import YOLO
3
from PIL import Image
4
from io import BytesIO
5
from pathlib import Path
6
import os
7

8
app = FastAPI(title="YOLO Key Detection API")
9

10
MODEL_PATH = os.getenv("MODEL_PATH", "/app/best.pt")
11
API_KEY = os.getenv("API_KEY", "change-this-key")
12
CONF_THRESHOLD = float(os.getenv("CONF_THRESHOLD", "0.25"))
13

14
_model = None
15

16
def get_model() -> YOLO:
17
    global _model
18
    if _model is not None:
19
        return _model
20

21
    model_file = Path(MODEL_PATH)
22
    if not model_file.exists():
23
        raise RuntimeError(f"Model file not found: {model_file}")
24

25
    _model = YOLO(str(model_file))
26
    return _model
27

28
@app.get("/health")
29
def health():
30
    model_file = Path(MODEL_PATH)
31
    return {
32
        "status": "ok",
33
        "model_path": str(model_file),
34
        "model_exists": model_file.exists(),
35
        "confidence_threshold": CONF_THRESHOLD,
36
    }
37

38
@app.post("/predict")
39
async def predict(
40
    file: UploadFile = File(...),
41
    x_api_key: str | None = Header(default=None),
42
):
43
    if API_KEY and x_api_key != API_KEY:
44
        raise HTTPException(status_code=401, detail="Invalid API key")
45

46
    image = Image.open(BytesIO(await file.read())).convert("RGB")
47
    model = get_model()
48
    results = model.predict(image, conf=CONF_THRESHOLD, verbose=False)
49
    result = results[0]
50

51
    detections = []
52
    if result.boxes is not None:
53
        names = result.names
54
        for box in result.boxes:
55
            cls_id = int(box.cls.item())
56
            conf = float(box.conf.item())
57
            x1, y1, x2, y2 = [float(v) for v in box.xyxy[0].tolist()]
58
            detections.append({
59
                "class": names.get(cls_id, str(cls_id)) if isinstance(names, dict) else names[cls_id],
60
                "class_id": cls_id,
61
                "confidence": conf,
62
                "bbox_xyxy": [x1, y1, x2, y2],
63
            })
64

65
    return {
66
        "filename": file.filename,
67
        "image_width": image.width,
68
        "image_height": image.height,
69
        "detections": detections,
70
    }

Dependency Stack#

1
fastapi==0.115.12
2
uvicorn[standard]==0.34.0
3
python-multipart==0.0.20
4
pillow==11.2.1
5
ultralytics==8.3.146

Containerization Layer#

1
FROM python:3.11-slim
2

3
ENV PYTHONDONTWRITEBYTECODE=1 \
4
    PYTHONUNBUFFERED=1 \
5
    PORT=8000 \
6
    MODEL_PATH=/app/best.pt \
7
    API_KEY=change-this-key \
8
    CONF_THRESHOLD=0.25
9

10
WORKDIR /app
11

12
RUN apt-get update && apt-get install -y --no-install-recommends \
13
    libgl1 libglib2.0-0 && \
14
    rm -rf /var/lib/apt/lists/*
15

16
COPY requirements.txt .
17
RUN pip install --no-cache-dir --upgrade pip && \
18
    pip install --no-cache-dir --index-url https://download.pytorch.org/whl/cpu torch torchvision && \
19
    pip install --no-cache-dir -r requirements.txt
20

21
COPY app.py .
22
COPY best.pt .
23

24
EXPOSE 8000
25
CMD ["sh", "-c", "uvicorn app:app --host 0.0.0.0 --port ${PORT}"]

Deployment Path#

Runtime Example#

1
# local virtual environment
2
python -m venv .venv
3
source .venv/bin/activate
4

5
# install dependencies
6
pip install -r requirements.txt
7

8
# run API locally
9
uvicorn app:app --host 0.0.0.0 --port 8000
10

11
# health check
12
curl http://localhost:8000/health
13

14
# prediction request
15
curl -X POST "http://localhost:8000/predict" \
16
  -H "x-api-key: change-this-key" \
17
  -F "file=@sample_key.jpg"

Azure Deployment Pattern#

• Build a Docker image for the inference service
• Push the image to Azure Container Registry
• Deploy or update the Azure Container App
• Expose external ingress on the inference port
• Validate runtime through /health
• Execute inference through /predict

1
az login
2
az acr login --name <ACR_NAME>
3

4
docker build -t gis-key-detection:latest .
5
docker tag gis-key-detection:latest <ACR_NAME>.azurecr.io/gis-key-detection:latest
6
docker push <ACR_NAME>.azurecr.io/gis-key-detection:latest
7

8
az containerapp create \
9
  --name <CONTAINER_APP_NAME> \
10
  --resource-group <RESOURCE_GROUP> \
11
  --environment <CONTAINER_APPS_ENV> \
12
  --image <ACR_NAME>.azurecr.io/gis-key-detection:latest \
13
  --target-port 8000 \
14
  --ingress external \
15
  --registry-server <ACR_NAME>.azurecr.io

Public Demo Surface#

IMPORTANT

A public Hugging Face Space provides a lightweight demo surface while the primary production deployment pattern remains Azure Container Apps.

Demo Video#

Engineering Value#

This project is not just about detecting a visual object.

It demonstrates how to take a trained model and make it:

• reproducible
• containerized
• callable through a stable API
• deployable in cloud infrastructure
• portable across demo and production surfaces
• documented for reuse by other engineers

Current Strengths#

• Clear separation between training artifacts and inference service
• Simple API contract for health and prediction
• Parameterized runtime settings
• CPU-compatible deployment path
• Public demo and cloud deployment story in the same project
• Technical runbook orientation rather than notebook-only experimentation

Next Improvements#

• Add formal evaluation metrics and benchmark summary
• Introduce CI/CD for build and deployment automation
• Add model versioning and artifact registry integration
• Add structured logging and request tracing
• Add batch inference mode
• Add request/response schema docs with OpenAPI examples
• Move secrets to managed secret storage for production environments
• Add load and concurrency validation for Azure-hosted runtime

Key Innovation#

IMPORTANT

This project connects computer vision model development with API engineering and cloud deployment discipline.

It turns:

Model Training → Inference Service → Containerized Deployment

rather than stopping at experimentation.

Conclusion#

This repository shows how an object detection solution can evolve from a YOLO training workflow into a deployable engineering asset.

It combines:

• dataset organization
• training outputs
• FastAPI inference serving
• Docker packaging
• Azure Container Apps deployment
• public demo exposure
• technical runbook documentation

Final Thought#

From training a key detector
to shipping a cloud-ready computer vision service

The real value is not only the model — it is the end-to-end delivery architecture.