Update app.py

app.py

@@ -1,14 +1,12 @@
 from fastapi import FastAPI, Request, HTTPException
 from fastapi.responses import HTMLResponse
-from fastapi.staticfiles import StaticFiles
 from pydantic import BaseModel
 import tensorflow as tf
 import numpy as np
 import uvicorn
 import os
 import logging
-import pickle
-from typing import Dict, Any
+from typing import Dict, Any, List
 from transformers import AutoTokenizer
 
 # Setup logging
@@ -17,28 +15,26 @@ logger = logging.getLogger(__name__)
 
 # Configuration
 MODEL_PATH = "model.tflite"
-TOKENIZER_PATH = "tokenizer" 
-LABEL_ENCODER_PATH = "label_encoder.pkl"
+TOKENIZER_PATH = "tokenizer"
 MAX_LENGTH = 128
 
 # Inisialisasi FastAPI
 app = FastAPI(
     title="Damkar Classification API (TFLite)",
-    description="API untuk klasifikasi tipe laporan damkar menggunakan TFLite model",
+    description="API untuk klasifikasi tipe laporan damkar menggunakan TFLite model - Raw Output",
     version="1.0.0"
 )
 
 # Global variables
 interpreter = None
 tokenizer = None
-label_encoder = None
 input_details = None
 output_details = None
 
 @app.on_event("startup")
 async def load_model():
     """Load model dan dependencies saat aplikasi startup"""
-    global interpreter, tokenizer, label_encoder, input_details, output_details
+    global interpreter, tokenizer, input_details, output_details
     
     try:
         logger.info("Loading TFLite model...")
@@ -54,62 +50,36 @@ async def load_model():
         input_details = interpreter.get_input_details()
         output_details = interpreter.get_output_details()
         
-        logger.info(f"Model loaded. Input shape: {[detail['shape'] for detail in input_details]}")
+        logger.info(f"Model loaded successfully!")
+        logger.info(f"Input details: {input_details}")
+        logger.info(f"Output details: {output_details}")
         
         # Load tokenizer
         logger.info("Loading tokenizer...")
         if os.path.exists(TOKENIZER_PATH):
             tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_PATH)
         else:
-            # Fallback ke tokenizer online jika tidak ada lokal
             logger.warning("Local tokenizer not found, using online tokenizer")
             tokenizer = AutoTokenizer.from_pretrained("indobenchmark/indobert-base-p1")
         
-        # Load label encoder
-        logger.info("Loading label encoder...")
-        if os.path.exists(LABEL_ENCODER_PATH):
-            with open(LABEL_ENCODER_PATH, 'rb') as f:
-                label_encoder = pickle.load(f)
-        else:
-            # Default labels jika tidak ada label encoder
-            logger.warning("Label encoder not found, using default labels")
-            label_encoder = create_default_label_encoder()
-        
         logger.info("All components loaded successfully!")
         
     except Exception as e:
         logger.error(f"Error loading model: {str(e)}")
         raise e
 
-def create_default_label_encoder():
-    """Create default label encoder jika file tidak ada"""
-    class DefaultLabelEncoder:
-        def __init__(self):
-            # Sesuaikan dengan kategori yang Anda miliki
-            self.classes_ = [
-                "Kebakaran",
-                "Evakuasi/Penyelamatan Hewan", 
-                "Penyelamatan Non Hewan & Bantuan Teknis",
-                "Lain-lain"
-            ]
-        
-        def inverse_transform(self, encoded):
-            return [self.classes_[i] for i in encoded]
-    
-    return DefaultLabelEncoder()
-
 def predict_tflite(text: str) -> Dict[str, Any]:
-    """Fungsi prediksi menggunakan TFLite model"""
-    global interpreter, tokenizer, label_encoder, input_details, output_details
+    """Fungsi prediksi menggunakan TFLite model - mengembalikan raw output"""
+    global interpreter, tokenizer, input_details, output_details
     
-    if not all([interpreter, tokenizer, label_encoder]):
+    if not all([interpreter, tokenizer]):
         raise HTTPException(status_code=503, detail="Model components not loaded")
     
     try:
         # Resize input tensors
-        interpreter.resize_tensor_input(0, [1, MAX_LENGTH])  # attention_mask
-        interpreter.resize_tensor_input(1, [1, MAX_LENGTH])  # input_ids  
-        interpreter.resize_tensor_input(2, [1, MAX_LENGTH])  # token_type_ids
+        interpreter.resize_tensor_input(input_details[0]['index'], [1, MAX_LENGTH])
+        interpreter.resize_tensor_input(input_details[1]['index'], [1, MAX_LENGTH])
+        interpreter.resize_tensor_input(input_details[2]['index'], [1, MAX_LENGTH])
         interpreter.allocate_tensors()
         
         # Tokenize text
@@ -126,7 +96,7 @@ def predict_tflite(text: str) -> Dict[str, Any]:
         token_type_ids = encoded['token_type_ids'].astype(np.int32)
         attention_mask = encoded['attention_mask'].astype(np.int32)
         
-        # Set tensors
+        # Set tensors - gunakan urutan yang benar
         interpreter.set_tensor(input_details[0]['index'], attention_mask)
         interpreter.set_tensor(input_details[1]['index'], input_ids)
         interpreter.set_tensor(input_details[2]['index'], token_type_ids)
@@ -134,20 +104,25 @@ def predict_tflite(text: str) -> Dict[str, Any]:
         # Run inference
         interpreter.invoke()
         
-        # Get output
-        output = interpreter.get_tensor(output_details[0]['index'])
+        # Get raw output
+        raw_output = interpreter.get_tensor(output_details[0]['index'])
+        
+        # Hitung probabilitas dengan softmax
+        probabilities = tf.nn.softmax(raw_output[0]).numpy()
         
-        # Get predictions
-        probabilities = tf.nn.softmax(output[0]).numpy()
-        pred_encoded = np.argmax(output, axis=1)
-        predicted_label = label_encoder.inverse_transform(pred_encoded)[0]
-        confidence = float(np.max(probabilities))
+        # Prediksi kelas (index dengan probabilitas tertinggi)
+        predicted_class_index = int(np.argmax(raw_output, axis=1)[0])
+        max_confidence = float(np.max(probabilities))
         
         return {
-            "label": predicted_label,
-            "confidence": confidence,
-            "probabilities": {
-                label: float(prob) for label, prob in zip(label_encoder.classes_, probabilities)
+            "predicted_class_index": predicted_class_index,
+            "confidence": max_confidence,
+            "raw_output": raw_output[0].tolist(),  # Convert numpy array to list
+            "probabilities": probabilities.tolist(),
+            "input_text": text,
+            "model_info": {
+                "output_shape": raw_output.shape,
+                "num_classes": len(probabilities)
             }
         }
         
@@ -160,9 +135,12 @@ class InputText(BaseModel):
     text: str
 
 class PredictionResponse(BaseModel):
-    label: str
+    predicted_class_index: int
     confidence: float
-    probabilities: Dict[str, float]
+    raw_output: List[float]
+    probabilities: List[float]
+    input_text: str
+    model_info: Dict[str, Any]
     status: str = "success"
 
 # HTML template untuk UI
@@ -170,13 +148,13 @@ HTML_TEMPLATE = """
 <!DOCTYPE html>
 <html>
 <head>
-    <title>Damkar Classification</title>
+    <title>Damkar Classification - Raw Output</title>
     <meta charset="UTF-8">
     <meta name="viewport" content="width=device-width, initial-scale=1.0">
     <style>
         body {
             font-family: 'Segoe UI', Tahoma, Geneva, Verdana, sans-serif;
-            max-width: 800px;
+            max-width: 900px;
             margin: 0 auto;
             padding: 20px;
             background-color: #f5f5f5;
@@ -256,9 +234,10 @@ HTML_TEMPLATE = """
             display: flex;
             justify-content: space-between;
             margin: 5px 0;
-            padding: 5px;
+            padding: 8px;
             background-color: #f8f9fa;
             border-radius: 4px;
+            font-family: monospace;
         }
         .examples {
             margin-top: 20px;
@@ -275,11 +254,29 @@ HTML_TEMPLATE = """
         .example-text:hover {
             color: #0056b3;
         }
+        .raw-output {
+            background-color: #f8f9fa;
+            padding: 10px;
+            border-radius: 4px;
+            font-family: monospace;
+            font-size: 12px;
+            margin: 10px 0;
+            max-height: 200px;
+            overflow-y: auto;
+        }
+        .model-info {
+            background-color: #e7f3ff;
+            padding: 10px;
+            border-radius: 4px;
+            margin: 10px 0;
+            font-size: 14px;
+        }
     </style>
 </head>
 <body>
     <div class="container">
-        <h1>🚒 Klasifikasi Laporan Damkar</h1>
+        <h1>🚒 Damkar Classification - Raw Output</h1>
+        <p style="text-align: center; color: #666;">Menampilkan output mentah dari TFLite model tanpa label encoder</p>
         
         <div class="form-group">
             <label for="textInput">Masukkan teks laporan:</label>
@@ -346,20 +343,33 @@ HTML_TEMPLATE = """
                 if (response.ok) {
                     let resultHTML = `
                         <h3>Hasil Prediksi:</h3>
-                        <p><strong>Kategori:</strong> ${data.label}</p>
+                        <p><strong>Predicted Class Index:</strong> ${data.predicted_class_index}</p>
                         <p><strong>Confidence:</strong> ${(data.confidence * 100).toFixed(2)}%</p>
-                        <h4>Detail Probabilitas:</h4>
+                        
+                        <div class="model-info">
+                            <strong>Model Info:</strong><br>
+                            Output Shape: ${JSON.stringify(data.model_info.output_shape)}<br>
+                            Number of Classes: ${data.model_info.num_classes}
+                        </div>
+                        
+                        <h4>Probabilitas per Class:</h4>
                     `;
                     
-                    for (const [label, prob] of Object.entries(data.probabilities)) {
-                        const percentage = (prob * 100).toFixed(2);
+                    data.probabilities.forEach((prob, index) => {
+                        const percentage = (prob * 100).toFixed(4);
+                        const isMax = index === data.predicted_class_index;
                         resultHTML += `
-                            <div class="prob-item">
-                                <span>${label}</span>
+                            <div class="prob-item" style="${isMax ? 'background-color: #fff3cd; font-weight: bold;' : ''}">
+                                <span>Class ${index}</span>
                                 <span>${percentage}%</span>
                             </div>
                         `;
-                    }
+                    });
+                    
+                    resultHTML += `
+                        <h4>Raw Output (Logits):</h4>
+                        <div class="raw-output">${JSON.stringify(data.raw_output, null, 2)}</div>
+                    `;
                     
                     showResult('success', resultHTML);
                 } else {
@@ -400,17 +410,29 @@ def read_root():
 @app.get("/health")
 def health_check():
     """Health check endpoint"""
-    global interpreter, tokenizer, label_encoder
+    global interpreter, tokenizer
     
-    if not all([interpreter, tokenizer, label_encoder]):
+    if not all([interpreter, tokenizer]):
         return {"status": "unhealthy", "message": "Model components not loaded"}
     
     return {
         "status": "healthy", 
         "message": "TFLite model is ready",
         "model_info": {
-            "input_shapes": [detail['shape'] for detail in input_details],
-            "output_shape": output_details[0]['shape'] if output_details else None,
+            "input_details": [
+                {
+                    "name": detail.get('name', f'input_{i}'),
+                    "shape": detail['shape'].tolist(),
+                    "dtype": str(detail['dtype'])
+                } for i, detail in enumerate(input_details)
+            ],
+            "output_details": [
+                {
+                    "name": detail.get('name', f'output_{i}'),
+                    "shape": detail['shape'].tolist(),
+                    "dtype": str(detail['dtype'])
+                } for i, detail in enumerate(output_details)
+            ],
             "max_length": MAX_LENGTH
         }
     }
@@ -427,11 +449,7 @@ def predict(input: InputText):
         # Lakukan prediksi
         result = predict_tflite(input.text)
         
-        return PredictionResponse(
-            label=result["label"],
-            confidence=result["confidence"],
-            probabilities=result["probabilities"]
-        )
+        return PredictionResponse(**result)
         
     except HTTPException:
         raise
@@ -445,6 +463,7 @@ def test_endpoint():
     return {
         "message": "TFLite API is working!",
         "status": "ok",
+        "version": "raw_output",
         "endpoints": {
             "ui": "/",
             "predict": "/predict",