Initial upload face-shape Space

.gitattributes

@@ -0,0 +1 @@
+*.keras filter=lfs diff=lfs merge=lfs -text

app.py

@@ -0,0 +1,120 @@
+from __future__ import annotations
+
+import logging
+import os
+from typing import Dict, List, Optional, Tuple
+
+import gradio as gr
+import numpy as np
+import tensorflow as tf
+from PIL import Image
+
+from config import settings
+
+logging.basicConfig(level=logging.INFO, format="[%(asctime)s] %(levelname)s %(message)s")
+logger = logging.getLogger(__name__)
+
+IMG_SIZE = 244
+
+
+class FaceShapeModel:
+    def __init__(self, model_path: str, labels: List[str]):
+        if not os.path.exists(model_path):
+            raise FileNotFoundError(f"Model file not found at: {model_path}")
+
+        self.labels = labels
+        logger.info("Loading TensorFlow model from %s", model_path)
+        self.model = tf.keras.models.load_model(model_path)
+        logger.info("Model loaded successfully with %d labels", len(labels))
+
+    @staticmethod
+    def _preprocess(image: Image.Image) -> np.ndarray:
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+
+        resized = image.resize((IMG_SIZE, IMG_SIZE), Image.BILINEAR)
+        array = tf.keras.preprocessing.image.img_to_array(resized)
+        array = np.expand_dims(array, axis=0)
+        return array
+
+    def predict_image(self, image: Image.Image) -> Dict[str, float]:
+        batch = self._preprocess(image)
+        preds = self.model.predict(batch, verbose=0)
+
+        if isinstance(preds, (list, tuple)):
+            preds = preds[0]
+
+        scores = np.asarray(preds).squeeze()
+
+        if scores.ndim == 0:
+            scores = np.array([float(scores)])
+
+        if len(scores) != len(self.labels):
+            raise ValueError(
+                "Model output length does not match labels. "
+                f"Expected {len(self.labels)} values, got {len(scores)}."
+            )
+
+        return {label: float(score) for label, score in zip(self.labels, scores.tolist())}
+
+
+_model: Optional[FaceShapeModel] = None
+
+
+def get_model() -> FaceShapeModel:
+    global _model
+    if _model is None:
+        _model = FaceShapeModel(settings.model_path, settings.labels)
+    return _model
+
+
+def predict(image: Image.Image) -> Dict[str, float]:
+    try:
+        model = get_model()
+    except Exception as exc:  # pragma: no cover - defensive logging
+        logger.exception("Failed to load model")
+        raise gr.Error(f"Model gagal dimuat: {exc}") from exc
+
+    try:
+        return model.predict_image(image)
+    except Exception as exc:
+        logger.exception("Prediction failed")
+        raise gr.Error(f"Prediksi gagal: {exc}") from exc
+
+
+def build_interface() -> gr.Interface:
+    return gr.Interface(
+        fn=predict,
+        inputs=gr.Image(type="pil", image_mode="RGB"),
+        outputs=gr.Label(num_top_classes=3),
+        title="Face Shape Detection",
+        description="Unggah foto wajah untuk mendeteksi bentuk wajah Anda menggunakan model TensorFlow.",
+        allow_flagging="never",
+    )
+
+
+def launch_app():
+    iface = build_interface()
+
+    auth_credentials: Optional[Tuple[str, str]] = None
+    if settings.gradio_username and settings.gradio_password:
+        auth_credentials = (settings.gradio_username, settings.gradio_password)
+
+    iface.launch(
+        server_name="0.0.0.0",
+        server_port=settings.port,
+        share=settings.share,
+        auth=auth_credentials,
+        auth_message="Masukkan kredensial untuk mengakses demo",
+        auth_token=settings.gradio_auth_token,
+        cors=settings.cors_allowed_origins,
+        show_api=True,
+    )
+
+
+if __name__ == "__main__":
+    try:
+        launch_app()
+    except Exception:  # pragma: no cover - console visibility
+        logger.exception("Gradio application terminated due to an error")
+        raise

config.json

@@ -0,0 +1,13 @@
+{
+  "model_path": "model/best_model.keras",
+  "labels": ["Heart", "Oblong", "Oval", "Round", "Square"],
+  "port": 7860,
+  "cors_allowed_origins": [
+    "http://localhost:3000",
+    "http://127.0.0.1:3000"
+  ],
+  "share": false,
+  "gradio_auth_token": null,
+  "gradio_username": null,
+  "gradio_password": null
+}

config.py

@@ -0,0 +1,132 @@
+from __future__ import annotations
+
+import json
+import os
+from dataclasses import dataclass
+from functools import lru_cache
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+CONFIG_FILE = Path(__file__).with_name("config.json")
+DEFAULT_LABELS: List[str] = [
+    "Heart",
+    "Oblong",
+    "Oval",
+    "Round",
+    "Square",
+]
+DEFAULT_ALLOWED_ORIGINS: List[str] = [
+    "http://localhost:3000",
+    "http://127.0.0.1:3000",
+]
+DEFAULT_PORT = 7860
+
+
+def _load_config_file() -> Dict[str, Any]:
+    if not CONFIG_FILE.exists():
+        return {}
+
+    try:
+        return json.loads(CONFIG_FILE.read_text())
+    except json.JSONDecodeError as exc:
+        raise ValueError(f"Konfigurasi JSON tidak valid: {CONFIG_FILE}") from exc
+
+
+def _parse_labels(raw: Any) -> List[str]:
+    if raw is None:
+        return DEFAULT_LABELS.copy()
+
+    if isinstance(raw, str):
+        parts = [label.strip() for label in raw.split(",") if label.strip()]
+        return parts or DEFAULT_LABELS.copy()
+
+    if isinstance(raw, list):
+        filtered = [str(label).strip() for label in raw if str(label).strip()]
+        return filtered or DEFAULT_LABELS.copy()
+
+    return DEFAULT_LABELS.copy()
+
+
+def _parse_origins(raw: Any) -> List[str]:
+    if raw is None:
+        return DEFAULT_ALLOWED_ORIGINS.copy()
+
+    if isinstance(raw, str):
+        parts = [origin.strip() for origin in raw.split(",") if origin.strip()]
+        return parts or DEFAULT_ALLOWED_ORIGINS.copy()
+
+    if isinstance(raw, list):
+        filtered = [str(origin).strip() for origin in raw if str(origin).strip()]
+        return filtered or DEFAULT_ALLOWED_ORIGINS.copy()
+
+    return DEFAULT_ALLOWED_ORIGINS.copy()
+
+
+def _parse_bool(raw: Any, fallback: bool = False) -> bool:
+    if raw is None:
+        return fallback
+
+    if isinstance(raw, bool):
+        return raw
+
+    return str(raw).strip().lower() in {"1", "true", "yes", "on"}
+
+
+def _parse_int(raw: Any, fallback: int) -> int:
+    if raw is None:
+        return fallback
+
+    try:
+        value = int(raw)
+    except (TypeError, ValueError):
+        return fallback
+
+    return value if value > 0 else fallback
+
+
+def _resolve_model_path(file_value: Optional[str]) -> str:
+    env_value = os.environ.get("MODEL_PATH")
+    candidate = env_value or file_value or "model/best_model.keras"
+    path = Path(candidate)
+    if not path.is_absolute():
+        path = (CONFIG_FILE.parent / path).resolve()
+    return str(path)
+
+
+@dataclass(frozen=True)
+class Settings:
+    model_path: str
+    labels: List[str]
+    port: int
+    cors_allowed_origins: List[str]
+    gradio_auth_token: str | None
+    gradio_username: str | None
+    gradio_password: str | None
+    share: bool
+
+
+_CONFIG_CACHE = _load_config_file()
+
+
+@lru_cache(maxsize=1)
+def get_settings() -> Settings:
+    labels_raw = os.environ.get("MODEL_LABELS")
+    origins_raw = os.environ.get("CORS_ALLOWED_ORIGINS")
+    share_raw: Any = os.environ.get("GRADIO_SHARE")
+    port_raw: Any = os.environ.get("PORT")
+
+    return Settings(
+        model_path=_resolve_model_path(_CONFIG_CACHE.get("model_path")),
+        labels=_parse_labels(labels_raw if labels_raw is not None else _CONFIG_CACHE.get("labels")),
+        port=_parse_int(port_raw if port_raw is not None else _CONFIG_CACHE.get("port"), DEFAULT_PORT),
+        cors_allowed_origins=_parse_origins(
+            origins_raw if origins_raw is not None else _CONFIG_CACHE.get("cors_allowed_origins")
+        ),
+        gradio_auth_token=os.environ.get("GRADIO_AUTH_TOKEN") or _CONFIG_CACHE.get("gradio_auth_token"),
+        gradio_username=os.environ.get("GRADIO_USERNAME") or _CONFIG_CACHE.get("gradio_username"),
+        gradio_password=os.environ.get("GRADIO_PASSWORD") or _CONFIG_CACHE.get("gradio_password"),
+        share=_parse_bool(share_raw if share_raw is not None else _CONFIG_CACHE.get("share"), False),
+    )
+
+
+settings = get_settings()

inference.py

@@ -0,0 +1,61 @@
+from __future__ import annotations
+
+import io
+from typing import Any, Dict, List
+
+import numpy as np
+from PIL import Image
+import tensorflow as tf
+
+LABELS: List[str] = [
+    "Heart",
+    "Oblong",
+    "Oval",
+    "Round",
+    "Square",
+]
+
+TARGET_SIZE = 244
+
+def _load_image(image_bytes: bytes) -> Image.Image:
+    image = Image.open(io.BytesIO(image_bytes))
+    if image.mode != "RGB":
+        image = image.convert("RGB")
+    return image
+
+
+def _preprocess(image_bytes: bytes) -> np.ndarray:
+    image = _load_image(image_bytes)
+    resized = image.resize((TARGET_SIZE, TARGET_SIZE), Image.BILINEAR)
+    array = np.asarray(resized, dtype="float32")
+    array /= 255.0
+    return np.expand_dims(array, axis=0)
+
+
+class PreTrainedModel:
+    def __init__(self, model_path: str = "model/best_model.keras") -> None:
+        self.model = tf.keras.models.load_model(model_path)
+
+    def predict(self, inputs: bytes) -> List[Dict[str, Any]]:
+        batch = _preprocess(inputs)
+        preds = self.model.predict(batch, verbose=0)
+
+        if isinstance(preds, (list, tuple)):
+            preds = preds[0]
+
+        scores = np.asarray(preds).squeeze()
+        if scores.ndim == 0:
+            scores = np.array([float(scores)])
+
+        scores_list = scores.tolist()
+        top_index = int(np.argmax(scores_list))
+        return [
+            {
+                "label": LABELS[top_index],
+                "score": float(scores_list[top_index]),
+            }
+        ]
+
+
+def load_model(model_dir: str = ".") -> PreTrainedModel:
+    return PreTrainedModel(model_path=f"{model_dir}/model/best_model.keras")

model/best_model.keras

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:da4bb3f7d3abd04447e80d50a183354f03921c9971a471f6ee0144dceaf1b60a
+size 32285016

requirements.txt

@@ -0,0 +1,5 @@
+tensorflow==2.16.1
+numpy
+Pillow
+requests
+gradio