Upload 6 files

Dockerfile

@@ -0,0 +1,36 @@
+# ─────────────────────────────────────────────
+# Base image (lightweight Python)
+# ─────────────────────────────────────────────
+FROM python:3.10-slim
+
+# Prevent python from buffering stdout/stderr
+ENV PYTHONUNBUFFERED=1
+ENV PYTHONDONTWRITEBYTECODE=1
+
+# Set working directory
+WORKDIR /app
+
+# Install system dependencies (needed for torch, pandas, etc.)
+RUN apt-get update && apt-get install -y \
+    build-essential \
+    curl \
+    git \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first (better Docker caching)
+COPY requirements.txt .
+
+# Upgrade pip
+RUN pip install --upgrade pip
+
+# Install Python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy entire app
+COPY . .
+
+# Expose port (HF uses 7860 internally)
+EXPOSE 7860
+
+# Start FastAPI using uvicorn
+CMD ["uvicorn", "main:app", "--host", "0.0.0.0", "--port", "7860"]

main.py

@@ -0,0 +1,215 @@
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel, Field
+import numpy as np
+import torch
+import pickle
+import json
+import os
+from typing import Optional
+
+# ── App Setup ─────────────────────────────────────────────────────────────────
+app = FastAPI(
+    title="PSInSAR Deformation Forecast API",
+    description="PINN-based ground deformation risk forecasting from PSInSAR data",
+    version="1.0.0",
+)
+
+# ── Global state (loaded once at startup) ─────────────────────────────────────
+scaler = None
+cfg = None
+model = None
+df = None
+df_clean = None
+
+DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# ── These must match your training setup ──────────────────────────────────────
+FEATURE_COLS = []   # ← replace with your actual feature column names
+PHYSICS_COLS = []   # ← replace with your actual physics column names
+SEQ_LEN = 10        # ← replace with your actual sequence length
+HORIZON = 3         # ← replace with your actual horizon
+N_PASSES = 50       # MC Dropout passes
+
+
+# ── Request / Response Schemas ────────────────────────────────────────────────
+class ForecastRequest(BaseModel):
+    lat: float = Field(..., description="Target latitude", example=22.360001)
+    lon: float = Field(..., description="Target longitude", example=82.530869)
+    tolerance: Optional[float] = Field(
+        0.001, description="Search radius in degrees to find nearest PS point"
+    )
+
+
+class EpochForecast(BaseModel):
+    day: float
+    failure_probability: float
+    uncertainty_std: float
+    high_risk: bool
+
+
+class ForecastResponse(BaseModel):
+    ps_id: str
+    actual_lat: float
+    actual_lon: float
+    total_epochs: int
+    forecast_count: int
+    high_risk_count: int
+    high_risk_pct: float
+    mean_failure_probability: float
+    mean_uncertainty: float
+    first_alarm_day: Optional[float]
+    threshold_used: float
+    model_auc: float
+    model_pr_auc: float
+    forecasts: list[EpochForecast]
+
+
+# ── Startup: load model & data ─────────────────────────────────────────────────
+@app.on_event("startup")
+def load_assets():
+    global scaler, cfg, model, df, df_clean
+
+    # Load scaler
+    with open("scaler.pkl", "rb") as f:
+        scaler = pickle.load(f)
+
+    # Load config
+    with open("model_config.json", "r") as f:
+        cfg = json.load(f)
+
+    # Load model  ← import your model class before this block
+    # from your_model_module import YourPINNModel
+    # model = YourPINNModel(**cfg["model_params"]).to(DEVICE)
+    model.load_state_dict(torch.load("pinn_best.pt", map_location=DEVICE))
+    model.eval()
+
+    # Load dataframes  ← replace with your actual data loading logic
+    # import pandas as pd
+    # df = pd.read_parquet("ps_data.parquet")
+    # df_clean = pd.read_parquet("ps_data_clean.parquet")
+
+    print(f"Assets loaded. Running on {DEVICE}")
+
+
+# ── Helper: find nearest PS point ─────────────────────────────────────────────
+def get_ps_by_latlon(lat: float, lon: float, tol: float = 0.001) -> str:
+    mask = (
+        (np.abs(df["lat"] - lat) <= tol) &
+        (np.abs(df["lon"] - lon) <= tol)
+    )
+    matches = df[mask]
+
+    if len(matches) == 0:
+        # Fallback: absolute nearest point
+        dist = np.sqrt((df["lat"] - lat) ** 2 + (df["lon"] - lon) ** 2)
+        nearest = df.loc[dist.idxmin()]
+        return str(nearest["ps_id"]), nearest["lat"], nearest["lon"], True
+
+    matches = matches.copy()
+    matches["_dist"] = np.sqrt(
+        (matches["lat"] - lat) ** 2 + (matches["lon"] - lon) ** 2
+    )
+    row = matches.loc[matches["_dist"].idxmin()]
+    return str(row["ps_id"]), row["lat"], row["lon"], False
+
+
+# ── Forecast endpoint ──────────────────────────────────────────────────────────
+@app.post("/forecast", response_model=ForecastResponse)
+def forecast(req: ForecastRequest):
+    try:
+        ps_id, actual_lat, actual_lon, used_fallback = get_ps_by_latlon(
+            req.lat, req.lon, req.tolerance
+        )
+    except Exception as e:
+        raise HTTPException(status_code=404, detail=f"Could not find PS point: {e}")
+
+    # Load time series for this PS point
+    ps_raw = (
+        df[df["ps_id"] == ps_id]
+        .sort_values("days_since_start")
+        .reset_index(drop=True)
+    )
+    ps_clean = (
+        df_clean[df_clean["ps_id"] == ps_id]
+        .sort_values("days_since_start")
+        .reset_index(drop=True)
+    )
+
+    if len(ps_clean) < SEQ_LEN + HORIZON + 1:
+        raise HTTPException(
+            status_code=422,
+            detail=f"Insufficient data for PS point {ps_id} "
+                   f"(need >{SEQ_LEN + HORIZON} epochs, got {len(ps_clean)})",
+        )
+
+    days_all = ps_raw["days_since_start"].values
+    disp_all = ps_raw["cumulative_disp_mm"].values
+
+    feats = ps_clean[FEATURE_COLS].values.astype(np.float32)
+    physics = ps_clean[PHYSICS_COLS].values.astype(np.float32)
+
+    threshold = cfg["best_threshold"]
+    epoch_forecasts = []
+
+    for i in range(SEQ_LEN, len(ps_clean) - HORIZON):
+        x_seq = torch.tensor(feats[i - SEQ_LEN:i]).unsqueeze(0).to(DEVICE)
+        p_vec = torch.tensor(physics[i]).unsqueeze(0).to(DEVICE)
+
+        preds = []
+        for _ in range(N_PASSES):
+            with torch.no_grad():
+                preds.append(torch.sigmoid(model(x_seq, p_vec)).item())
+
+        fcst_idx = i + HORIZON
+        mean_p = float(np.mean(preds))
+        std_p = float(np.std(preds))
+        high_risk = mean_p >= threshold
+
+        epoch_forecasts.append(
+            EpochForecast(
+                day=float(days_all[fcst_idx]),
+                failure_probability=round(mean_p, 6),
+                uncertainty_std=round(std_p, 6),
+                high_risk=high_risk,
+            )
+        )
+
+    # Aggregate stats
+    forecast_days = np.array([e.day for e in epoch_forecasts])
+    forecast_mean = np.array([e.failure_probability for e in epoch_forecasts])
+    forecast_std = np.array([e.uncertainty_std for e in epoch_forecasts])
+    forecast_risk = np.array([e.high_risk for e in epoch_forecasts])
+
+    n_risk = int(forecast_risk.sum())
+    first_alarm = (
+        float(forecast_days[forecast_risk == 1][0]) if n_risk > 0 else None
+    )
+
+    return ForecastResponse(
+        ps_id=ps_id,
+        actual_lat=float(actual_lat),
+        actual_lon=float(actual_lon),
+        total_epochs=len(ps_raw),
+        forecast_count=len(epoch_forecasts),
+        high_risk_count=n_risk,
+        high_risk_pct=round(n_risk / len(epoch_forecasts) * 100, 2),
+        mean_failure_probability=round(float(forecast_mean.mean()), 6),
+        mean_uncertainty=round(float(forecast_std.mean()), 6),
+        first_alarm_day=first_alarm,
+        threshold_used=threshold,
+        model_auc=cfg["test_auc"],
+        model_pr_auc=cfg["test_pr_auc"],
+        forecasts=epoch_forecasts,
+    )
+
+
+# ── Health check ───────────────────────────────────────────────────────────────
+@app.get("/health")
+def health():
+    return {"status": "ok", "device": str(DEVICE)}
+
+
+# ── Run locally ────────────────x────────────────────────────────────────────────
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run("main:app", host="0.0.0.0", port=8000, reload=False)

model_config.json

@@ -0,0 +1,36 @@
+{
+  "n_features": 14,
+  "n_physics": 3,
+  "hidden": 32,
+  "n_heads": 2,
+  "dropout": 0.4,
+  "seq_len": 8,
+  "horizon": 2,
+  "feature_cols": [
+    "lat",
+    "lon",
+    "cumulative_disp_mm",
+    "incremental_disp_mm",
+    "velocity_last_3ep",
+    "velocity_last_6ep",
+    "disp_rolling_mean_3",
+    "disp_rolling_mean_6",
+    "disp_rolling_std_6",
+    "coherence",
+    "mean_velocity_mm_yr",
+    "dem_height_m",
+    "seasonal_sin",
+    "seasonal_cos"
+  ],
+  "physics_cols": [
+    "acceleration",
+    "velocity_last_3ep",
+    "dem_height_m"
+  ],
+  "best_threshold": 0.5551024079322815,
+  "best_val_auc": 0.8073059156530157,
+  "test_auc": 0.8027481911831947,
+  "test_pr_auc": 0.2522120332201386,
+  "pos_weight": 11.660771704180064,
+  "stopped_epoch": 36
+}

pinn_best.pt

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

requirements.txt

@@ -0,0 +1,8 @@
+fastapi
+uvicorn
+pydantic
+numpy
+pandas
+torch
+scikit-learn
+pyarrow

scaler.pkl

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