Upload 4 files

Dockerfile

@@ -0,0 +1,35 @@
+
+FROM python:3.10-slim
+
+# ── System deps ──
+RUN apt-get update && apt-get install -y --no-install-recommends \
+        libgl1 \
+        libglib2.0-0 \
+        libsm6 \
+        libxrender1 \
+        libxext6 \
+    && rm -rf /var/lib/apt/lists/*
+
+# ── Non-root user required by Hugging Face Spaces ──
+RUN useradd -m -u 1000 user
+USER user
+
+ENV HOME=/home/user \
+    PATH=/home/user/.local/bin:$PATH \
+    PYTHONUNBUFFERED=1
+
+WORKDIR /home/user/app
+
+# ── Install Python deps ──
+COPY --chown=user requirements.txt ./
+RUN pip install --no-cache-dir --upgrade pip \
+ && pip install --no-cache-dir -r requirements.txt
+
+#  Copy app source 
+COPY --chown=user . .
+
+#  Expose port (Hugging Face Spaces uses 7860) ──
+EXPOSE 7860
+
+# ── Start server ──
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,271 @@
+import io
+import os
+import logging
+import numpy as np
+import pandas as pd
+import cv2
+from pathlib import Path
+from contextlib import asynccontextmanager
+
+import uvicorn
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from fastapi.responses import JSONResponse
+from fastapi.middleware.cors import CORSMiddleware
+from PIL import Image
+from sklearn.preprocessing import LabelEncoder
+import tensorflow as tf
+
+# ──────────────────────────────────────────────
+# Logging
+# ──────────────────────────────────────────────
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ──────────────────────────────────────────────
+# Paths  (relative — works inside the Space)
+# ──────────────────────────────────────────────
+MODEL_PATH  = os.getenv("MODEL_PATH",  "IrisRecognizer95.h5")
+CSV_PATH    = os.getenv("CSV_PATH",    "Banned_travelers22.csv")
+
+# ──────────────────────────────────────────────
+# Image config  (must match training)
+# ──────────────────────────────────────────────
+IMG_HEIGHT   = 150
+IMG_WIDTH    = 150
+NUM_CHANNELS = 1
+
+# ──────────────────────────────────────────────
+# Globals (loaded once at startup)
+# ──────────────────────────────────────────────
+model:         tf.keras.Model | None = None
+banned_df:     pd.DataFrame  | None = None
+label_encoder: LabelEncoder  | None = None
+
+
+# ──────────────────────────────────────────────
+# Preprocessing helpers
+# ──────────────────────────────────────────────
+def resize_keep_aspect_ratio(
+    img: np.ndarray,
+    target_h: int = IMG_HEIGHT,
+    target_w: int = IMG_WIDTH,
+    pad_value: int = 255,
+) -> np.ndarray:
+    """Resize grayscale image while preserving aspect ratio (white padding)."""
+    aspect = img.shape[1] / img.shape[0]
+    if aspect > target_w / target_h:
+        new_w = target_w
+        new_h = int(target_w / aspect)
+    else:
+        new_h = target_h
+        new_w = int(target_h * aspect)
+
+    resized  = cv2.resize(img, (new_w, new_h))
+    padded   = np.full((target_h, target_w), pad_value, dtype=np.uint8)
+    x_off    = (target_w - new_w) // 2
+    y_off    = (target_h - new_h) // 2
+    padded[y_off:y_off + new_h, x_off:x_off + new_w] = resized
+    return padded
+
+
+def preprocess_image_bytes(image_bytes: bytes) -> np.ndarray:
+    """
+    Convert raw image bytes → model-ready numpy array  (1, 150, 150, 1).
+    Steps:
+      1. Decode to grayscale
+      2. Resize with aspect-ratio padding
+      3. Normalise to [0, 1]
+      4. Expand dims for batch + channel
+    """
+    # Decode via PIL (handles JPEG / PNG / BMP …)
+    pil_img = Image.open(io.BytesIO(image_bytes)).convert("L")  # grayscale
+    img_np  = np.array(pil_img, dtype=np.uint8)
+
+    img_resized   = resize_keep_aspect_ratio(img_np)
+    img_norm      = img_resized.astype(np.float32) / 255.0
+    img_expanded  = img_norm.reshape(1, IMG_HEIGHT, IMG_WIDTH, NUM_CHANNELS)
+    return img_expanded
+
+
+# ──────────────────────────────────────────────
+# Startup / shutdown
+# ──────────────────────────────────────────────
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global model, banned_df, label_encoder
+
+    # ── Load model ──
+    if not Path(MODEL_PATH).exists():
+        logger.error(f"Model file not found: {MODEL_PATH}")
+        raise FileNotFoundError(f"Model not found: {MODEL_PATH}")
+
+    logger.info(f"Loading model from {MODEL_PATH} …")
+    model = tf.keras.models.load_model(MODEL_PATH)
+    logger.info("Model loaded ✓")
+
+    # ── Load banned-traveler CSV ──
+    if not Path(CSV_PATH).exists():
+        logger.error(f"CSV file not found: {CSV_PATH}")
+        raise FileNotFoundError(f"CSV not found: {CSV_PATH}")
+
+    logger.info(f"Loading banned-traveler list from {CSV_PATH} …")
+    banned_df = pd.read_csv(CSV_PATH)
+
+    # Normalise column names (strip spaces / lower)
+    banned_df.columns = banned_df.columns.str.strip()
+
+    required_cols = {"Label", "person_id", "Status"}
+    missing = required_cols - set(banned_df.columns)
+    if missing:
+        raise ValueError(f"CSV is missing columns: {missing}")
+
+    banned_df["Label"]     = banned_df["Label"].astype(str).str.strip()
+    banned_df["person_id"] = banned_df["person_id"].astype(str).str.strip()
+    banned_df["Status"]    = banned_df["Status"].astype(str).str.strip()
+
+    # ── Build LabelEncoder from CSV labels (same as training) ──
+    label_encoder = LabelEncoder()
+    label_encoder.fit(banned_df["Label"].unique())
+    logger.info(
+        f"LabelEncoder fitted on {len(label_encoder.classes_)} classes ✓"
+    )
+    logger.info("Startup complete — API ready.")
+
+    yield  # ── app is running ──
+
+    logger.info("Shutting down …")
+
+
+# ──────────────────────────────────────────────
+# FastAPI app
+# ──────────────────────────────────────────────
+app = FastAPI(
+    title="Iris Recognition — Banned Traveler Detection",
+    description=(
+        "Upload an iris image and the API will tell you "
+        "whether the person is banned from travelling or not."
+    ),
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ──────────────────────────────────────────────
+# Routes
+# ──────────────────────────────────────────────
+@app.get("/", tags=["Health"])
+def root():
+    return {
+        "message": "Iris Recognition API is running 🚀",
+        "endpoints": {
+            "predict": "/predict  [POST]  — upload iris image",
+            "health":  "/health   [GET]   — service status",
+            "docs":    "/docs     [GET]   — Swagger UI",
+        },
+    }
+
+
+@app.get("/health", tags=["Health"])
+def health():
+    return {
+        "status":          "ok",
+        "model_loaded":    model is not None,
+        "csv_loaded":      banned_df is not None,
+        "num_classes":     int(len(label_encoder.classes_)) if label_encoder else 0,
+        "banned_records":  int(len(banned_df)) if banned_df is not None else 0,
+    }
+
+
+@app.post("/predict", tags=["Prediction"])
+async def predict(file: UploadFile = File(..., description="Iris image (JPEG/PNG)")):
+    """
+    Upload an iris image → returns:
+    - `person_id`     : predicted person identifier
+    - `predicted_label`: predicted label (e.g. '437-R')
+    - `status`        : 'Banned' | 'Allowed' | 'Unknown'
+    - `confidence`    : model confidence score [0-1]
+    - `is_banned`     : boolean
+    """
+    # ── Validate content type ──
+    if file.content_type not in ("image/jpeg", "image/png", "image/jpg", "image/bmp"):
+        raise HTTPException(
+            status_code=415,
+            detail=f"Unsupported image format: {file.content_type}. Use JPEG or PNG.",
+        )
+
+    # ── Read file bytes ──
+    image_bytes = await file.read()
+    if len(image_bytes) == 0:
+        raise HTTPException(status_code=400, detail="Empty file uploaded.")
+
+    # ── Preprocess ──
+    try:
+        img_array = preprocess_image_bytes(image_bytes)
+    except Exception as e:
+        logger.error(f"Image preprocessing failed: {e}")
+        raise HTTPException(status_code=422, detail=f"Could not process image: {str(e)}")
+
+    # ── Inference ──
+    try:
+        probabilities = model.predict(img_array, verbose=0)          # (1, 2000)
+        pred_class_idx = int(np.argmax(probabilities[0]))
+        confidence     = float(np.max(probabilities[0]))
+        predicted_label = str(label_encoder.classes_[pred_class_idx])
+    except Exception as e:
+        logger.error(f"Model inference failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Model inference error: {str(e)}")
+
+    # ── Lookup in banned CSV ──
+    try:
+        match = banned_df[banned_df["Label"] == predicted_label]
+
+        if not match.empty:
+            row       = match.iloc[0]
+            person_id = str(row["person_id"])
+            status    = str(row["Status"])
+        else:
+            # Label predicted but not in CSV → report as unknown
+            person_id = predicted_label.split("-")[0]
+            status    = "Unknown"
+
+        is_banned = status.lower() == "banned"
+
+    except Exception as e:
+        logger.error(f"CSV lookup failed: {e}")
+        raise HTTPException(status_code=500, detail=f"Database lookup error: {str(e)}")
+
+    logger.info(
+        f"[PREDICT] label={predicted_label} | person_id={person_id} "
+        f"| status={status} | confidence={confidence:.4f}"
+    )
+
+    return JSONResponse(
+        content={
+            "person_id":       person_id,
+            "predicted_label": predicted_label,
+            "status":          status,
+            "confidence":      round(confidence, 4),
+            "is_banned":       is_banned,
+            "message": (
+                f"⚠️  BANNED — Person {person_id} is NOT allowed to travel."
+                if is_banned
+                else f"✅  ALLOWED — Person {person_id} is cleared to travel."
+                if status == "Allowed"
+                else f"❓  UNKNOWN — Person {person_id} not found in records."
+            ),
+        }
+    )
+
+
+# ──────────────────────────────────────────────
+# Run locally
+# ──────────────────────────────────────────────
+if __name__ == "__main__":
+    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=False)

requirements.txt

@@ -0,0 +1,16 @@
+# Web framework
+fastapi==0.111.0
+uvicorn[standard]==0.30.1
+python-multipart==0.0.9
+
+# Deep Learning
+tensorflow==2.15.0
+
+# Image processing
+Pillow==10.3.0
+opencv-python-headless==4.9.0.80
+
+# Data
+numpy==1.26.4
+pandas==2.2.2
+scikit-learn==1.5.0