Upload 4 files

app.py

@@ -1,54 +1,32 @@
-import json
 import os
-import re
 from contextlib import asynccontextmanager
 
-
 from fastapi import FastAPI, HTTPException, Request
 from pydantic import BaseModel
+from transformers import pipeline
 
-MODEL_NAME = "Qwen/Qwen3.5-9B:together"
+MODEL_NAME = "ayameRushia/bert-base-indonesian-1.5G-sentiment-analysis-smsa"
 API_KEY = os.getenv("API_KEY")
-HF_TOKEN = os.getenv("HF_TOKEN")
 
-# Will hold either InferenceClient or local model+tokenizer
-inference_client = None
-local_model = None
-local_tokenizer = None
+# Label mapping — IndoNLU SMSA: positive/neutral/negative
+LABEL_MAP = {
+    "positive": "positive",
+    "neutral": "neutral",
+    "negative": "negative",
+    "label_0": "positive",
+    "label_1": "neutral",
+    "label_2": "negative",
+}
+
+classifier = None
 
 
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    global inference_client, local_model, local_tokenizer
-
-    if HF_TOKEN:
-        # Option 1: HF Inference API (GPU-backed, fast)
-        print("HF_TOKEN found — using HF Inference API")
-        from huggingface_hub import InferenceClient
-        inference_client = InferenceClient(
-            api_key=HF_TOKEN,
-        )
-        print("Inference client ready.")
-    else:
-        # Option 2: Local model with INT8 quantization (CPU fallback)
-        print("No HF_TOKEN — loading model locally with INT8 quantization")
-        import torch
-        from transformers import AutoModelForCausalLM, AutoTokenizer
-        import torch.quantization
-
-        local_tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-        model = AutoModelForCausalLM.from_pretrained(
-            MODEL_NAME,
-            torch_dtype=torch.float32,
-            device_map="cpu",
-        )
-        # Apply dynamic INT8 quantization for faster CPU inference
-        local_model = torch.quantization.quantize_dynamic(
-            model, {torch.nn.Linear}, dtype=torch.qint8
-        )
-        local_model.eval()
-        print("Local INT8 model ready.")
-
+    global classifier
+    print(f"Loading model: {MODEL_NAME}")
+    classifier = pipeline("text-classification", model=MODEL_NAME)
+    print("Model loaded.")
     yield
 
 
@@ -59,72 +37,6 @@ class PredictRequest(BaseModel):
     texts: list[str]
 
 
-SYSTEM_PROMPT = "Indonesian stock news sentiment analyzer. Return ONLY a JSON array of [sentiment, score] pairs where sentiment is positive/negative/neutral and score is 0.0-1.0. No markdown, no explanation."
-
-
-def build_prompt(texts: list[str]) -> str:
-    headlines = "\n".join(f"{i+1}. {t}" for i, t in enumerate(texts))
-    return f"{headlines}\n/no_think"
-
-
-def parse_response(raw: str, texts: list[str]) -> list[dict]:
-    raw = re.sub(r"<think>.*?</think>", "", raw, flags=re.DOTALL).strip()
-    match = re.search(r"\[.*\]", raw, re.DOTALL)
-    if match:
-        try:
-            parsed = json.loads(match.group())
-            # Index-based: [[sentiment, score], ...]
-            if isinstance(parsed, list) and len(parsed) == len(texts):
-                if isinstance(parsed[0], list):
-                    return [
-                        {"text": texts[i], "sentiment": parsed[i][0], "score": parsed[i][1]}
-                        for i in range(len(texts))
-                    ]
-                # Fallback: old object format still works
-                return parsed
-        except (json.JSONDecodeError, IndexError, KeyError):
-            pass
-    return [{"text": t, "sentiment": "neutral", "score": 0.5} for t in texts]
-
-
-def run_hf_api(texts: list[str]) -> str:
-    messages = [
-        {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user", "content": build_prompt(texts)},
-    ]
-    response = inference_client.chat.completions.create(
-        model=MODEL_NAME,
-        messages=messages,
-        max_tokens=256,
-        temperature=0.1,
-    )
-    return response.choices[0].message.content or ""
-
-
-def run_local(texts: list[str]) -> str:
-    import torch
-    messages = [
-        {"role": "system", "content": SYSTEM_PROMPT},
-        {"role": "user", "content": build_prompt(texts)},
-    ]
-    text_input = local_tokenizer.apply_chat_template(
-        messages,
-        tokenize=False,
-        add_generation_prompt=True,
-        enable_thinking=False,
-    )
-    inputs = local_tokenizer(text_input, return_tensors="pt")
-    with torch.no_grad():
-        outputs = local_model.generate(
-            **inputs,
-            max_new_tokens=256,
-            do_sample=False,
-            pad_token_id=local_tokenizer.eos_token_id,
-        )
-    generated = outputs[0][inputs["input_ids"].shape[1]:]
-    return local_tokenizer.decode(generated, skip_special_tokens=True)
-
-
 @app.post("/predict")
 async def predict(body: PredictRequest, request: Request):
     if API_KEY:
@@ -138,27 +50,23 @@ async def predict(body: PredictRequest, request: Request):
     if len(texts) > 20:
         raise HTTPException(status_code=400, detail="Maximum 20 texts per request")
 
-    if inference_client is None and local_model is None:
+    if classifier is None:
         raise HTTPException(status_code=503, detail="Model not loaded yet")
 
-    raw = run_hf_api(texts) if inference_client else run_local(texts)
-    results = parse_response(raw, texts)
-
-    normalized = []
-    for r in results:
-        sentiment = str(r.get("sentiment", "neutral")).lower()
-        if sentiment not in ("positive", "negative", "neutral"):
-            sentiment = "neutral"
-        normalized.append({
-            "text": r.get("text", ""),
-            "sentiment": sentiment,
-            "score": round(float(r.get("score", 0.5)), 4),
+    predictions = classifier(texts, truncation=True, max_length=512)
+
+    results = []
+    for text, pred in zip(texts, predictions):
+        label = LABEL_MAP.get(pred["label"].lower(), "neutral")
+        results.append({
+            "text": text,
+            "sentiment": label,
+            "score": round(pred["score"], 4),
         })
 
-    return {"results": normalized, "_raw": raw}
+    return {"results": results}
 
 
 @app.get("/health")
 def health():
-    mode = "hf_api" if inference_client else "local_int8" if local_model else "not_loaded"
-    return {"status": "ok", "mode": mode}
+    return {"status": "ok", "model_loaded": classifier is not None}

requirements.txt

@@ -1,5 +1,4 @@
 fastapi==0.115.5
 uvicorn[standard]==0.32.1
-transformers
-accelerate>=0.26.0
-huggingface_hub
+transformers>=4.51.0
+torch==2.5.1