Initial commit: Dockerized low-latency SVM classifier with FastAPI and Gradio UI.

Dockerfile

@@ -0,0 +1,15 @@
+FROM python:3.9-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY app.py .
+
+COPY checkpoint/ checkpoint/
+
+ENV PORT 7860
+EXPOSE 7860
+
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

READMe.md

@@ -0,0 +1,61 @@
+---
+title: STOP
+sdk: docker
+app_port: 7860
+colorFrom: red
+colorTo: indigo
+description: Low-latency STOP/NOT_STOP text classification using Linear SVM deployed with FastAPI and Docker.
+---
+
+# STOP Classifier API
+
+This Hugging Face Space hosts a low-latency text classification service deployed with Docker and FastAPI.
+
+The service uses a highly efficient Linear Support Vector Machine (SVM) model trained on text features extracted via TF-IDF to classify messages as either intending to end communication (`STOP`) or not (`NOT_STOP`). As confirmed by the training script, the SVM model provides millisecond-level inference, which is ideal for the required low-latency API.
+
+## Project Structure
+
+The deployment uses the following structure:
+
+```
+.
+├── app.py           
+├── Dockerfile       
+├── requirements.txt 
+├── README.md        
+└── checkpoint/
+    ├── tfidf_vectorizer.pkl
+    └── svm_stop_classifier.pkl
+```
+
+## API Endpoints
+
+The FastAPI application provides two primary endpoints for prediction:
+
+### 1. Health Check (GET)
+
+* **Path:** `/`
+* **Method:** `GET`
+* **Description:** A simple endpoint to confirm the service is running and the models are loaded.
+
+### 2. Single Prediction (GET)
+
+* **Path:** `/predict?text=<your_text>`
+* **Method:** `GET`
+* **Description:** Classifies a single text string passed as a query parameter. This is suitable for quick, individual queries.
+* **Example Query:** `/predict?text=please%20discontinue%20all%20contact`
+
+### 3. Batch Prediction (POST)
+
+* **Path:** `/predict`
+* **Method:** `POST`
+* **Description:** Classifies a list of text strings in a single request. This is the recommended approach for high-throughput, low-latency production use cases due to reduced overhead.
+* **Request Body (JSON):**
+
+    ```json
+    {
+      "texts": [
+        "do not ever text me again",
+        "I will stop by your office tomorrow"
+      ]
+    }

app.py

@@ -0,0 +1,128 @@
+import os
+import joblib
+import gradio as gr
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+from typing import List
+
+CHECKPOINT_DIR = "checkpoint"
+TFIDF_PATH = os.path.join(CHECKPOINT_DIR, "tfidf_vectorizer.pkl")
+SVM_PATH = os.path.join(CHECKPOINT_DIR, "svm_stop_classifier.pkl")
+
+LABEL_0 = "NOT_STOP"
+LABEL_1 = "STOP"
+
+tfidf_vectorizer = None
+svm_model = None
+
+try:
+    print(f"Loading TFIDF Vectorizer from {TFIDF_PATH}...")
+    tfidf_vectorizer = joblib.load(TFIDF_PATH)
+    print(f"Loading SVM Model from {SVM_PATH}...")
+    svm_model = joblib.load(SVM_PATH)
+    print("Models loaded successfully.")
+except FileNotFoundError as e:
+    print(f"ERROR: Model file not found: {e}")
+    raise RuntimeError(f"Failed to load required model files. Ensure 'checkpoint/' is correctly populated. Error: {e}")
+
+app = FastAPI(
+    title="STOP Classifier API",
+    description="STOP/NOT_STOP text classification using Linear SVM. The main UI is at the root '/', while the API endpoints are at '/api-docs' and '/predict'.",
+    version="1.0.0"
+)
+
+class PredictionRequest(BaseModel):
+    texts: List[str] = Field(
+        ...,
+        description="A list of text strings to classify.",
+        example=[
+            "please discontinue all communication",
+            "I will stop by the station after lunch"
+        ]
+    )
+
+class PredictionResponse(BaseModel):
+    text: str = Field(..., description="The input text.")
+    prediction: str = Field(..., description="The predicted label (STOP or NOT_STOP).")
+    probability_NOT_STOP: float = Field(..., description="Probability of NOT_STOP label.")
+    probability_STOP: float = Field(..., description="Probability of STOP label.")
+    inference_model: str = Field("SVM", description="The model used for inference.")
+
+def predict_svm(texts: List[str]) -> List[PredictionResponse]:
+    if not texts:
+        return []
+        
+    vec = tfidf_vectorizer.transform(texts)
+    probs = svm_model.predict_proba(vec)
+    preds = svm_model.predict(vec)
+
+    results = []
+    for i, txt in enumerate(texts):
+        pred_label = LABEL_1 if preds[i] == 1 else LABEL_0
+        results.append(PredictionResponse(
+            text=txt,
+            prediction=pred_label,
+            probability_NOT_STOP=float(probs[i][0]),
+            probability_STOP=float(probs[i][1]),
+            inference_model="SVM"
+        ))
+    
+    return results
+
+@app.get("/health", status_code=200, tags=["API"])
+def health_check():
+    return {"status": "ok", "model_loaded": bool(svm_model)}
+
+@app.post("/predict", response_model=List[PredictionResponse], tags=["API"])
+async def post_predict(request: PredictionRequest):
+    try:
+        results = predict_svm(request.texts)
+        return results
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal Server Error during POST prediction: {e}")
+
+@app.get("/predict", response_model=PredictionResponse, tags=["API"])
+async def get_predict(text: str):
+    if not text.strip():
+        raise HTTPException(status_code=400, detail="Text query parameter cannot be empty.")
+        
+    try:
+        results = predict_svm([text])
+        if not results:
+            raise HTTPException(status_code=500, detail="Prediction returned empty result.")
+        
+        return results[0]
+        
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Internal Server Error during GET prediction: {e}")
+
+def gradio_interface_fn(text_input):
+    if not text_input or not text_input.strip():
+        return "Please enter text for classification.", None
+        
+    try:
+        result = predict_svm([text_input])[0]
+        prediction_label = result.prediction
+        
+        prob_display = {
+            result.prediction: result.probability_STOP if result.prediction == LABEL_1 else result.probability_NOT_STOP,
+            LABEL_1 if result.prediction == LABEL_0 else LABEL_0: result.probability_STOP if result.prediction == LABEL_0 else result.probability_NOT_STOP
+        }
+        
+        return prediction_label, prob_display
+        
+    except Exception as e:
+        return f"An error occurred: {str(e)}", None
+
+ui = gr.Interface(
+    fn=gradio_interface_fn,
+    inputs=gr.Textbox(lines=2, placeholder="Enter a message to classify...", label="Input Text"),
+    outputs=[
+        gr.Label(label="Classification Result"), 
+        gr.Label(label="Probabilities")
+    ],
+    title="STOP Classifier (Low-Latency SVM)",
+    description="This is the user interface for the SVM model. The model classifies text as intended to end communication (STOP) or not (NOT_STOP). The API is available at the '/predict' endpoints."
+)
+
+app = gr.mount_app(app, ui, path="/")

requirements.txt

@@ -0,0 +1,5 @@
+fastapi
+uvicorn[standard]
+scikit-learn
+joblib
+pydantic