Upload 3 files

Dockerfile

@@ -0,0 +1,20 @@
+FROM python:3.10-slim
+
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy all code and artifacts
+COPY . .
+
+# Ensure NLTK data is downloaded (though main.py does this on startup, 
+# it's better to bake it in for faster startup if possible, 
+# but main.py handles it dynamically).
+
+EXPOSE 7860
+# HF Spaces use port 7860 by default for some SDKs, but for Docker we can use any
+# but HF prefers 7860.
+
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,201 @@
+"""
+backend/main.py
+
+Run:
+    pip install -r requirements.txt
+    uvicorn main:app --reload --port 8000
+"""
+
+import os
+import re
+import pickle
+import time
+from contextlib import asynccontextmanager
+from typing import Optional
+
+import nltk
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field, field_validator
+
+# ── NLTK setup ────────────────────────────────────────────────────────────────
+for _pkg, _path in [
+    ("stopwords", "corpora/stopwords"),
+    ("punkt_tab", "tokenizers/punkt_tab"),
+    ("wordnet",   "corpora/wordnet"),
+]:
+    try:
+        nltk.data.find(_path)
+    except LookupError:
+        nltk.download(_pkg, quiet=True)
+
+from nltk.corpus import stopwords
+from nltk.stem import WordNetLemmatizer
+
+_STOP_WORDS = nltk.corpus.stopwords.words("english")
+_LEMMATIZER = WordNetLemmatizer()
+
+
+# ── cleaning() — exact copy from notebook cell 12 ────────────────────────────
+def cleaning(text: str) -> str:
+    preprocessed = str(text).lower()
+    preprocessed = re.sub(r"[^a-zA-Z\s]", "", preprocessed)
+    words = nltk.word_tokenize(preprocessed)
+    filtered_words = [word for word in words if word not in _STOP_WORDS]
+    filtered_words = [_LEMMATIZER.lemmatize(word) for word in filtered_words]
+    return " ".join(filtered_words)
+
+
+# ── Artifact loading ──────────────────────────────────────────────────────────
+ARTIFACT_DIR = os.getenv("ARTIFACT_DIR", "./artifacts")
+
+MODEL      = None
+VECTORIZER = None
+ENCODER    = None
+
+
+def _load(fname: str):
+    path = os.path.join(ARTIFACT_DIR, fname)
+    if not os.path.exists(path):
+        raise FileNotFoundError(
+            f"Artifact not found: {path}\n"
+            f"Unzip model.zip into {ARTIFACT_DIR}/ first."
+        )
+    with open(path, "rb") as f:
+        return pickle.load(f)
+
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    global MODEL, VECTORIZER, ENCODER
+    print(f"Loading artifacts from: {ARTIFACT_DIR}")
+    MODEL      = _load("model.pkl")
+    VECTORIZER = _load("tfidf.pkl")
+    ENCODER    = _load("encoder.pkl")
+    print(f"Model loaded ✓  |  {type(MODEL).__name__}  |  Classes: {list(ENCODER.classes_)}")
+    yield
+    print("Shutting down.")
+
+
+# ── App ───────────────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="Mental Health Sentiment Analysis API",
+    version="1.0.0",
+    lifespan=lifespan,
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+# ── Schemas ───────────────────────────────────────────────────────────────────
+class PredictRequest(BaseModel):
+    text: str = Field(..., min_length=3, max_length=5000)
+
+    @field_validator("text")
+    @classmethod
+    def strip_text(cls, v: str) -> str:
+        return v.strip()
+
+
+class ClassProbability(BaseModel):
+    label: str
+    probability: float
+
+
+class PredictResponse(BaseModel):
+    label: str
+    confidence: float
+    probabilities: list[ClassProbability]
+    cleaned_input: str
+    latency_ms: float
+
+
+class BatchPredictRequest(BaseModel):
+    texts: list[str] = Field(..., min_length=1, max_length=50)
+
+
+class BatchPredictResponse(BaseModel):
+    results: list[PredictResponse]
+    total_latency_ms: float
+
+
+class HealthResponse(BaseModel):
+    status: str
+    model_loaded: bool
+    model_type: Optional[str] = None
+    classes: Optional[list[str]] = None
+
+
+# ── Core inference ────────────────────────────────────────────────────────────
+def _infer(text: str) -> PredictResponse:
+    t0 = time.perf_counter()
+
+    cleaned = cleaning(text)
+    if not cleaned.strip():
+        raise HTTPException(status_code=422, detail="Text is empty after preprocessing.")
+
+    vec        = VECTORIZER.transform([cleaned])
+    pred_idx   = MODEL.predict(vec)[0]
+    label      = ENCODER.inverse_transform([pred_idx])[0]
+    proba      = MODEL.predict_proba(vec)[0]
+    confidence = float(proba[pred_idx])
+
+    probs_sorted = [
+        ClassProbability(label=cls, probability=round(float(p), 4))
+        for cls, p in sorted(
+            zip(ENCODER.classes_, proba),
+            key=lambda x: x[1],
+            reverse=True,
+        )
+    ]
+
+    return PredictResponse(
+        label         = label,
+        confidence    = round(confidence, 4),
+        probabilities = probs_sorted,
+        cleaned_input = cleaned,
+        latency_ms    = round((time.perf_counter() - t0) * 1000, 2),
+    )
+
+
+# ── Routes ────────────────────────────────────────────────────────────────────
+@app.get("/", response_model=HealthResponse)
+def health():
+    return HealthResponse(
+        status       = "ok",
+        model_loaded = MODEL is not None,
+        model_type   = type(MODEL).__name__ if MODEL else None,
+        classes      = list(ENCODER.classes_) if ENCODER else None,
+    )
+
+
+@app.post("/predict", response_model=PredictResponse)
+def predict(req: PredictRequest):
+    if MODEL is None:
+        raise HTTPException(status_code=503, detail="Model not loaded.")
+    return _infer(req.text)
+
+
+@app.post("/predict/batch", response_model=BatchPredictResponse)
+def predict_batch(req: BatchPredictRequest):
+    if MODEL is None:
+        raise HTTPException(status_code=503, detail="Model not loaded.")
+    t0 = time.perf_counter()
+    results = [_infer(t) for t in req.texts]
+    return BatchPredictResponse(
+        results          = results,
+        total_latency_ms = round((time.perf_counter() - t0) * 1000, 2),
+    )
+
+
+@app.get("/classes")
+def get_classes():
+    if ENCODER is None:
+        raise HTTPException(status_code=503, detail="Model not loaded.")
+    return {"classes": list(ENCODER.classes_)}

requirements.txt

@@ -0,0 +1,6 @@
+fastapi>=0.111.0
+uvicorn[standard]>=0.29.0
+pydantic>=2.6.0
+scikit-learn>=1.4.0
+nltk>=3.8.1
+numpy>=1.26.0