Initial commit

.gitignore

@@ -0,0 +1,18 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+*.pyc
+
+# System
+.DS_Store
+
+# Virtual environments
+.venv/
+.qodo/
+.gradio/
+
+secrets/

app.py

@@ -0,0 +1,275 @@
+import os
+import time
+import json
+import tempfile
+from pathlib import Path
+
+import numpy as np
+import pandas as pd
+import gradio as gr
+
+# --- Earth Engine
+import ee
+
+# -------------------- AUTH GEE --------------------
+# Sur Hugging Face Spaces : définir ces 2 secrets dans Settings > Repository secrets
+#   EE_SERVICE_ACCOUNT  -> ex: gee-sa@your-project.iam.gserviceaccount.com
+#   EE_SERVICE_KEY      -> contenu JSON de la clé (copier-coller)
+SA_EMAIL = os.getenv("EE_SERVICE_ACCOUNT")
+SA_KEY_JSON = os.getenv("EE_SERVICE_KEY")
+
+def init_ee():
+    if SA_EMAIL and SA_KEY_JSON:
+        key_path = os.path.join(tempfile.gettempdir(), "ee-key.json")
+        if not os.path.exists(key_path):
+            with open(key_path, "w") as f:
+                f.write(SA_KEY_JSON)
+        creds = ee.ServiceAccountCredentials(SA_EMAIL, key_path)
+        ee.Initialize(creds)
+    else:
+        # Local: ee.Authenticate() une fois dans le terminal, puis:
+        try:
+            ee.Initialize()
+        except Exception as e:
+            raise RuntimeError(
+                "GEE non initialisé. Définis EE_SERVICE_ACCOUNT/EE_SERVICE_KEY (Space) "
+                "ou exécute ee.Authenticate() en local."
+            ) from e
+
+init_ee()
+
+# -------------------- Collections --------------------
+S2 = ee.ImageCollection("COPERNICUS/S2_SR_HARMONIZED")
+S1 = ee.ImageCollection("COPERNICUS/S1_GRD")
+DEM = ee.Image("USGS/SRTMGL1_003")
+
+# -------------------- Utilitaires --------------------
+def days_since_utc(utc_iso: str) -> int:
+    t_img = time.mktime(time.strptime(utc_iso[:19], "%Y-%m-%dT%H:%M:%S"))
+    return int((time.time() - t_img) // 86400)
+
+def s2_mask_clouds(img: ee.Image) -> ee.Image:
+    # Masque nuages QA60 (bits 10 et 11)
+    qa = img.select("QA60")
+    cloud = qa.bitwiseAnd(1 << 10).Or(qa.bitwiseAnd(1 << 11)).neq(0)
+    return img.updateMask(cloud.Not())
+
+def add_s2_scale(img: ee.Image) -> ee.Image:
+    # S2_SR est en int16 avec scale = 1e-4
+    scale = 1e-4
+    bands = img.select(["B1","B2","B3","B4","B5","B6","B7","B8","B8A","B9","B11","B12"])
+    return img.addBands(bands.multiply(scale), overwrite=True)
+
+def compute_s2_indices(img: ee.Image) -> ee.Image:
+    # Band aliases
+    B1  = img.select("B1");  B2  = img.select("B2");  B3  = img.select("B3");  B4  = img.select("B4")
+    B5  = img.select("B5");  B6  = img.select("B6");  B7  = img.select("B7");  B8  = img.select("B8")
+    B8A = img.select("B8A"); B9  = img.select("B9");  B11 = img.select("B11"); B12 = img.select("B12")
+
+    eps = 1e-6
+    NDVI  = img.normalizedDifference(["B8","B4"]).rename("NDVI")
+    GNDVI = img.normalizedDifference(["B8","B3"]).rename("GNDVI")
+    NDWI  = img.normalizedDifference(["B3","B8"]).rename("NDWI")
+    NDMI  = img.normalizedDifference(["B8","B11"]).rename("NDMI")
+    NBR   = img.normalizedDifference(["B8","B12"]).rename("NBR")
+
+    EVI = img.expression(
+        "2.5 * (NIR - RED) / (NIR + 6*RED - 7.5*BLUE + 1.0 + eps)",
+        {"NIR": B8, "RED": B4, "BLUE": B2, "eps": eps}
+    ).rename("EVI")
+
+    SAVI = img.expression(
+        "((NIR - RED) / (NIR + RED + L)) * (1 + L)",
+        {"NIR": B8, "RED": B4, "L": 0.5}
+    ).rename("SAVI")
+
+    MSAVI2 = img.expression(
+        "(2*NIR + 1 - sqrt((2*NIR + 1)^2 - 8*(NIR - RED))) / 2",
+        {"NIR": B8, "RED": B4}
+    ).rename("MSAVI2")
+
+    SIPI = img.expression(
+        "(NIR - BLUE) / (NIR + RED + eps)",
+        {"NIR": B8, "RED": B4, "BLUE": B2, "eps": eps}
+    ).rename("SIPI")
+
+    ARVI = img.expression(
+        "(NIR - (2*RED - BLUE)) / (NIR + (2*RED - BLUE) + eps)",
+        {"NIR": B8, "RED": B4, "BLUE": B2, "eps": eps}
+    ).rename("ARVI")
+
+    return img.addBands([NDVI, EVI, SAVI, NDWI, NDMI, NBR, GNDVI, MSAVI2, SIPI, ARVI])
+
+def s1_preprocess(ic: ee.ImageCollection) -> ee.ImageCollection:
+    # Filtre sur mode IW, sélection VV/VH, median composite
+    return (ic.filter(ee.Filter.eq("instrumentMode", "IW"))
+             .select(["VV","VH"]))
+
+def lonlat_to_utm_epsg(lon: float, lat: float) -> int:
+    zone = int((lon + 180) // 6) + 1
+    if lat >= 0:
+        return 32600 + zone  # WGS84 UTM N
+    else:
+        return 32700 + zone  # WGS84 UTM S
+
+def projected_xy(lon: float, lat: float):
+    # Retourne easting/northing (en mètres) du centroïde en UTM
+    epsg = f"EPSG:{lonlat_to_utm_epsg(lon, lat)}"
+    # Utilise EE pour projeter sans dépendance externe
+    pt = ee.Geometry.Point([lon, lat])
+    proj = ee.Projection(epsg)
+    xy = ee.List(pt.transform(proj, 1).coordinates()).getInfo()
+    return float(xy[0]), float(xy[1])
+
+# -------------------- Extraction features --------------------
+S2_BANDS = ["B2","B3","B4","B5","B6","B7","B8","B8A","B11","B12","B1","B9"]  # ordre stable (12)
+S2_IDX   = ["NDVI","EVI","SAVI","NDWI","NDMI","NBR","GNDVI","MSAVI2","SIPI","ARVI"]
+S1_VARS  = ["VV","VH","VVVHR"]
+TOPO     = ["elevation","slope"]
+COORDS   = ["latitude_proj","longitude_proj"]  # en UTM (northing/easting) – noms conservés pour compat
+
+EXPECTED_COLUMNS = S2_BANDS + S2_IDX + S1_VARS + TOPO + COORDS
+
+def extract_from_gee(lat: float, lon: float, radius_m: int = 150):
+    pt = ee.Geometry.Point([float(lon), float(lat)])
+    roi = pt.buffer(radius_m).bounds()
+
+    # S2: 2 ans récents, nuages < 40%
+    end = ee.Date.now()
+    start = end.advance(-2, "year")
+    s2 = (S2.filterBounds(roi)
+            .filterDate(start, end)
+            .filter(ee.Filter.lt("CLOUDY_PIXEL_PERCENTAGE", 40))
+            .map(s2_mask_clouds)
+            .map(add_s2_scale)
+            .map(compute_s2_indices))
+
+    img_s2 = s2.sort("system:time_start", False).first()
+    if img_s2 is None:
+        return None, {"error": "No Sentinel-2 image available on ROI/time window."}
+
+    cloud_cover = ee.Number(img_s2.get("CLOUDY_PIXEL_PERCENTAGE")).getInfo()
+    acq_iso = ee.Date(img_s2.get("system:time_start")).format().getInfo()
+    days = days_since_utc(acq_iso)
+
+    # S1: même fenêtre – median composite
+    s1 = s1_preprocess(S1.filterBounds(roi).filterDate(start, end))
+    img_s1 = s1.median()
+
+    # DEM
+    elevation = DEM.select("elevation")
+    slope = ee.Terrain.slope(DEM).rename("slope")
+
+    # Réductions
+    reducer = ee.Reducer.mean()
+    s2_vals = img_s2.select(S2_BANDS + S2_IDX).reduceRegion(reducer=reducer, geometry=roi, scale=20, maxPixels=1e8).getInfo()
+    s1_vals = img_s1.select(["VV","VH"]).reduceRegion(reducer=reducer, geometry=roi, scale=20, maxPixels=1e8).getInfo()
+    topo_vals = elevation.addBands(slope).reduceRegion(reducer=reducer, geometry=roi, scale=30, maxPixels=1e8).getInfo()
+
+    # Compose features dict
+    feats = {}
+    # S2 bands & indices
+    for k in (S2_BANDS + S2_IDX):
+        v = s2_vals.get(k) if s2_vals else None
+        feats[k] = float(v) if v is not None else np.nan
+
+    # S1 VV/VH + ratio
+    vv = s1_vals.get("VV") if s1_vals else None
+    vh = s1_vals.get("VH") if s1_vals else None
+    vv = float(vv) if vv is not None else np.nan
+    vh = float(vh) if vh is not None else np.nan
+    feats["VV"] = vv
+    feats["VH"] = vh
+    feats["VVVHR"] = (vv / vh) if (not np.isnan(vv) and not np.isnan(vh) and vh != 0) else np.nan
+
+    # Topo
+    elev = topo_vals.get("elevation") if topo_vals else None
+    slp  = topo_vals.get("slope") if topo_vals else None
+    feats["elevation"] = float(elev) if elev is not None else np.nan
+    feats["slope"]     = float(slp) if slp is not None else np.nan
+
+    # Coords projetées UTM (northing/easting)
+    easting, northing = projected_xy(lon, lat)
+    feats["latitude_proj"]  = northing   # naming conservé
+    feats["longitude_proj"] = easting
+
+    # NDVI moyen pour affichage
+    ndvi_mean = feats["NDVI"] if "NDVI" in feats and not np.isnan(feats["NDVI"]) else None
+
+    # DataFrame ordonné (colonnes exactement comme attendues)
+    row = {k: feats.get(k, np.nan) for k in EXPECTED_COLUMNS}
+    X = pd.DataFrame([row], columns=EXPECTED_COLUMNS)
+
+    return {
+        "X": X,
+        "cloud": float(cloud_cover),
+        "days": int(days),
+        "ndvi_mean": (None if ndvi_mean is None else float(ndvi_mean))
+    }, None
+
+# -------------------- Modèle (pipeline sklearn + CatBoost) --------------------
+def load_pipeline():
+    path = Path("data/best_model_c_pipeline.pkl")
+    if not path.exists():
+        raise RuntimeError("Modèle introuvable: data/best_model_c_pipeline.pkl")
+    import joblib
+    return joblib.load(path)
+
+PIPE = load_pipeline()
+
+def predict_agbd(df_row: pd.DataFrame) -> float:
+    # Le pipeline gère prétraitements (scalers, PCA, etc.) + CatBoost
+    y = PIPE.predict(df_row)
+    return float(np.asarray(y).ravel()[0])
+
+def carbon_from_agbd(agbd_t_ha: float, cf: float = 0.55) -> float:
+    return float(agbd_t_ha * cf)
+
+# -------------------- Gradio callbacks --------------------
+def run_all(location_name: str, lat: float, lon: float):
+    try:
+        data, err = extract_from_gee(lat, lon)
+        if err is not None or data is None:
+            return ("n/a", "n/a", "n/a", "n/a", "n/a")
+        X = data["X"]
+        agbd = predict_agbd(X)
+        carbon = carbon_from_agbd(agbd)
+        cloud = data["cloud"]
+        days = data["days"]
+        ndvi = data["ndvi_mean"]
+        return (f"{cloud:.4f} %",
+                f"{days} days ago",
+                f"{agbd:.5f} t/ha",
+                f"{carbon:.5f} tC/ha",
+                ("NDVI: {:.4f}".format(ndvi) if ndvi is not None else "NDVI: n/a"))
+    except Exception as e:
+        # Retourne 5 champs texte pour éviter les erreurs Gradio côté UI
+        return ("error", "", "", "", str(e))
+
+with gr.Blocks(theme=gr.themes.Soft(), fill_height=True) as demo:
+    gr.Markdown("🌴 **BEEPAS (GEE + CatBoost)** — Biomass estimation 🌴")
+
+    with gr.Row():
+        with gr.Column(scale=1):
+            name = gr.Textbox(label="location_name", value="ile boulay :")
+            lat = gr.Number(label="lat", value=5.280498, precision=6)
+            lon = gr.Number(label="lon", value=-4.089883, precision=6)
+            with gr.Row():
+                clear = gr.Button("Clear")
+                submit = gr.Button("Submit", variant="primary")
+        with gr.Column(scale=1):
+            cloud = gr.Textbox(label="Cloud coverage")
+            days  = gr.Textbox(label="Number of days since sensing")
+            agbd  = gr.Textbox(label="Above ground biomass density (AGBD) t/ha")
+            cstock= gr.Textbox(label="Carbon stock density tC/ha")
+            ndvi  = gr.Textbox(label="Mean NDVI")
+
+    def _on_submit(n, la, lo): return run_all(n, la, lo)
+    submit.click(_on_submit, [name, lat, lon], [cloud, days, agbd, cstock, ndvi])
+
+    def _on_clear():
+        return "", None, None, "", "", ""
+    clear.click(_on_clear, outputs=[name, lat, lon, cloud, days, agbd])
+
+if __name__ == "__main__":
+    demo.launch()

data/best_model_c_pipeline.pkl

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

requirements.txt

@@ -0,0 +1,5 @@
+catboost==1.2.8
+earthengine-api==1.6.13
+gradio>=5.49.1
+joblib==1.5.2
+pandas==2.3.3