Upload 10 files

Dockerfile

@@ -0,0 +1,19 @@
+# Use python 3.9 slim image
+FROM python:3.9-slim
+
+# Set working directory
+WORKDIR /code
+
+# Copy requirements first (for caching)
+COPY ./requirements.txt /code/requirements.txt
+
+# Install dependencies
+RUN pip install --no-cache-dir --upgrade -r /code/requirements.txt
+
+# Copy the model directory and code
+# MAKE SURE your model is unzipped in a folder named 'model'
+COPY ./model /code/model
+COPY ./main.py /code/main.py
+
+# Run the app
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,96 @@
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+import torch
+import torch.nn.functional as F
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from lime.lime_text import LimeTextExplainer
+import numpy as np
+import os
+
+app = FastAPI(title="MedGuard API")
+
+# --- NUCLEAR CORS FIX ---
+# Allow EVERYTHING. This rules out CORS as the problem.
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"], 
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- CONFIGURATION ---
+MODEL_PATH = "./model"
+DEVICE = "cpu"
+
+print(f"🔄 Loading Model from {MODEL_PATH}...")
+model = None
+tokenizer = None
+
+try:
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_PATH)
+    model = AutoModelForSequenceClassification.from_pretrained(MODEL_PATH)
+    model.to(DEVICE)
+    model.eval()
+    print("✅ Model Loaded Successfully!")
+except Exception as e:
+    print(f"❌ Error loading local model: {e}")
+    MODEL_NAME = "csebuetnlp/banglabert"
+    tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
+    model = AutoModelForSequenceClassification.from_pretrained(MODEL_NAME, num_labels=3)
+
+# --- DATA MODELS ---
+class QueryRequest(BaseModel):
+    text: str
+
+class PredictionResponse(BaseModel):
+    label: str
+    confidence: float
+    probs: dict
+    explanation: list = None
+
+LABELS = ["Highly Relevant", "Partially Relevant", "Not Relevant"]
+
+def predict_proba_lime(texts):
+    inputs = tokenizer(texts, return_tensors="pt", padding=True, truncation=True, max_length=128).to(DEVICE)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    return torch.nn.functional.softmax(outputs.logits, dim=-1).cpu().numpy()
+
+@app.get("/")
+def health_check():
+    return {"status": "active", "model": "MedGuard v1.0"}
+
+@app.post("/predict", response_model=PredictionResponse)
+def predict(request: QueryRequest):
+    if not model or not tokenizer:
+        raise HTTPException(status_code=503, detail="Model not loaded")
+    
+    try:
+        inputs = tokenizer(request.text, return_tensors="pt", truncation=True, max_length=128).to(DEVICE)
+        with torch.no_grad():
+            outputs = model(**inputs)
+            probs = F.softmax(outputs.logits, dim=-1).cpu().numpy()[0]
+        
+        pred_idx = np.argmax(probs)
+        
+        # LIME (Reduced to 20 samples for speed testing)
+        explainer = LimeTextExplainer(class_names=LABELS, split_expression=lambda x: x.split())
+        exp = explainer.explain_instance(request.text, predict_proba_lime, num_features=6, num_samples=20, labels=[pred_idx])
+        lime_features = exp.as_list(label=pred_idx) 
+        
+        return {
+            "label": LABELS[pred_idx],
+            "confidence": round(float(probs[pred_idx]) * 100, 2),
+            "probs": {l: round(float(p), 4) for l, p in zip(LABELS, probs)},
+            "explanation": lime_features
+        }
+    except Exception as e:
+        print(f"Server Error: {e}") # Print error to backend terminal
+        raise HTTPException(status_code=500, detail=str(e))
+
+if __name__ == "__main__":
+    import uvicorn
+    # Bind to localhost specifically
+    uvicorn.run(app, host="127.0.0.1", port=8000)

model/config.json

@@ -0,0 +1,40 @@
+{
+  "architectures": [
+    "ElectraForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "embedding_size": 768,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_2": 2
+  },
+  "layer_norm_eps": 1e-12,
+  "max_position_embeddings": 512,
+  "model_type": "electra",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "pad_token_id": 0,
+  "position_embedding_type": "absolute",
+  "problem_type": "single_label_classification",
+  "summary_activation": "gelu",
+  "summary_last_dropout": 0.1,
+  "summary_type": "first",
+  "summary_use_proj": true,
+  "transformers_version": "4.57.1",
+  "type_vocab_size": 2,
+  "use_cache": true,
+  "vocab_size": 32000
+}

model/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:8c629f3b73a705b26cccfea07913b6b6660658e6bf97d38e7d445d58d4739925
+size 442502748

model/special_tokens_map.json

@@ -0,0 +1,7 @@
+{
+  "cls_token": "[CLS]",
+  "mask_token": "[MASK]",
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "unk_token": "[UNK]"
+}

model/tokenizer_config.json

@@ -0,0 +1,59 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "1": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "2": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "3": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "4": {
+      "content": "[MASK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    }
+  },
+  "clean_up_tokenization_spaces": true,
+  "cls_token": "[CLS]",
+  "do_basic_tokenize": true,
+  "do_lower_case": false,
+  "extra_special_tokens": {},
+  "full_tokenizer_file": null,
+  "mask_token": "[MASK]",
+  "model_max_length": 1000000000000000019884624838656,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": false,
+  "tokenizer_class": "ElectraTokenizer",
+  "unk_token": "[UNK]"
+}

model/training_args.bin

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:724b5929cc16aead90319cdfae62b336b875ed296fef079a6838ca0e3a355469
+size 5841

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+torch
+transformers
+numpy
+lime
+pydantic
+python-multipart