Update app.py

app.py

@@ -7,14 +7,13 @@ from fastapi import FastAPI
 from pydantic import BaseModel
 from fastapi.middleware.cors import CORSMiddleware
 
-# Optimasi Memory (Wajib untuk HF Free Tier)
+# Optimasi RAM
 os.environ["TF_CPP_MIN_LOG_LEVEL"] = "3"
 os.environ["CUDA_VISIBLE_DEVICES"] = "-1"
 os.environ["TF_NUM_INTEROP_THREADS"] = "1"
 os.environ["TF_NUM_INTRAOP_THREADS"] = "1"
 
 app = FastAPI(title="NER API Service")
-
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -23,36 +22,69 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
-# Global variables untuk Lazy Loading
 ner_model = None
 vocab = None
-
-# Konfigurasi NER
 MAX_SEQ_LEN = 64
 IDX2LABEL = {0: "<PAD>", 1: "O", 2: "B-MERCHANT", 3: "I-MERCHANT", 4: "B-ITEM", 5: "I-ITEM", 6: "B-TOTAL", 7: "I-TOTAL"}
 UNK_TOKEN = "<UNK>"
 NUM_TOKEN = "<NUM>"
 PRICE_TOKEN = "<PRICE>"
 
-# Schema untuk menerima data JSON dari Space A
 class TextRequest(BaseModel):
     text: str
 
+# =========================================================
+# TRIK BYPASS: BANGUN ARSITEKTUR MANUAL BERDASARKAN LOG
+# =========================================================
+def build_manual_model(vocab_size=7929, max_len=64, num_classes=8):
+    # Nama setiap layer disamakan persis dengan log agar weights menempel sempurna
+    inputs = tf.keras.Input(shape=(max_len,), dtype='int32', name='tokens')
+    
+    x = tf.keras.layers.Embedding(input_dim=vocab_size, output_dim=64, mask_zero=True, name='embedding')(inputs)
+    x = tf.keras.layers.SpatialDropout1D(0.3, name='spatial_dropout1d')(x)
+    
+    # BiLSTM 1
+    lstm1_f = tf.keras.layers.LSTM(128, return_sequences=True, dropout=0.4, name='forward_lstm')
+    lstm1_b = tf.keras.layers.LSTM(128, return_sequences=True, go_backwards=True, dropout=0.4, name='backward_lstm')
+    x = tf.keras.layers.Bidirectional(lstm1_f, backward_layer=lstm1_b, name='bilstm_1')(x)
+    
+    # BiLSTM 2
+    lstm2_f = tf.keras.layers.LSTM(64, return_sequences=True, dropout=0.4, name='forward_lstm_1')
+    lstm2_b = tf.keras.layers.LSTM(64, return_sequences=True, go_backwards=True, dropout=0.4, name='backward_lstm_1')
+    x = tf.keras.layers.Bidirectional(lstm2_f, backward_layer=lstm2_b, name='bilstm_2')(x)
+    
+    # TimeDistributed Dense 1
+    dense1 = tf.keras.layers.Dense(64, activation='relu', name='dense')
+    x = tf.keras.layers.TimeDistributed(dense1, name='proj')(x)
+    x = tf.keras.layers.Dropout(0.4, name='dropout')(x)
+    
+    # TimeDistributed Dense 2 (Logits)
+    dense2 = tf.keras.layers.Dense(num_classes, activation='linear', name='dense_1')
+    x = tf.keras.layers.TimeDistributed(dense2, name='logits')(x)
+    
+    # Output Softmax
+    probs = tf.keras.layers.Activation('softmax', name='probabilities')(x)
+    
+    return tf.keras.Model(inputs=inputs, outputs=probs, name='BiLSTM_NER')
+
 def get_ner_model():
     global ner_model, vocab
     if ner_model is None:
-        with open("vocab.pkl", "rb") as f:
+        with open("data/processed/vocab.pkl", "rb") as f:
             vocab = pickle.load(f)
-        # compile=False penting agar tidak error saat mencari custom loss function
-        ner_model = tf.keras.models.load_model("receipt_ner_model.keras", compile=False)
+        
+        # 1. Buat kerangkanya
+        ner_model = build_manual_model()
+        
+        # 2. HANYA isi bobotnya (Ini yang menyelamatkan kita dari error JSON!)
+        ner_model.load_weights("receipt_ner_model.keras")
+        
     return ner_model, vocab
 
 def normalize_token(token: str):
     token = token.strip()
-    if re.fullmatch(r"\d{1,3}([.,]\d{3})*", token):
-        return PRICE_TOKEN
-    if re.fullmatch(r"\d+", token):
-        return NUM_TOKEN
+    if re.fullmatch(r"\d{1,3}([.,]\d{3})*", token): return PRICE_TOKEN
+    if re.fullmatch(r"\d+", token): return NUM_TOKEN
     token = re.sub(r"^[^a-zA-Z0-9']+|[^a-zA-Z0-9']+$", "", token)
     return token.upper() if token else UNK_TOKEN
 
@@ -62,53 +94,46 @@ def predict_ner(request: TextRequest):
         raw_text = request.text
         entities = {"MERCHANT": [], "ITEM": [], "TOTAL": []}
         
-        # Jika teks kosong, langsung kembalikan entitas kosong
         if not raw_text.strip():
             return {"success": True, "entities": entities}
 
         model, vcb = get_ner_model()
         
-        # Tokenisasi sederhana
         tokens = [t for line in raw_text.split("\n") for t in line.strip().split() if t]
         if not tokens:
             return {"success": True, "entities": entities}
 
-        # Encoding
         norm_tokens = [normalize_token(t) for t in tokens]
-        X = np.zeros((1, MAX_SEQ_LEN), dtype=np.int32)
-        mask = np.zeros((1, MAX_SEQ_LEN), dtype=np.float32)
         
+        # Hanya butuh array X, mask dihapus karena sudah otomatis ditangani layer Embedding
+        X = np.zeros((1, MAX_SEQ_LEN), dtype=np.int32)
         length = min(len(norm_tokens), MAX_SEQ_LEN)
+        
         for i in range(length):
             X[0, i] = vcb.get(norm_tokens[i], vcb.get(UNK_TOKEN, 0))
-            mask[0, i] = 1.0
             
-        # Prediksi menggunakan TensorFlow
-        probs = model([X, mask], training=False).numpy()
+        # Inference super cepat
+        probs = model(X, training=False).numpy()
         labels = [IDX2LABEL[int(np.argmax(probs[0, i]))] for i in range(length)]
         
-        # Ekstraksi IOB (Inside-Outside-Beginning)
         current_type = None
         span = []
         for tok, lbl in zip(tokens[:length], labels):
             if lbl.startswith("B-"):
-                if current_type: 
-                    entities[current_type].append(" ".join(span))
+                if current_type: entities[current_type].append(" ".join(span))
                 current_type = lbl[2:]
                 span = [tok]
             elif lbl.startswith("I-") and current_type == lbl[2:]:
                 span.append(tok)
             else:
-                if current_type: 
-                    entities[current_type].append(" ".join(span))
+                if current_type: entities[current_type].append(" ".join(span))
                 current_type = None
                 span = []
-        if current_type: 
-            entities[current_type].append(" ".join(span))
+        if current_type: entities[current_type].append(" ".join(span))
 
         return {"success": True, "entities": entities}
         
     except Exception as e:
-        print(f"Error NER: {e}")
-        # Jika terjadi error internal, kembalikan objek kosong agar Space A tidak crash
+        import traceback
+        print(f"Error NER detail: {traceback.format_exc()}")
         return {"success": False, "error": str(e), "entities": {"MERCHANT": [], "ITEM": [], "TOTAL": []}}