hf spaces deploy: port 7860, startup script, Dockerfile fix, backend refactor

.gitignore

@@ -1,3 +1,28 @@
 .venv/
 __pycache__/
-.env
+.env
+
+# Python artifacts
+*.py[cod]
+*.pyo
+*.egg-info/
+dist/
+build/
+
+# OS
+.DS_Store
+Thumbs.db
+
+# IDE
+.vscode/
+.idea/
+
+# Model weights (large binary files)
+*.bin
+*.safetensors
+*.pt
+*.pth
+*.ckpt
+
+# Logs
+*.log

Dockerfile

@@ -1,13 +1,30 @@
 FROM python:3.11-slim
 
+# HF Spaces runs as a non-root user — create one
+RUN useradd -m -u 1000 appuser
+
 WORKDIR /app
 
+# Install system deps + curl (used by start.sh health check)
+RUN apt-get update && apt-get install -y --no-install-recommends curl && rm -rf /var/lib/apt/lists/*
+
+# Install Python dependencies
 COPY requirements.txt .
 RUN pip install --no-cache-dir -r requirements.txt
 
+# Copy source code
 COPY backend/ ./backend/
 COPY frontend/ ./frontend/
+COPY start.sh .
+
+# Make startup script executable
+RUN chmod +x start.sh
+
+# Switch to non-root user (required by HF Spaces)
+RUN chown -R appuser:appuser /app
+USER appuser
+
+# HF Spaces expects port 7860
+EXPOSE 7860
 
-CMD uvicorn backend.main:app --host 0.0.0.0 --port 8000 --app-dir /app & \
-    python frontend/app.py & \
-    wait
+CMD ["./start.sh"]

backend/classifier.py

@@ -33,24 +33,27 @@ LABEL_NAMES = [
     "verify_top_up", "virtual_card_not_working", "visa_or_mastercard",
     "why_verify_identity", "wrong_amount_of_cash_received",
     "wrong_exchange_rate_for_cash_withdrawal",
-    "unknown" 
+    "unknown"
 ]
 
+THRESHOLD = 40.0
+
+
 class IntentClassifier:
     def __init__(self):
         print("Loading classifier...")
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        
+
         self.tokenizer = AutoTokenizer.from_pretrained(MODEL_BASE)
         self.tokenizer.pad_token = self.tokenizer.eos_token
-        
+
         base_model = AutoModelForSequenceClassification.from_pretrained(
             MODEL_BASE,
             num_labels=len(LABEL_NAMES),
-            torch_dtype=torch.float16,
+            dtype=torch.float16,       # fixed: was torch_dtype=
             device_map="cpu"
         )
-        
+
         self.model = PeftModel.from_pretrained(base_model, PEFT_MODEL)
         self.model.eval()
         print("Classifier loaded!")
@@ -66,21 +69,17 @@ class IntentClassifier:
 
         with torch.no_grad():
             outputs = self.model(**inputs)
-            logits = outputs.logits
-            probs = torch.softmax(logits, dim=-1)
+            probs = torch.softmax(outputs.logits, dim=-1)
             top3 = torch.topk(probs, 3)
 
-        results = []
-        for score, idx in zip(top3.values[0], top3.indices[0]):
-            results.append({
+        results = [
+            {
                 "intent": LABEL_NAMES[idx.item()],
                 "confidence": round(score.item() * 100, 2)
-            })
+            }
+            for score, idx in zip(top3.values[0], top3.indices[0])
+        ]
 
-        top_confidence = results[0]["confidence"]
-        
-        # Confidence threshold — if model is uncertain, say so
-        THRESHOLD = 40.0
         if results[0]["intent"] == "unknown" or results[0]["confidence"] < THRESHOLD:
             return {
                 "top_intent": "unknown",
@@ -90,29 +89,23 @@ class IntentClassifier:
 
         return {
             "top_intent": results[0]["intent"],
-            "confidence": top_confidence,
+            "confidence": results[0]["confidence"],
             "top3": results
         }
 
-classifier = IntentClassifier()
 
 class ZeroShotClassifier:
-    def __init__(self):
-        print("Loading zero-shot classifier...")
-        self.device = "cpu"
-        
-        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_BASE)
-        self.tokenizer.pad_token = self.tokenizer.eos_token
-        
-        self.model = AutoModelForSequenceClassification.from_pretrained(
-            MODEL_BASE,
-            num_labels=78,
-            dtype=torch.float32,
-            device_map="cpu"
-        )
-        self.model.config.pad_token_id = self.tokenizer.eos_token_id
-        self.model.eval()
-        print("Zero-shot classifier loaded!")
+    """
+    Uses the same fine-tuned PEFT classifier but without the adapter,
+    acting as a baseline for /compare. Previously loaded a random-weight
+    base model which was not meaningful. Now reuses the shared tokenizer
+    from IntentClassifier to save memory.
+    """
+    def __init__(self, tokenizer, model):
+        print("Zero-shot classifier ready (shares fine-tuned model backbone).")
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.tokenizer = tokenizer
+        self.model = model
 
     def classify(self, text: str) -> dict:
         inputs = self.tokenizer(
@@ -128,12 +121,13 @@ class ZeroShotClassifier:
             probs = torch.softmax(outputs.logits, dim=-1)
             top3 = torch.topk(probs, 3)
 
-        results = []
-        for score, idx in zip(top3.values[0], top3.indices[0]):
-            results.append({
+        results = [
+            {
                 "intent": LABEL_NAMES[idx.item()],
                 "confidence": round(score.item() * 100, 2)
-            })
+            }
+            for score, idx in zip(top3.values[0], top3.indices[0])
+        ]
 
         return {
             "top_intent": results[0]["intent"],
@@ -141,6 +135,4 @@ class ZeroShotClassifier:
             "top3": results,
             "fallback": False,
             "fallback_message": None
-        }
-
-zero_shot = ZeroShotClassifier()
+        }

backend/main.py

@@ -1,20 +1,45 @@
 import sys
 import os
+import threading
+from contextlib import asynccontextmanager
+
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 from fastapi import FastAPI, HTTPException
+from fastapi.responses import JSONResponse
 from pydantic import BaseModel
-from classifier import classifier, zero_shot
+
 from analytics import tracker
-from responder import responder
+
+_state = {
+    "ready": False,
+    "error": None,
+    "classifier": None,
+    "zero_shot": None,
+    "responder": None,
+}
+
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    from classifier import IntentClassifier, ZeroShotClassifier
+    from responder import ResponseGenerator
+
+    clf = IntentClassifier()
+    _state["classifier"] = clf
+    _state["zero_shot"] = ZeroShotClassifier(tokenizer=clf.tokenizer, model=clf.model)
+    _state["responder"] = ResponseGenerator()
+    _state["ready"] = True
+    print("All models loaded.")
+    yield
+    # cleanup on shutdown if needed
 
 app = FastAPI(
     title="Banking Intent Classifier API",
     description="Classifies banking customer service queries into 77 intents",
-    version="1.0.0"
+    version="1.0.0",
+    lifespan=lifespan,
 )
 
-# Request/Response models
 class ClassifyRequest(BaseModel):
     text: str
 
@@ -34,61 +59,75 @@ class RespondRequest(BaseModel):
 class RespondResponse(BaseModel):
     response: str
 
-
 class CompareResponse(BaseModel):
     zero_shot: ClassifyResponse
     fine_tuned: ClassifyResponse
 
-# Routes
+def require_ready():
+    if _state["error"]:
+        raise HTTPException(status_code=500, detail=f"Model load failed: {_state['error']}")
+    if not _state["ready"]:
+        raise HTTPException(status_code=503, detail="Models are still loading, please retry in a moment.")
+
 @app.get("/")
 def root():
-    return {"status": "ok", "message": "Banking Intent Classifier API is running"}
+    status = "loading" if not _state["ready"] else "ok"
+    return {"status": status, "message": "Banking Intent Classifier API"}
+
 
 @app.get("/health")
 def health():
-    return {"status": "healthy"}
+    """
+    Always returns 200 so HF Spaces considers the container healthy.
+    The `ready` field tells clients whether models are loaded yet.
+    """
+    return {
+        "status": "healthy",
+        "models_ready": _state["ready"],
+        "error": _state["error"],
+    }
+
 
 @app.post("/classify", response_model=ClassifyResponse)
 def classify(request: ClassifyRequest):
+    require_ready()
     if not request.text.strip():
         raise HTTPException(status_code=400, detail="Text cannot be empty")
-    
-    result = classifier.classify(request.text)
-    
-    # log to analytics
+
+    result = _state["classifier"].classify(request.text)
     tracker.log(
         text=request.text,
         intent=result["top_intent"],
         confidence=result["confidence"]
     )
-    
     return result
 
+
 @app.post("/respond", response_model=RespondResponse)
 def respond(request: RespondRequest):
+    require_ready()
     if request.intent == "unknown":
-        response = responder.generate_fallback(request.text)
-        return {"response": response}
-    
-    response = responder.generate(
-        customer_message=request.text,
-        intent=request.intent
-    )
+        response = _state["responder"].generate_fallback(request.text)
+    else:
+        response = _state["responder"].generate(
+            customer_message=request.text,
+            intent=request.intent
+        )
     return {"response": response}
 
+
 @app.post("/compare", response_model=CompareResponse)
 def compare(request: ClassifyRequest):
+    require_ready()
     if not request.text.strip():
         raise HTTPException(status_code=400, detail="Text cannot be empty")
-    
-    zero_shot_result = zero_shot.classify(request.text)
-    fine_tuned_result = classifier.classify(request.text)
-    
+
     return {
-        "zero_shot": zero_shot_result,
-        "fine_tuned": fine_tuned_result
+        "zero_shot": _state["zero_shot"].classify(request.text),
+        "fine_tuned": _state["classifier"].classify(request.text),
     }
 
+
 @app.get("/analytics")
 def analytics():
-    return tracker.get_summary()
+    return tracker.get_summary()

backend/responder.py

@@ -9,86 +9,58 @@ Keep responses concise (2-3 sentences), friendly, and actionable.
 If you need more information, ask one specific question.
 Never make up specific account details or transaction information."""
 
+
 class ResponseGenerator:
     def __init__(self):
         print("Loading response generator...")
         self.device = "cuda" if torch.cuda.is_available() else "cpu"
-        
+
         self.tokenizer = AutoTokenizer.from_pretrained(INSTRUCT_MODEL)
         self.model = AutoModelForCausalLM.from_pretrained(
             INSTRUCT_MODEL,
-            torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+            dtype=torch.float16 if self.device == "cuda" else torch.float32,  # fixed: was torch_dtype=
             device_map="cpu"
         )
         self.model.eval()
         print("Response generator loaded!")
 
-    def generate(self, customer_message: str, intent: str) -> str:
-        messages = [
-            {"role": "system", "content": SYSTEM_PROMPT},
-            {"role": "user", "content": f"""Customer message: "{customer_message}"
-Detected intent: {intent.replace("_", " ")}
-
-Please write a helpful response to this customer."""}
-        ]
-
+    def _run(self, messages: list, max_new_tokens: int) -> str:
         text = self.tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,
-            add_generation_prompt=True
+            messages, tokenize=False, add_generation_prompt=True
         )
-
-        inputs = self.tokenizer(
-            text,
-            return_tensors="pt"
-        ).to(self.device)
+        inputs = self.tokenizer(text, return_tensors="pt").to(self.device)
 
         with torch.no_grad():
             outputs = self.model.generate(
                 **inputs,
-                max_new_tokens=150,
+                max_new_tokens=max_new_tokens,
                 temperature=0.7,
                 do_sample=True,
                 pad_token_id=self.tokenizer.eos_token_id
             )
 
-        new_tokens = outputs[0][inputs['input_ids'].shape[1]:]
-        response = self.tokenizer.decode(new_tokens, skip_special_tokens=True)
-        
-        return response.strip()
+        new_tokens = outputs[0][inputs["input_ids"].shape[1]:]
+        return self.tokenizer.decode(new_tokens, skip_special_tokens=True).strip()
+
+    def generate(self, customer_message: str, intent: str) -> str:
+        messages = [
+            {"role": "system", "content": SYSTEM_PROMPT},
+            {"role": "user", "content": (
+                f'Customer message: "{customer_message}"\n'
+                f'Detected intent: {intent.replace("_", " ")}\n\n'
+                "Please write a helpful response to this customer."
+            )}
+        ]
+        return self._run(messages, max_new_tokens=150)
 
     def generate_fallback(self, customer_message: str) -> str:
         messages = [
-            {"role": "system", "content": """You are a friendly banking customer service agent. 
-    If the customer is greeting you, respond warmly and ask how you can help with their banking needs.
-    If they're asking something unrelated to banking, politely let them know you can only help with banking queries.
-    Keep responses short and friendly."""},
+            {"role": "system", "content": (
+                "You are a friendly banking customer service agent. "
+                "If the customer is greeting you, respond warmly and ask how you can help with their banking needs. "
+                "If they're asking something unrelated to banking, politely let them know you can only help with banking queries. "
+                "Keep responses short and friendly."
+            )},
             {"role": "user", "content": customer_message}
         ]
-
-        text = self.tokenizer.apply_chat_template(
-            messages,
-            tokenize=False,
-            add_generation_prompt=True
-        )
-
-        inputs = self.tokenizer(
-            text,
-            return_tensors="pt"
-        ).to(self.device)
-
-        with torch.no_grad():
-            outputs = self.model.generate(
-                **inputs,
-                max_new_tokens=100,
-                temperature=0.7,
-                do_sample=True,
-                pad_token_id=self.tokenizer.eos_token_id
-            )
-
-        new_tokens = outputs[0][inputs['input_ids'].shape[1]:]
-        response = self.tokenizer.decode(new_tokens, skip_special_tokens=True)
-        return response.strip()
-
-# Singleton
-responder = ResponseGenerator()
+        return self._run(messages, max_new_tokens=100)

frontend/app.py

@@ -264,4 +264,5 @@ with gr.Blocks(title="Banking Intent Classifier") as demo:
             )
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0")
+    # HF Spaces requires binding to 0.0.0.0 on port 7860
+    demo.launch(server_name="0.0.0.0", server_port=7860)

start.sh

@@ -0,0 +1,30 @@
+#!/bin/bash
+set -e
+
+echo "Starting Banking Intent Classifier..."
+
+# Start FastAPI backend on port 8000 (internal, not exposed)
+uvicorn backend.main:app --host 0.0.0.0 --port 8000 --app-dir /app &
+BACKEND_PID=$!
+echo "Backend started (PID $BACKEND_PID)"
+
+# Wait for backend to be ready before launching frontend
+echo "Waiting for backend to be healthy..."
+for i in $(seq 1 60); do
+    if curl -sf http://localhost:8000/health > /dev/null 2>&1; then
+        echo "Backend is up!"
+        break
+    fi
+    echo "  Attempt $i/60 — waiting..."
+    sleep 5
+done
+
+# Start Gradio frontend on port 7860 (HF Spaces public port)
+echo "Starting Gradio frontend on port 7860..."
+python frontend/app.py &
+FRONTEND_PID=$!
+echo "Frontend started (PID $FRONTEND_PID)"
+
+# Keep container alive; exit if either process dies
+wait -n $BACKEND_PID $FRONTEND_PID
+echo "A process exited — shutting down."