apaya

app.py

@@ -1,15 +1,17 @@
+# app.py
 import gradio as gr
 from inference import predict, predict_batch
 
-# Tema dan tata letak diatur di sini
 with gr.Blocks(theme=gr.themes.Soft(), css=None, analytics_enabled=False) as iface:
     gr.Markdown(
         """
-        # 🤖 Deteksi Bentuk Wajah (Indonesia)
-        Unggah foto wajah Anda untuk mengetahui bentuknya. Model ini dilatih menggunakan arsitektur EfficientNetB2.
-        Untuk hasil terbaik, gunakan foto di mana wajah terlihat jelas menghadap ke depan.
+            # Deteksi Bentuk Wajah
+            
+            Model **EfficientNetB4** (5 kelas: Heart, Oblong, Oval, Round, Square) yang dimuat dari `models/model.keras`.
+            Gunakan foto wajah frontal untuk hasil terbaik.
         """
     )
+
     with gr.Row():
         with gr.Column(scale=1):
             image_input = gr.Image(type="pil", label="Unggah Gambar Wajah")
@@ -17,27 +19,14 @@ with gr.Blocks(theme=gr.themes.Soft(), css=None, analytics_enabled=False) as ifa
         with gr.Column(scale=1):
             label_output = gr.Label(num_top_classes=3, label="Hasil Prediksi")
 
-    # Bagian untuk menampilkan contoh gambar (opsional)
-    gr.Examples(
-        examples=[
-        ],
-        inputs=image_input,
-        outputs=label_output,
-        fn=predict,
-        cache_examples=True
-    )
-    
-    # Hubungkan tombol "Prediksi" dengan fungsi predict yang sudah diimpor
+    gr.Examples(examples=[], inputs=image_input, outputs=label_output, fn=predict, cache_examples=True)
     submit_btn.click(fn=predict, inputs=image_input, outputs=label_output)
 
-    # Endpoint batch (opsional) untuk klien JSON; menjaga compat endpoint default tetap single
     with gr.Accordion("Batch (opsional)", open=False):
         files_in = gr.Files(file_count="multiple", file_types=["image"], label="Unggah beberapa gambar")
         json_out = gr.JSON(label="Best of batch (JSON)")
         batch_btn = gr.Button("Prediksi Batch")
         batch_btn.click(fn=predict_batch, inputs=files_in, outputs=json_out, api_name="predict_batch")
 
-# Luncurkan aplikasi jika file ini dijalankan secara langsung
 if __name__ == "__main__":
     iface.launch()
-

inference.py

@@ -1,145 +1,132 @@
+# inference.py
+import os, json, time
+from typing import List, Dict, Tuple, Any
 import numpy as np
 from PIL import Image
 import tensorflow as tf
-from typing import List, Dict, Tuple, Any
-import time
-import os
-
-# --- 1. Konfigurasi Model ---
-LABELS: List[str] = ["Heart", "Oblong", "Oval", "Round", "Square"]
-IMG_SIZE = 244
-
-# --- 2. Fungsi Preprocessing (Tidak Berubah) ---
-def preprocess_image(image: Image.Image) -> np.ndarray:
-    if image.mode != "RGB":
-        image = image.convert("RGB")
-    image = image.resize((IMG_SIZE, IMG_SIZE))
-    image_array = np.asarray(image)
-    image_array = np.expand_dims(image_array, axis=0)
-    processed_array = tf.keras.applications.efficientnet.preprocess_input(image_array)
-    return processed_array
 
-# --- 3. Kelas untuk Mengelola Model (Logika Baru) ---
+# ---------- Label handling ----------
+_DEFAULT_LABELS = ["Heart","Oblong","Oval","Round","Square"]
+
+def _load_labels() -> List[str]:
+    p_ci  = os.path.join("models", "class_indices.json")
+    p_i2c = os.path.join("models", "idx2class.json")
+    # Prioritas: class_indices.json
+    try:
+        with open(p_ci, "r") as f:
+            d = json.load(f)  # {"Label": idx, ...}
+        items = sorted(d.items(), key=lambda kv: kv[1])
+        labels = [k for k,_ in items]
+        print(f"[LABEL] from class_indices.json -> {labels}")
+        return labels
+    except Exception:
+        pass
+    # Fallback: idx2class.json
+    try:
+        with open(p_i2c, "r") as f:
+            d = json.load(f)  # {"0":"Label",...}
+        items = sorted(((int(k),v) for k,v in d.items()), key=lambda kv: kv[0])
+        labels = [v for _,v in items]
+        print(f"[LABEL] from idx2class.json -> {labels}")
+        return labels
+    except Exception:
+        print(f"[LABEL] fallback default -> {_DEFAULT_LABELS}")
+        return _DEFAULT_LABELS
+
+LABELS: List[str] = _load_labels()
+
+# ---------- Model loader ----------
 class FaceShapeModel:
-    def __init__(self, model_path: str = "models/model.keras") -> None:
-        """
-        Membangun arsitektur model secara manual dan memuat bobotnya.
-        Ini adalah solusi untuk masalah inkompatibilitas internal model.
-        """
-        print("Memulai proses pemuatan model dengan arsitektur baru...")
+    def __init__(self, model_path: str = os.path.join("models","model.keras")) -> None:
+        self.model = None
+        self.img_size = 224
+        self.external_rescale = False
+
+        full_path = os.path.join(os.getcwd(), model_path)
+        print(f"[LOAD] {full_path}")
+        self.model = tf.keras.models.load_model(full_path, compile=False)
+
+        # Ambil ukuran input dari model (None, H, W, 3)
+        ishape = self.model.input_shape
+        if isinstance(ishape, (list, tuple)):
+            h = ishape[1] if len(ishape) > 1 else None
+            if isinstance(h, int) and h > 0:
+                self.img_size = h
+        print(f"[MODEL] input img_size = {self.img_size}")
+
+        # Deteksi preprocessing internal (rescaling/normalization)
+        first_names = [l.name.lower() for l in self.model.layers[:8]]
+        has_internal_pp = any(("rescaling" in n) or ("normalization" in n) for n in first_names)
+        self.external_rescale = not has_internal_pp
+        print(f"[MODEL] internal_preproc={has_internal_pp} -> external_rescale={self.external_rescale}")
+
+        # Warm-up (optional)
         try:
-
-            inputs = tf.keras.layers.Input(shape=(IMG_SIZE, IMG_SIZE, 3))
-            base_model = tf.keras.applications.EfficientNetB2(
-                weights=None, 
-                include_top=False,
-                pooling='avg',
-                input_tensor=inputs
-            )
-            x = tf.keras.layers.Dropout(0.4)(base_model.output)
-            outputs = tf.keras.layers.Dense(len(LABELS), activation='softmax')(x)
-            
-            rebuilt_model = tf.keras.Model(inputs=inputs, outputs=outputs)
-            print("Arsitektur model baru berhasil dibuat.")
-
-            # 2. Muat HANYA bobotnya ke dalam arsitektur yang sudah benar
-            full_path = os.path.join(os.getcwd(), model_path)
-            print(f"Mencoba memuat bobot dari: {full_path}")
-            rebuilt_model.load_weights(full_path)
-            
-            self.model = rebuilt_model
-            print("Model berhasil dibangun ulang dan bobot telah dimuat.")
-
-            # Warm-up: satu inference dummy agar jalur model siap (mengurangi cold-start)
-            try:
-                _ = self.model(tf.zeros((1, IMG_SIZE, IMG_SIZE, 3)))
-                print("Warm-up inference completed.")
-            except Exception as werr:
-                print(f"Warm-up failed (non-fatal): {werr}")
-
+            _ = self.model(tf.zeros((1, self.img_size, self.img_size, 3), dtype=tf.float32))
         except Exception as e:
-            print(f"Error saat memuat model di inference.py: {e}")
-            self.model = None
+            print("[WARN] warmup failed:", e)
+
+    def _preprocess(self, image: Image.Image) -> np.ndarray:
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        image = image.resize((self.img_size, self.img_size))
+        x = np.asarray(image, dtype=np.float32)  # [0..255]
+        if self.external_rescale:
+            x = x / 255.0
+        return np.expand_dims(x, axis=0)
 
     def predict_image(self, image: Image.Image) -> Dict[str, float]:
-        """Melakukan prediksi pada satu gambar."""
-        if not self.model:
-            return {"Error": "Model tidak dapat dimuat."}
+        if self.model is None:
+            return {"Error": "Model tidak dimuat."}
         if image is None:
-            return {"Error": "Gambar tidak tersedia."}
-
+            return {"Error": "Gambar kosong."}
         t0 = time.perf_counter()
-        processed_input = preprocess_image(image)
-        preds = self.model.predict(processed_input, verbose=0)[0]
-        confidences: Dict[str, float] = {label: float(score) for label, score in zip(LABELS, preds)}
-        # Logging ringan
-        dt = (time.perf_counter() - t0) * 1000
-        print(f"predict_image: took {dt:.1f} ms")
-        return confidences
+        xin = self._preprocess(image)
+        probs = self.model.predict(xin, verbose=0)[0]  # (C,)
+        out = {lbl: float(p) for lbl, p in zip(LABELS, probs)}
+        print(f"[INF] {len(LABELS)}-class in {(time.perf_counter()-t0)*1000:.1f} ms")
+        return out
 
-# Buat instance dari model kita
-model_instance = FaceShapeModel()
+# singleton
+_model = FaceShapeModel()
 
+# gradio APIs
 def predict(image_pil: Image.Image) -> Dict[str, float]:
-    """Fungsi wrapper yang akan dipanggil oleh Gradio."""
-    if model_instance:
-        return model_instance.predict_image(image_pil)
+    if _model and _model.model is not None:
+        return _model.predict_image(image_pil)
     return {"Error": "Instance model tidak tersedia."}
 
-
-# --- Batch prediction opsional ---
+# (opsional) batch
 def _dict_to_payload(d: Dict[str, float]) -> Dict[str, object]:
-    # Konversi dict label->score menjadi payload {label, confidences:[{label,confidence}]}
-    if not d or any(k == "Error" for k in d.keys()):
+    if not d or any(k == "Error" for k in d):
         return {"label": "", "confidences": []}
-    items: List[Tuple[str, float]] = sorted(d.items(), key=lambda kv: kv[1], reverse=True)
-    top = items[0][0] if items else ""
-    confs = [{"label": k, "confidence": float(v)} for k, v in items]
-    return {"label": top, "confidences": confs}
-
+    items = sorted(d.items(), key=lambda kv: kv[1], reverse=True)
+    return {"label": items[0][0], "confidences": [{"label": k, "confidence": float(v)} for k,v in items]}
 
 def _to_pil_list(files: List[Any]) -> List[Image.Image]:
-    out: List[Image.Image] = []
-    for f in files:
+    out = []
+    for f in files or []:
         try:
             if isinstance(f, Image.Image):
-                out.append(f)
-                continue
-            # Gradio >=4: FileData with .path
-            path = None
-            if hasattr(f, "path") and isinstance(getattr(f, "path"), str):
-                path = getattr(f, "path")
-            elif isinstance(f, str):
-                path = f
-            elif hasattr(f, "name") and isinstance(getattr(f, "name"), str):
-                path = getattr(f, "name")
+                out.append(f); continue
+            path = getattr(f, "path", None) or getattr(f, "name", None) or (f if isinstance(f,str) else None)
             if path:
-                img = Image.open(path).convert("RGB")
-                out.append(img)
+                out.append(Image.open(path).convert("RGB"))
         except Exception:
             continue
     return out
 
-
 def predict_batch(files: List[Any]) -> Dict[str, object]:
-    """Prediksi batch: menerima FileData/paths atau PIL.Image; pilih hasil terbaik."""
-    if not model_instance:
+    if not _model or _model.model is None:
         return {"error": "Instance model tidak tersedia."}
-    if not files:
-        return {"error": "Tidak ada gambar."}
-
-    images = _to_pil_list(files)
-    if not images:
-        return {"error": "Tidak dapat membaca gambar."}
-
-    best_payload: Dict[str, object] = {"label": "", "confidences": []}
-    best_conf = -1.0
-    for img in images:
-        d = model_instance.predict_image(img)
-        payload = _dict_to_payload(d)
-        conf = float(payload.get("confidences", [{"confidence": 0.0}])[0]["confidence"]) if payload.get("confidences") else 0.0
-        if conf > best_conf:
-            best_conf = conf
-            best_payload = payload
-    return best_payload
-
+    imgs = _to_pil_list(files)
+    if not imgs:
+        return {"error": "Tidak ada gambar valid."}
+    best, bestc = {"label":"", "confidences":[]}, -1.0
+    for img in imgs:
+        d = _model.predict_image(img)
+        p = _dict_to_payload(d)
+        c = float(p["confidences"][0]["confidence"]) if p["confidences"] else 0.0
+        if c > bestc:
+            best, bestc = p, c
+    return best