fix import

app.py

@@ -1,45 +1,34 @@
-def predict(image: Image.Image) -> Dict[str, float]:
-    """Prediksi satu gambar. Return dict label->prob."""
-    if image is None:
-        return {"Error": "No image"}
-    return _MODEL.predict_dict(image)
+# app.py
+import os
+import gradio as gr
+from inference import predict, predict_batch  # <-- gunakan fungsi dari inference.py
 
+def _payload(d):
+    # ubah dict {label: prob} -> payload gradio.Label
+    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 predict_batch(images: Iterable[Any]) -> List[Dict[str, float]]:
-    """
-    Prediksi banyak gambar. Setiap elemen boleh berupa:
-    - PIL.Image.Image
-    - path string / os.PathLike
-    - Gradio image object (akan dicoba dibuka via PIL)
-    Return: list of dict label->prob (panjang sama dengan input).
-    """
-    results: List[Dict[str, float]] = []
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Face Shape Classification — EfficientNetB4 (300×300)")
+    with gr.Row():
+        inp = gr.Image(type="pil", label="Upload face (frontal)")
+        out = gr.Label(num_top_classes=5, label="Predictions")
+    btn = gr.Button("Predict")
+    btn.click(lambda im: _payload(predict(im)), inputs=inp, outputs=out)
 
-    def _as_pil(x: Any) -> Optional[Image.Image]:
-        if x is None:
-            return None
-        if isinstance(x, Image.Image):
-            return x
-        # path-like
-        if isinstance(x, (str, bytes, os.PathLike)):
-            try:
-                return Image.open(x).convert("RGB")
-            except Exception:
-                return None
-        try:
-            return Image.open(x).convert("RGB")
-        except Exception:
-            return None
+    # Batch tab (opsional)
+    with gr.Tab("Batch"):
+        gal = gr.Gallery(label="Images").style(grid=4)
+        out_gal = gr.JSON(label="Batch outputs")
+        runb = gr.Button("Run batch")
+        runb.click(lambda ims: [predict_batch(ims)], inputs=gal, outputs=out_gal)
 
-    images = images or []
-    for x in images:
-        pil = _as_pil(x)
-        if pil is None:
-            results.append({"Error": "Invalid image"})
-        else:
-            results.append(_MODEL.predict_dict(pil))
-    return results
+    # Examples (jika ada folder examples/)
+    if os.path.exists("examples"):
+        gr.Examples(
+            examples=[os.path.join("examples", f) for f in os.listdir("examples")],
+            inputs=inp
+        )
 
-
-# Optional explicit export
-__all__ = ["predict", "predict_batch"]
+if __name__ == "__main__":
+    demo.launch()

inference.py

@@ -1,31 +1,24 @@
-import os
-import json
-import time
+# inference.py
+import os, json, time
 from typing import List, Dict, Iterable, Any, Optional
 import numpy as np
 from PIL import Image
 import tensorflow as tf
 
-# -------------------- Label utilities --------------------
-
-_DEFAULT_LABELS = ["Heart", "Oblong", "Oval", "Round", "Square"]
+# ---------- Label utils ----------
+_DEFAULT_LABELS = ["Heart","Oblong","Oval","Round","Square"]
 
 def _load_labels() -> List[str]:
-    """Prioritas: models/class_indices.json -> models/idx2class.json -> default."""
-    p_ci  = os.path.join("models", "class_indices.json")   
-    p_i2c = os.path.join("models", "idx2class.json")       
-
-    # 1) class_indices.json (label->idx) → urutkan by idx
+    p_ci  = os.path.join("models", "class_indices.json")   # {"Label": idx}
+    p_i2c = os.path.join("models", "idx2class.json")       # {"0":"Label"}
     try:
         with open(p_ci, "r") as f:
             ci = json.load(f)
-        labels = [k for k, _ in sorted(ci.items(), key=lambda kv: kv[1])]
+        labels = [k for k,_ in sorted(ci.items(), key=lambda kv: kv[1])]
         print("[LABEL] from class_indices.json ->", labels)
         return labels
     except Exception:
         pass
-
-    # 2) idx2class.json (idx->label) → urutkan by idx
     try:
         with open(p_i2c, "r") as f:
             i2c = json.load(f)
@@ -34,23 +27,14 @@ def _load_labels() -> List[str]:
         return labels
     except Exception:
         pass
-
-    # 3) fallback
     print("[LABEL] fallback default ->", _DEFAULT_LABELS)
     return _DEFAULT_LABELS
 
-
-def _generate_config_if_missing(model: tf.keras.Model, labels: List[str], path: str = "config.json"):
-    """Buat config.json jika belum ada (metadata untuk Space)."""
-    if os.path.exists(path):
-        return
+def _generate_config_if_missing(model: tf.keras.Model, labels: List[str], path="config.json"):
+    if os.path.exists(path): return
     ishape = model.input_shape
-    try:
-        h = int(ishape[1])
-        assert h > 0
-    except Exception as e:
-        raise AssertionError(f"Input shape tidak valid untuk config: {ishape}") from e
-
+    h = int(ishape[1])
+    assert h > 0, f"Input shape aneh: {ishape}"
     cfg = {
         "architectures": ["EfficientNetB4"],
         "image_size": h,
@@ -58,31 +42,25 @@ def _generate_config_if_missing(model: tf.keras.Model, labels: List[str], path:
         "id2label": {str(i): lbl for i, lbl in enumerate(labels)},
         "label2id": {lbl: i for i, lbl in enumerate(labels)},
     }
-    with open(path, "w") as f:
-        json.dump(cfg, f, indent=2)
+    with open(path, "w") as f: json.dump(cfg, f, indent=2)
     print(f"[CFG] wrote {path} (image_size={h}, num_labels={len(labels)})")
 
-
-# -------------------- Model wrapper --------------------
-
+# ---------- Model wrapper ----------
 class FaceShapeModel:
-    def __init__(self, model_path: str = "models/model.keras"):
-        self.labels: List[str] = _load_labels()
-
+    def __init__(self, model_path="models/model.keras"):
+        self.labels = _load_labels()
         full_path = os.path.join(os.getcwd(), model_path)
         print(f"[LOAD] {full_path}")
-        self.model: tf.keras.Model = tf.keras.models.load_model(full_path, compile=False)
+        self.model = tf.keras.models.load_model(full_path, compile=False)
 
-        # ambil ukuran input (H=W)
         ishape = self.model.input_shape
-        self.img_size: int = int(ishape[1])
+        self.img_size = int(ishape[1])
         print(f"[MODEL] input img_size = {self.img_size}")
 
-       
         names_lower = [l.name.lower() for l in self.model.layers[:10]]
-        has_internal_pp = any(("rescaling" in n) or ("normalization" in n) for n in names_lower)
-        self.external_rescale: bool = not has_internal_pp
-        print(f"[MODEL] internal_preproc={has_internal_pp} -> external_rescale={self.external_rescale}")
+        has_pp = any(("rescaling" in n) or ("normalization" in n) for n in names_lower)
+        self.external_rescale = not has_pp
+        print(f"[MODEL] internal_preproc={has_pp} -> external_rescale={self.external_rescale}")
 
         _generate_config_if_missing(self.model, self.labels)
 
@@ -91,32 +69,48 @@ class FaceShapeModel:
         except Exception as e:
             print("[WARN] warmup failed:", e)
 
-    # ---- preprocessing ----
     def _to_rgb(self, img: Image.Image) -> Image.Image:
         return img if img.mode == "RGB" else img.convert("RGB")
 
     def _preprocess(self, img: Image.Image) -> np.ndarray:
-        img = self._to_rgb(img)
-        img = img.resize((self.img_size, self.img_size))
+        img = self._to_rgb(img).resize((self.img_size, self.img_size))
         x = np.asarray(img, dtype=np.float32)
-        if self.external_rescale:
-            x = x / 255.0  
-        return np.expand_dims(x, axis=0)  
+        if self.external_rescale: x = x / 255.0
+        return np.expand_dims(x, 0)  # (1,H,W,3)
 
-    # ---- predict ----
     def predict_dict(self, img: Image.Image) -> Dict[str, float]:
-        """Kembalikan mapping {label: prob} (cocok untuk gradio.Label)."""
         t0 = time.perf_counter()
-        x = self._preprocess(img)
-        probs = self.model.predict(x, verbose=0)[0]  # (C,)
-        out = {lbl: float(p) for lbl, p in zip(self.labels, probs)}
+        p = self.model.predict(self._preprocess(img), verbose=0)[0]
         dt = (time.perf_counter() - t0) * 1000.0
         print(f"[INF] {len(self.labels)}-class in {dt:.1f} ms")
-        return out
+        return {lbl: float(prob) for lbl, prob in zip(self.labels, p)}
 
-
-# singleton model (di-load sekali saat import)
+# singleton
 _MODEL = FaceShapeModel()
 
-
-
+# ---------- Public API ----------
+def predict(image: Image.Image) -> Dict[str, float]:
+    if image is None:
+        return {"Error": "No image"}
+    return _MODEL.predict_dict(image)
+
+def predict_batch(images: Iterable[Any]) -> List[Dict[str, float]]:
+    from PIL import Image as _PILImage
+    import os as _os
+    results: List[Dict[str, float]] = []
+
+    def _as_pil(x: Any) -> Optional[_PILImage.Image]:
+        if x is None: return None
+        if isinstance(x, _PILImage.Image): return x
+        if isinstance(x, (str, bytes, _os.PathLike)):
+            try: return _PILImage.open(x).convert("RGB")
+            except Exception: return None
+        try: return _PILImage.open(x).convert("RGB")
+        except Exception: return None
+
+    for x in (images or []):
+        im = _as_pil(x)
+        results.append({"Error": "Invalid image"} if im is None else _MODEL.predict_dict(im))
+    return results
+
+__all__ = ["predict", "predict_batch"]