Upload 6 files

BERT_MODEL.pth

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:47318e40a47b689c5d0cc90d41b345a4e3b0f15a2a4a01fd7916763fc5873e52
+size 266456825

TOKENIZER/special_tokens_map.json

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

TOKENIZER/tokenizer_config.json

@@ -0,0 +1,58 @@
+{
+  "added_tokens_decoder": {
+    "0": {
+      "content": "[PAD]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "100": {
+      "content": "[UNK]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "101": {
+      "content": "[CLS]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "102": {
+      "content": "[SEP]",
+      "lstrip": false,
+      "normalized": false,
+      "rstrip": false,
+      "single_word": false,
+      "special": true
+    },
+    "103": {
+      "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": true,
+  "extra_special_tokens": {},
+  "mask_token": "[MASK]",
+  "model_max_length": 512,
+  "never_split": null,
+  "pad_token": "[PAD]",
+  "sep_token": "[SEP]",
+  "strip_accents": null,
+  "tokenize_chinese_chars": true,
+  "tokenizer_class": "DistilBertTokenizer",
+  "unk_token": "[UNK]"
+}

app.py

@@ -0,0 +1,107 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from typing import Literal
+import torch
+import torch.nn.functional as F
+from transformers import DistilBertTokenizer, DistilBertModel
+import logging
+import time
+
+logging.getLogger("transformers").setLevel(logging.ERROR)
+
+# ----------------------------
+# Model Definition
+# ----------------------------
+class SentimentClassifier(torch.nn.Module):
+    def __init__(self):
+        super().__init__()
+        self.bert = DistilBertModel.from_pretrained("distilbert-base-uncased")
+        for param in self.bert.parameters():
+            param.requires_grad = False
+        self.classifier = torch.nn.Sequential(
+            torch.nn.Linear(768, 256),
+            torch.nn.BatchNorm1d(256),
+            torch.nn.ReLU(),
+            torch.nn.Dropout(0.3),
+            torch.nn.Linear(256, 128),
+            torch.nn.BatchNorm1d(128),
+            torch.nn.ReLU(),
+            torch.nn.Dropout(0.3),
+            torch.nn.Linear(128, 64),
+            torch.nn.BatchNorm1d(64),
+            torch.nn.ReLU(),
+            torch.nn.Dropout(0.3),
+            torch.nn.Linear(64, 3)
+        )
+
+    def forward(self, input_ids, attention_mask):
+        sentence_embeddings = self.bert(input_ids=input_ids, attention_mask=attention_mask).last_hidden_state[:, 0, :]
+        return self.classifier(sentence_embeddings)
+
+
+app = FastAPI(title="TwittoBERT API", version="1.0")
+
+model = None
+tokenizer = None
+
+
+
+@app.on_event("startup")
+def load_model_and_tokenizer():
+    global model, tokenizer
+    print("Loading model and tokenizer...")
+    start = time.time()
+    model = SentimentClassifier()
+    model.load_state_dict(torch.load("BERT_MODEL.pth", map_location=torch.device("cpu")))
+    model.eval()
+    tokenizer = DistilBertTokenizer.from_pretrained("distilbert-base-uncased")
+    print(f"✅ Model loaded in {time.time() - start:.2f}s")
+
+
+class PredictionRequest(BaseModel):
+    text: str
+
+class PredictionResponse(BaseModel):
+    sentiment: Literal["Negative", "Neutral", "Positive"]
+    confidence: float  # 0.0 to 100.0
+
+class StatusResponse(BaseModel):
+    status: str
+    model_loaded: bool
+
+# ----------------------------
+# Endpoints
+# ----------------------------
+@app.get("/status", response_model=StatusResponse)
+async def status():
+    return {
+        "status": "healthy",
+        "model_loaded": model is not None and tokenizer is not None
+    }
+
+@app.post("/predict", response_model=PredictionResponse)
+async def predict(request: PredictionRequest):
+    if not request.text.strip():
+        raise HTTPException(status_code=400, detail="Text cannot be empty")
+    
+    try:
+        inputs = tokenizer(
+            request.text,
+            padding="max_length",
+            max_length=250, 
+            truncation=True,
+            return_tensors="pt"
+        )
+
+        with torch.no_grad():
+            logits = model(**inputs)
+            probs = F.softmax(logits, dim=1)
+            confidence, pred_class = torch.max(probs, dim=1)
+
+        label = ["Negative", "Neutral", "Positive"][pred_class.item()]
+        confidence_score = round(confidence.item() * 100, 2)
+
+        return {"sentiment": label, "confidence": confidence_score}
+
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Prediction error: {str(e)}")

requirements.txt

@@ -0,0 +1,8 @@
+pillow
+torch
+torchvi
+transformers
+functools
+huggingface_hub
+fastapi
+uvicorn