init

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.12-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+RUN chmod -R 777 /app
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,108 @@
+import pickle
+import numpy as np
+import io
+import math
+import cv2
+from skimage.feature import hog
+from fastapi import FastAPI, File, UploadFile, HTTPException
+from PIL import Image
+
+app = FastAPI(
+    title="Enhanced Peruvian Sign Language (LSP) Recognition API",
+    description="Upload an image of a Peruvian Sign Language alphabet sign to predict the corresponding letter using an enhanced Self-Organizing Map (SOM) with HOG features.",
+    version="2.0.0"
+)
+
+MODEL_FILENAME = 'lsp_som_model_enhanced.pkl'
+try:
+    with open(MODEL_FILENAME, 'rb') as f:
+        model_data = pickle.load(f)
+    som = model_data['som']
+    label_map = model_data['label_map']
+    CLASSES = model_data['classes']
+    IMG_SIZE = model_data['img_size']
+    HOG_PARAMS = model_data['feature_extraction_params'] # Load HOG parameters
+    print(f"✅ Model '{MODEL_FILENAME}' and assets loaded successfully.")
+    print(f"    - Classes: {CLASSES}")
+    print(f"    - Expected Image Size for Processing: {IMG_SIZE}x{IMG_SIZE}")
+    print(f"    - Feature Extractor: {HOG_PARAMS['type']}")
+except FileNotFoundError:
+    print(f"❌ FATAL ERROR: Model file '{MODEL_FILENAME}' not found.")
+    som = None
+
+def preprocess_and_extract_features_from_bytes(image_bytes: bytes):
+    try:
+        nparr = np.frombuffer(image_bytes, np.uint8)
+        img_bgr = cv2.imdecode(nparr, cv2.IMREAD_COLOR)
+        if img_bgr is None:
+            raise ValueError("Could not decode image bytes. The file may be corrupt or not an image.")
+        img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
+
+        ycrcb = cv2.cvtColor(img_rgb, cv2.COLOR_RGB2YCrCb)
+        skin_mask = cv2.inRange(ycrcb, np.array([0, 135, 85]), np.array([255, 180, 135]))
+
+        contours, _ = cv2.findContours(skin_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        if not contours:
+            raise ValueError("No contours found in the image. The hand sign may not be clear enough.")
+
+        largest_contour = max(contours, key=cv2.contourArea)
+        x, y, w, h = cv2.boundingRect(largest_contour)
+        cropped_hand = img_rgb[y:y+h, x:x+w]
+        
+        resized_hand = cv2.resize(cropped_hand, (IMG_SIZE, IMG_SIZE))
+        gray_hand = cv2.cvtColor(resized_hand, cv2.COLOR_RGB2GRAY)
+
+        hog_features = hog(gray_hand,
+                           orientations=HOG_PARAMS['orientations'],
+                           pixels_per_cell=HOG_PARAMS['pixels_per_cell'],
+                           cells_per_block=HOG_PARAMS['cells_per_block'],
+                           transform_sqrt=HOG_PARAMS['transform_sqrt'],
+                           block_norm=HOG_PARAMS['block_norm'])
+        
+        return hog_features
+
+    except Exception as e:
+        raise HTTPException(status_code=400, detail=f"Image processing failed. Error: {e}")
+
+
+@app.get("/", tags=["Status"])
+def read_root():
+    return {"status": "ok", "message": "Welcome to the Enhanced LSP Recognition API!"}
+
+@app.post("/predict", tags=["Prediction"])
+async def predict_sign(file: UploadFile = File(..., description="An image file of a Peruvian Sign Language sign.")):
+    if not som:
+        raise HTTPException(status_code=503, detail="Model is not available. API cannot process requests.")
+
+    image_bytes = await file.read()
+
+    feature_vector = preprocess_and_extract_features_from_bytes(image_bytes)
+
+    winner_neuron = som.winner(feature_vector)
+    predicted_index = label_map.get(winner_neuron, -1)
+
+    is_best_guess = False
+    if predicted_index == -1:
+        is_best_guess = True
+        min_dist = float('inf')
+        for mapped_pos, mapped_label in label_map.items():
+            dist = math.sqrt((winner_neuron[0] - mapped_pos[0])**2 + (winner_neuron[1] - mapped_pos[1])**2)
+            if dist < min_dist:
+                min_dist = dist
+                predicted_index = mapped_label
+    
+    if predicted_index != -1:
+        predicted_letter = CLASSES[predicted_index]
+        prediction_type = "Nearest Neighbor Guess" if is_best_guess else "Direct Match"
+    else:
+        predicted_letter = "Unknown"
+        prediction_type = "Critical Error: No mapped neurons found on the entire map."
+
+    response = {
+        "filename": file.filename,
+        "predicted_letter": predicted_letter,
+        "prediction_type": prediction_type,
+        "winner_neuron_on_map": [int(coord) for coord in winner_neuron]
+    }
+    print(f"[LOG] Prediction successful. Response: {response}")
+    return response

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+python-multipart
+minisom
+numpy
+Pillow
+scikit-image
+opencv-python-headless