update setup to b4

inference.py

@@ -1,132 +1,107 @@
-# inference.py
 import os, json, time
-from typing import List, Dict, Tuple, Any
+from typing import List, Dict, Any
 import numpy as np
 from PIL import Image
 import tensorflow as tf
+import gradio as gr
 
-# ---------- Label handling ----------
+# ---------- label loader ----------
 _DEFAULT_LABELS = ["Heart","Oblong","Oval","Round","Square"]
 
-def _load_labels() -> List[str]:
+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
+            d = json.load(f)  # {"Label": idx}
+        return [k for k,_ in sorted(d.items(), key=lambda kv: kv[1])]
     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
+            d = json.load(f)  # {"0":"Label"}
+        return [d[str(i)] for i in range(len(d))]
     except Exception:
-        print(f"[LABEL] fallback default -> {_DEFAULT_LABELS}")
         return _DEFAULT_LABELS
 
-LABELS: List[str] = _load_labels()
+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
+    h = ishape[1] if isinstance(ishape, (list, tuple)) and len(ishape) > 1 else None
+    assert isinstance(h, int) and h > 0, f"Input shape aneh: {ishape}"
+    cfg = {
+        "architectures": ["EfficientNetB4"],
+        "image_size": int(h),
+        "num_labels": len(labels),
+        "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)
+    print(f"[CFG] wrote {path} (image_size={h})")
 
-# ---------- Model loader ----------
+# ---------- model wrapper ----------
 class FaceShapeModel:
-    def __init__(self, model_path: str = os.path.join("models","model.keras")) -> None:
-        self.model = None
-        self.img_size = 224
-        self.external_rescale = False
-
+    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.models.load_model(full_path, compile=False)
 
-        # Ambil ukuran input dari model (None, H, W, 3)
+        # input size
         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
+        self.img_size = int(ishape[1])
         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}")
+        # detect internal preprocessing
+        first = [l.name.lower() for l in self.model.layers[:8]]
+        has_pp = any(("rescaling" in n) or ("normalization" in n) for n in first)
+        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)
 
-        # Warm-up (optional)
+        # warmup
         try:
             _ = self.model(tf.zeros((1, self.img_size, self.img_size, 3), dtype=tf.float32))
         except Exception as e:
             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 _preprocess(self, img: Image.Image) -> np.ndarray:
+        if img.mode != "RGB": img = img.convert("RGB")
+        img = 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, 0)
 
-    def predict_image(self, image: Image.Image) -> Dict[str, float]:
-        if self.model is None:
-            return {"Error": "Model tidak dimuat."}
-        if image is None:
-            return {"Error": "Gambar kosong."}
+    def predict_dict(self, img: Image.Image) -> Dict[str,float]:
         t0 = time.perf_counter()
-        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")
+        x = self._preprocess(img)
+        p = self.model.predict(x, verbose=0)[0]
+        out = {lbl: float(prob) for lbl, prob in zip(self.labels, p)}
+        print(f"[INF] {len(self.labels)}-class in {(time.perf_counter()-t0)*1000:.1f} ms")
         return out
 
-# singleton
 _model = FaceShapeModel()
 
-# gradio APIs
-def predict(image_pil: Image.Image) -> Dict[str, float]:
-    if _model and _model.model is not None:
-        return _model.predict_image(image_pil)
-    return {"Error": "Instance model tidak tersedia."}
+def predict(image: Image.Image) -> Dict[str, float]:
+    if image is None: return {"Error":"No image"}
+    return _model.predict_dict(image)
 
-# (opsional) batch
-def _dict_to_payload(d: Dict[str, float]) -> Dict[str, object]:
-    if not d or any(k == "Error" for k in d):
-        return {"label": "", "confidences": []}
+# --- Gradio UI ---
+def _payload(d: Dict[str,float]):
     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]}
+    return {"label": items[0][0], "confidences": [{"label":k, "confidence":v} for k,v in items]}
 
-def _to_pil_list(files: List[Any]) -> List[Image.Image]:
-    out = []
-    for f in files or []:
-        try:
-            if isinstance(f, Image.Image):
-                out.append(f); continue
-            path = getattr(f, "path", None) or getattr(f, "name", None) or (f if isinstance(f,str) else None)
-            if path:
-                out.append(Image.open(path).convert("RGB"))
-        except Exception:
-            continue
-    return out
+with gr.Blocks(theme=gr.themes.Soft()) as demo:
+    gr.Markdown("# Face Shape Classification — EfficientNetB4 (300×300)")
+    inp = gr.Image(type="pil", label="Upload face image (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)
+    gr.Examples(
+        examples=[os.path.join("examples", f) for f in os.listdir("examples")] if os.path.exists("examples") else [],
+        inputs=inp
+    )
 
-def predict_batch(files: List[Any]) -> Dict[str, object]:
-    if not _model or _model.model is None:
-        return {"error": "Instance model tidak tersedia."}
-    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
+if __name__ == "__main__":
+    demo.launch()

models/class_indices.json

@@ -0,0 +1,7 @@
+{
+  "Heart": 0,
+  "Oblong": 1,
+  "Oval": 2,
+  "Round": 3,
+  "Square": 4
+}

models/idx2class.json

@@ -0,0 +1,7 @@
+{
+  "0": "Heart",
+  "1": "Oblong",
+  "2": "Oval",
+  "3": "Round",
+  "4": "Square"
+}