Upload folder using huggingface_hub

.gitignore

@@ -0,0 +1,4 @@
+.venv/
+artifacts/
+training/data/
+__pycache__/

Dockerfile

@@ -0,0 +1,13 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . .
+
+# HF Spaces requires port 7860
+EXPOSE 7860
+
+CMD ["uvicorn", "server:app", "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,8 @@
+---
+title: M2Predict
+emoji: 🏠
+colorFrom: blue
+colorTo: green
+sdk: docker
+pinned: false
+---

inference/model_registry.py

@@ -0,0 +1,53 @@
+import json
+from pathlib import Path
+
+import joblib
+
+ROOT = Path(__file__).resolve().parents[1]  # apps/ml/
+MODELS_DIR = ROOT / "artifacts" / "models"
+
+
+class ModelBundle:
+    def __init__(self, model, te_mapping, metadata, pi_p5=None, pi_p95=None, bootstrap_models=None):
+        self.model = model
+        self.te_mapping = te_mapping
+        self.metadata = metadata
+        self.pi_p5 = pi_p5
+        self.pi_p95 = pi_p95
+        self.bootstrap_models = bootstrap_models or []
+
+
+def load_model(version: str) -> ModelBundle:
+    model_dir = MODELS_DIR / version
+    if not model_dir.exists():
+        raise ValueError(f"Model version '{version}' not found")
+
+    model = joblib.load(model_dir / "model.joblib")
+    metadata = json.loads(
+        (model_dir / "metadata.json").read_text(encoding="utf-8"))
+    te_mapping = json.loads(
+        (model_dir / "target_encoding.json").read_text(encoding="utf-8"))
+
+    conf = metadata.get("confidence", {})
+    pi_p5 = conf.get("pi_p5", None)
+    pi_p95 = conf.get("pi_p95", None)
+
+    # (optionnel) charger bootstraps HGB si présents
+    bootstrap_models = []
+    bs_dir = conf.get("bootstrap_dir")
+    if bs_dir:
+        bs_path = Path(bs_dir)
+        if not bs_path.is_absolute():
+            bs_path = model_dir / "bootstrap"
+        if bs_path.exists():
+            for p in sorted(bs_path.glob("model_boot_*.joblib")):
+                bootstrap_models.append(joblib.load(p))
+
+    return ModelBundle(
+        model=model,
+        te_mapping=te_mapping,
+        metadata=metadata,
+        pi_p5=pi_p5,
+        pi_p95=pi_p95,
+        bootstrap_models=bootstrap_models,
+    )

inference/predict.py

@@ -0,0 +1,94 @@
+import numpy as np
+import pandas as pd
+
+from .model_registry import load_model
+
+DEFAULT_MODEL = "v1_rf_te"
+
+
+def make_features(payload: dict, te_data: dict):
+    cp = str(payload["code_postal"]).zfill(5)
+
+    departement = cp[:2]
+    global_mean = te_data["global_mean"]
+    mapping = te_data["mapping"]
+
+    cp_te = mapping.get(cp, global_mean)
+
+    return pd.DataFrame([{
+        "departement": departement,
+        "surface_reelle_bati": payload["surface_reelle_bati"],
+        "nombre_pieces_principales": payload["nombre_pieces_principales"],
+        "type_local": payload["type_local"],
+        "cp_te": cp_te,
+    }])
+
+
+def _score_from_width(pi_width: float, p5: float | None, p95: float | None) -> float:
+    if p5 is None or p95 is None:
+        return 0.5  # fallback if metadata missing
+    denom = (p95 - p5) if (p95 - p5) != 0 else 1e-9
+    score = 1 - (pi_width - p5) / denom
+    return float(np.clip(score, 0, 1))
+
+
+def predict(payload: dict, model_version: str = DEFAULT_MODEL):
+    bundle = load_model(model_version)
+    X = make_features(payload, bundle.te_mapping)
+
+    pipe = bundle.model  # Pipeline(preprocess + model)
+    prix_m2 = float(pipe.predict(X)[0])
+
+    pre = pipe.named_steps["preprocess"]
+    core_model = pipe.named_steps["model"]
+
+    # ----------------------------
+    # Confidence: RF vs HGB
+    # ----------------------------
+    pi_width = None
+    q10 = None
+    q90 = None
+
+    # Case 1: RandomForestRegressor (has estimators_)
+    if hasattr(core_model, "estimators_"):
+        Xt = pre.transform(X)
+        all_tree_preds = np.array([tree.predict(Xt)[0]
+                                  for tree in core_model.estimators_])
+        q10 = float(np.quantile(all_tree_preds, 0.10))
+        q90 = float(np.quantile(all_tree_preds, 0.90))
+        pi_width = q90 - q10
+
+    # Case 2: HistGradientBoostingRegressor -> use bootstrap models
+    else:
+        # bundle.bootstrap_models is loaded in model_registry.py (from metadata.confidence.bootstrap_dir)
+        if bundle.bootstrap_models:
+            boot_preds = np.array([float(m.predict(X)[0])
+                                  for m in bundle.bootstrap_models])
+            q10 = float(np.quantile(boot_preds, 0.10))
+            q90 = float(np.quantile(boot_preds, 0.90))
+            pi_width = q90 - q10
+        else:
+            # no bootstrap models available => cannot compute uncertainty properly
+            pi_width = None
+
+    score = _score_from_width(
+        pi_width=float(pi_width) if pi_width is not None else 0.0,
+        p5=bundle.pi_p5,
+        p95=bundle.pi_p95,
+    ) if pi_width is not None else 0.5
+
+    surface = float(payload["surface_reelle_bati"])
+    prix_total = prix_m2 * surface
+
+    return {
+        "model_version": model_version,
+        "prix_m2": round(prix_m2, 2),
+        "prix_total_estime": round(prix_total, 2),
+        "score_confiance": round(score, 3),
+
+        # optional debug
+        "intervalle_largeur": None if pi_width is None else round(float(pi_width), 2),
+        "q10": None if q10 is None else round(q10, 2),
+        "q90": None if q90 is None else round(q90, 2),
+        "confidence_method": bundle.metadata.get("confidence", {}).get("method"),
+    }

main.py

@@ -0,0 +1,10 @@
+from inference.predict import predict
+
+result = predict({
+    "code_postal": "75011",
+    "surface_reelle_bati": 42,
+    "nombre_pieces_principales": 2,
+    "type_local": "Appartement",
+})
+
+print(result)

package.json

@@ -0,0 +1,7 @@
+{
+	"name": "ml",
+	"private": true,
+	"scripts": {
+		"dev": ".venv\\Scripts\\python -m uvicorn server:app --reload --port 8000"
+	}
+}

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+joblib
+numpy
+pandas
+pyarrow
+scikit-learn
+tqdm
+uvicorn[standard]

server.py

@@ -0,0 +1,29 @@
+from __future__ import annotations
+
+from fastapi import FastAPI
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+
+from inference.predict import predict
+
+app = FastAPI(title="M2Predict API")
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+class PredictRequest(BaseModel):
+    code_postal: str
+    surface_reelle_bati: float
+    nombre_pieces_principales: int
+    type_local: str
+
+
+@app.post("/predict")
+def predict_endpoint(req: PredictRequest, model_version: str = "v1_rf_te"):
+    result = predict(req.model_dump(), model_version=model_version)
+    return result