Bruh

.gitattributes

@@ -1,35 +1,14 @@
 *.7z filter=lfs diff=lfs merge=lfs -text
 *.arrow filter=lfs diff=lfs merge=lfs -text
 *.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
 *.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
 *.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
 *.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
 *.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
 *.pickle filter=lfs diff=lfs merge=lfs -text
 *.pkl filter=lfs diff=lfs merge=lfs -text
 *.pt filter=lfs diff=lfs merge=lfs -text
 *.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
 *.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
 *.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text
+*.tar.gz filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -2,6 +2,4 @@ __pycache__
 *.pyc
 .env
 *.wav
-
-# Ignore the heavy model file so git doesn't crash
-model.p
+# asl_model.pt is needed here, but usually ignored in git if large

Dockerfile

@@ -9,8 +9,7 @@ RUN apt-get update && apt-get install -y ffmpeg libsndfile1 libmagic1 && rm -rf
 COPY ./requirements.txt /code/requirements.txt
 RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
 
-# Copy all project files (NO model.p)
+# Copy all project files
 COPY . .
 
-# Run the FastAPI app
 CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

asl_model.pt

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

label_map.pkl

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

main.py

@@ -2,17 +2,16 @@ import os
 import io
 import base64
 import uuid
-import torch
 import pickle
 import numpy as np
-import requests
+import torch
+import torch.nn as nn
 from fastapi import FastAPI, HTTPException
 from pydantic import BaseModel
 from typing import List
 from transformers import pipeline
 from PIL import Image
 
-# FALLBACK FOR MAGIC (Prevents crash if libmagic1 is missing)
 try:
     import magic
     MAGIC_AVAILABLE = True
@@ -22,116 +21,69 @@ except ImportError:
 
 app = FastAPI(title="SenseMesh AI Engine")
 
-# --------------------------------------------------------
-# 1. DOWNLOAD MODEL FROM GOOGLE DRIVE IF NOT PRESENT
-# --------------------------------------------------------
-MODEL_URL = "https://drive.google.com/uc?export=download&id=1cT1idReSFH2xzPxhvURR7E0NsarD6AhK"
-MODEL_PATH = "model.p"
-
-def download_model_if_missing():
-    MODEL_URL = "https://drive.google.com/uc?export=download&id=13Yxz1nUB2Az-sjJv73SLpd7k0C7sTHF5"
-    MODEL_PATH = "model.p"
-
-    if os.path.exists(MODEL_PATH):
-        print("Model exists, skipping download.")
-        return
-
-    print("Downloading ASL model...")
-    response = requests.get(MODEL_URL)
-
-    if response.status_code != 200:
-        raise Exception("Failed to download model from Google Drive")
+# 1. MODEL DEFINITION
+class ASLModel(nn.Module):
+    def __init__(self, num_classes):
+        super().__init__()
+        self.lstm = nn.LSTM(150, 128, num_layers=2, batch_first=True, dropout=0.3, bidirectional=True)
+        self.fc = nn.Linear(256, num_classes)
 
-    with open(MODEL_PATH, "wb") as f:
-        f.write(response.content)
+    def forward(self, x):
+        out, _ = self.lstm(x)
+        return self.fc(out[:, -1, :])
 
-    print("Model downloaded successfully!")
-
-# Trigger download if missing
-download_model_if_missing()
-
-# --------------------------------------------------------
-# 2. LOAD ASL MODEL
-# --------------------------------------------------------
+# 2. LOAD RESOURCES
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 asl_model = None
-print(f"Loading ASL Model from {MODEL_PATH}...")
+asl_meta = {}
 
-if os.path.exists(MODEL_PATH):
+if os.path.exists("label_map.pkl") and os.path.exists("asl_model.pt"):
     try:
-        with open(MODEL_PATH, 'rb') as f:
-            model_dict = pickle.load(f)
-            asl_model = model_dict['model'] if isinstance(model_dict, dict) and 'model' in model_dict else model_dict
-        print(" ✅  ASL Model Loaded.")
+        with open("label_map.pkl", "rb") as f:
+            asl_meta = pickle.load(f)
+        
+        num_classes = len(asl_meta["idx_to_label"])
+        print(f"Loading ASL Model for {num_classes} words...")
+        
+        asl_model = ASLModel(num_classes=num_classes)
+        asl_model.load_state_dict(torch.load("asl_model.pt", map_location=device))
+        asl_model.to(device).eval()
+        print(" ✅  ASL LSTM Model Loaded Successfully.")
     except Exception as e:
-        print(f" ❌  ASL Load Error: {e}")
+        print(f" ❌  ASL Load Fail: {e}")
 else:
-    print(" ⚠️  ASL Model not found. Sign language features will fail.")
-
-# --------------------------------------------------------
-# 3. LOAD CORE AI MODELS
-# --------------------------------------------------------
-print("Loading Core AI Models... (Checking for GPU)")
-device = 0 if torch.cuda.is_available() else -1
-print(f"Device set to: {'GPU' if device == 0 else 'CPU'}")
-
-sentiment_pipe = pipeline(
-    "sentiment-analysis",
-    model="distilbert-base-uncased-finetuned-sst-2-english",
-    device=device
-)
-caption_pipe = pipeline(
-    "image-to-text",
-    model="nlpconnect/vit-gpt2-image-captioning",
-    device=device
-)
-transcribe_pipe = pipeline(
-    "automatic-speech-recognition",
-    model="openai/whisper-tiny",
-    device=device
-)
-env_audio_pipe = pipeline(
-    "audio-classification",
-    model="mit/ast-finetuned-audioset-10-10-0.4593",
-    device=device
-)
-
-print(" ✅  All Core Models Loaded.")
+    print(" ⚠️  ASL Files Missing (asl_model.pt or label_map.pkl). Sign Language disabled.")
 
+# 3. LOAD MODELS
+print("Loading Core AI Models...")
+try:
+    sentiment_pipe = pipeline("text-classification", model="j-hartmann/emotion-english-distilroberta-base", top_k=1)
+    transcribe_pipe = pipeline("automatic-speech-recognition", model="openai/whisper-tiny")
+    hazard_pipe = pipeline("audio-classification", model="mit/ast-finetuned-audioset-10-10-0.4593")
+    caption_pipe = pipeline("image-to-text", model="nlpconnect/vit-gpt2-image-captioning")
+    print(" ✅  All Core Models Loaded.")
+except Exception as e:
+    print(f" ⚠️  Core Model Load Warning: {e}")
 
 class Payload(BaseModel):
     data_base64: str = ""
     text: str = ""
 
-
 class LandmarkPayload(BaseModel):
     landmarks: List[float]
 
-
-DANGER_LABELS = [
-    "gunshot", "gunfire", "explosion", "scream", "screaming",
-    "fire alarm", "siren", "glass breaking", "crying", "police car", "ambulance"
-]
-
-
 def save_audio_smartly(base64_string):
-    """Decodes base64 and saves with correct extension based on MIME type"""
     try:
         b64_clean = base64_string.split(",")[1] if "," in base64_string else base64_string
         data = base64.b64decode(b64_clean)
-
-        ext = ".wav"  # Default
+        ext = ".wav"
         if MAGIC_AVAILABLE:
             try:
                 mime = magic.from_buffer(data, mime=True)
-                if "webm" in mime:
-                    ext = ".webm"
-                elif "ogg" in mime:
-                    ext = ".ogg"
-                elif "mp4" in mime:
-                    ext = ".m4a"
-            except Exception:
-                pass
-
+                if "webm" in mime: ext = ".webm"
+                elif "ogg" in mime: ext = ".ogg"
+                elif "mp4" in mime: ext = ".m4a"
+            except: pass
         filename = f"/tmp/{uuid.uuid4()}{ext}"
         with open(filename, "wb") as f:
             f.write(data)
@@ -139,40 +91,17 @@ def save_audio_smartly(base64_string):
     except Exception as e:
         raise HTTPException(status_code=400, detail=f"Audio Decode Error: {str(e)}")
 
-
 @app.get("/")
 def health_check():
-    return {
-        "status": "online",
-        "gpu": torch.cuda.is_available(),
-        "asl_active": asl_model is not None
-    }
-
+    return {"status": "online", "gpu": torch.cuda.is_available(), "asl_active": asl_model is not None}
 
 @app.post("/analyze_text")
 def analyze_text(payload: Payload):
-    results = sentiment_pipe(payload.text)
-    urgency = "low"
-    triggers = ["help", "emergency", "fire", "danger", "hurt", "call 911"]
-    if any(t in payload.text.lower() for t in triggers):
-        urgency = "high"
-    return {"emotion": results[0]["label"], "urgency": urgency}
-
-
-@app.post("/describe")
-def describe_image(payload: Payload):
-    try:
-        b64_str = payload.data_base64.split(",")[1] if "," in payload.data_base64 else payload.data_base64
-        image_data = base64.b64decode(b64_str)
-        image = Image.open(io.BytesIO(image_data))
-        captions = caption_pipe(image)
-        return {"description": captions[0]["generated_text"]}
-    except Exception as e:
-        raise HTTPException(status_code=500, detail=str(e))
-
+    res = sentiment_pipe(payload.text)
+    return {"emotion": res[0][0]['label']}
 
 @app.post("/transcribe")
-def transcribe_audio(payload: Payload):
+def transcribe(payload: Payload):
     filename = None
     try:
         filename = save_audio_smartly(payload.data_base64)
@@ -181,38 +110,55 @@ def transcribe_audio(payload: Payload):
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
     finally:
-        if filename and os.path.exists(filename):
-            os.remove(filename)
-
+        if filename and os.path.exists(filename): os.remove(filename)
 
-@app.post("/detect_sound_event")
-def detect_sound_event(payload: Payload):
+@app.post("/detect_hazard")
+def detect_hazard(payload: Payload):
     filename = None
     try:
         filename = save_audio_smartly(payload.data_base64)
-        results = env_audio_pipe(filename)
-        top_event = results[0]["label"]
-
-        is_dangerous = any(danger in top_event.lower() for danger in DANGER_LABELS)
+        events = hazard_pipe(filename, top_k=5)
+        dangers = ["siren", "alarm", "scream", "explosion", "glass", "gunshot", "fire"]
+        top_event = events[0]['label']
+        is_dangerous = any(d in e['label'].lower() for e in events for d in dangers)
         urgency_level = "critical" if is_dangerous else "low"
-
         return {"event": top_event, "urgency": urgency_level}
     except Exception as e:
         raise HTTPException(status_code=500, detail=str(e))
     finally:
-        if filename and os.path.exists(filename):
-            os.remove(filename)
+        if filename and os.path.exists(filename): os.remove(filename)
+
+@app.post("/describe")
+def describe_image(payload: Payload):
+    try:
+        b64_str = payload.data_base64.split(",")[1] if "," in payload.data_base64 else payload.data_base64
+        image_data = base64.b64decode(b64_str)
+        image = Image.open(io.BytesIO(image_data))
+        captions = caption_pipe(image)
+        return {"description": captions[0]["generated_text"]}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
 
 @app.post("/predict_sign")
 def predict_sign(payload: LandmarkPayload):
-    if not asl_model:
-        return {"gesture": "Error: Model Missing"}
-
+    if not asl_model: return {"gesture": "Error: Model Missing"}
     try:
-        data = np.asarray(payload.landmarks).reshape(1, -1)
-        prediction = asl_model.predict(data)
-        return {"gesture": str(prediction[0])}
-
+        raw_data = np.array(payload.landmarks, dtype=np.float32)
+        if raw_data.size != 30 * 150:
+            return {"gesture": "Shape Error"}
+        
+        # NORMALIZE
+        norm_data = (raw_data - asl_meta["mean"]) / (asl_meta["std"] + 1e-7)
+        input_tensor = torch.tensor(norm_data).reshape(1, 30, 150).to(device)
+        
+        with torch.no_grad():
+            logits = asl_model(input_tensor)
+            idx = torch.argmax(logits, dim=1).item()
+            confidence = torch.softmax(logits, dim=1)[0, idx].item()
+
+        label = asl_meta["idx_to_label"][idx]
+        if confidence < 0.7: return {"gesture": "..."} 
+        return {"gesture": str(label)}
     except Exception as e:
         print("❌ ASL Prediction Error:", e)
         return {"gesture": "Error"}

requirements.txt

@@ -1,19 +1,14 @@
 numpy==1.26.4
 scikit-learn==1.3.0
-
 fastapi
 uvicorn
 python-multipart
-
 torch
 transformers==4.37.2
-
 pillow
 pydantic
-
 scipy
 soundfile
 librosa
 python-magic
-
 requests