gdfgdfgdfgfg

call_models.py

@@ -7,6 +7,7 @@ import numpy as np
 
 from predict_from_supabase import predict_replacements
 from model import DegradationModel, COMPONENT_NAMES
+from process_inputs import process_inputs
 
 load_dotenv()
 
@@ -44,7 +45,7 @@ def predict():
         return jsonify({"error": f"model file not found: {model_path}"}), 404
 
     h0 = np.array(h0_raw, dtype=float)
-    X  = np.array(X_raw,  dtype=float)
+    X  = process_inputs(np.array(X_raw, dtype=float))
 
     if h0.shape != (model.N,):
         return jsonify({"error": f"h0 must have {model.N} elements, got {h0.shape}"}), 400

predict_from_supabase.py

@@ -10,27 +10,24 @@ from supabase import create_client
 from stable_baselines3 import PPO
 from model import DegradationModel
 from scheduling_rl import _ACTION_TABLE, COMPONENT_NAMES
+from process_inputs import process_inputs
 
 # ---------------------------------------------------------------------------
 # Supabase client
 # ---------------------------------------------------------------------------
 
-_sb = None
+_sb = create_client(os.environ["SUPABASE_URL"], os.environ["SUPABASE_KEY"])
 
-def _get_sb():
-    global _sb
-    if _sb is None:
-        _sb = create_client(os.environ["SUPABASE_URL"], os.environ["SUPABASE_SERVICE_KEY"])
-    return _sb
-
-# Column order must match the obs vector expected by the PPO (C=7 conditions)
+# Column order must match INPUT_NAMES in model.py (C=9, obs vector is R^20)
 _CONDITION_COLS = [
     "ambient_temperature_c",
     "build_chamber_temp_c",
     "ambient_humidity_pct",
     "powder_contamination_level",
+    "print_hours",
     "build_volume_cm3",
     "recoating_speed_mm_s",
+    "recoating_cycles",
     "maintenance_level",
 ]
 
@@ -47,48 +44,48 @@ _HEALTH_COLS = [
 ]
 
 # ---------------------------------------------------------------------------
-# Fetch helpers
+# Helpers
 # ---------------------------------------------------------------------------
 
-def _fetch_health(printer_id: str, t: datetime) -> np.ndarray:
-    """Snapshot whose time_step_id matches hours elapsed since last_repair."""
-    sb = _get_sb()
-    printer = (
-        sb.table("printers")
-        .select("last_repair")
-        .eq("id", printer_id)
-        .single()
-        .execute()
-        .data
-    )
-    if not printer:
-        raise ValueError(f"Printer {printer_id} not found")
+def _as_aware(dt: datetime) -> datetime:
+    """Return a timezone-aware datetime, treating naive datetimes as UTC."""
+    if dt.tzinfo is None:
+        return dt.replace(tzinfo=timezone.utc)
+    return dt
 
-    last_repair = datetime.fromisoformat(printer["last_repair"]).replace(tzinfo=timezone.utc)
-    time_step_id = int((t - last_repair).total_seconds() // 3600)
 
+def _parse_ts(s: str) -> datetime:
+    """Parse an ISO timestamp string that may use a trailing Z."""
+    return _as_aware(datetime.fromisoformat(s.replace("Z", "+00:00")))
+
+
+# ---------------------------------------------------------------------------
+# Fetch helpers
+# ---------------------------------------------------------------------------
+
+def _fetch_health(printer_id: str) -> np.ndarray:
+    """Latest health snapshot for the printer."""
     row = (
-        sb.table("snapshots")
+        _sb.table("snapshots")
         .select(", ".join(_HEALTH_COLS))
         .eq("id", printer_id)
-        .gte("time_step_id", time_step_id)
-        .order("time_step_id", desc=False)
+        .order("time_step_id", desc=True)
         .limit(1)
         .execute()
         .data
     )
     if not row:
-        raise ValueError(f"No snapshot for printer {printer_id} at time_step_id={time_step_id} (t={t})")
+        raise ValueError(f"No snapshot found for printer {printer_id}")
     return np.array([row[0][c] for c in _HEALTH_COLS], dtype=np.float64)
 
 
 def _fetch_conditions(printer_id: str, t: datetime) -> np.ndarray:
     """Closest conditions row at or before t."""
     row = (
-        _get_sb().table("conditions")
+        _sb.table("conditions")
         .select(", ".join(_CONDITION_COLS))
         .eq("id", printer_id)
-        .lte("timestamp", t.isoformat())
+        .lte("timestamp", _as_aware(t).isoformat())
         .order("timestamp", desc=True)
         .limit(1)
         .execute()
@@ -96,7 +93,8 @@ def _fetch_conditions(printer_id: str, t: datetime) -> np.ndarray:
     )
     if not row:
         raise ValueError(f"No conditions found for printer {printer_id} at {t}")
-    return np.array([row[0][c] for c in _CONDITION_COLS], dtype=np.float64)
+    # Coerce NULL columns to 0.0 (seed_data.py may omit some fields)
+    return np.array([float(row[0][c] or 0.0) for c in _CONDITION_COLS], dtype=np.float64)
 
 # ---------------------------------------------------------------------------
 # Main prediction
@@ -115,8 +113,8 @@ def predict_replacements(
     DegradationModel.load(model_path)   # validates model exists
     ppo = PPO.load(ppo_path)
 
-    health = _fetch_health(printer_id, t)
-    X_t    = _fetch_conditions(printer_id, t)
+    health = _fetch_health(printer_id)
+    X_t    = process_inputs(_fetch_conditions(printer_id, t))
 
     obs = np.concatenate([health, X_t, [budget_remaining / W], [t_hours]]).astype(np.float32)
     action, _ = ppo.predict(obs, deterministic=True)
@@ -125,7 +123,7 @@ def predict_replacements(
     to_replace = [COMPONENT_NAMES[i] for i, b in enumerate(bits) if b]
     return {
         "printer_id":    printer_id,
-        "timestamp":     t.isoformat(),
+        "timestamp":     _as_aware(t).isoformat(),
         "health":        dict(zip(COMPONENT_NAMES, health.tolist())),
         "conditions":    dict(zip(_CONDITION_COLS, X_t.tolist())),
         "replace":       to_replace,
@@ -140,7 +138,7 @@ def predict_replacements(
 if __name__ == "__main__":
     import json, sys
     printer_id = sys.argv[1] if len(sys.argv) > 1 else "printer_001"
-    t = datetime.fromisoformat(sys.argv[2]) if len(sys.argv) > 2 else datetime.now()
+    t = _parse_ts(sys.argv[2]) if len(sys.argv) > 2 else datetime.now(tz=timezone.utc)
     budget = float(sys.argv[3]) if len(sys.argv) > 3 else 10_000.0
 
     result = predict_replacements(printer_id, t, budget_remaining=budget)

process_inputs.py

@@ -0,0 +1,54 @@
+import numpy as np
+
+
+def process_inputs(X: np.ndarray) -> np.ndarray:
+    """Convert inputs from natural units to normalized model inputs.
+
+    Index | Name                  | Natural unit | Notes
+    ------|-----------------------|--------------|--------------------------------
+    0     | ambient_temperature_c | °C           | Kelvin ratio — never 0
+    1     | build_chamber_temp_c  | °C           | Kelvin ratio — never 0
+    2     | ambient_humidity_pct  | %            | floor 0.25 — dry air still allows degradation
+    3     | powder_contamination  | AQI [0–500]  | floor 0.15 — even clean air causes wear
+    4     | print_hours           | h            | 0 → 0 (machine not running)
+    5     | build_volume_cm3      | cm³          | 0 → 0 (no active build)
+    6     | recoating_speed_mm_s  | mm/s         | 0 → 0 (recoater stationary)
+    7     | recoating_cycles      | count        | 0 → 0 (no recoating done)
+    8     | maintenance_level     | [0, 1]       | floor 0.2 — even perfect maintenance
+          |                       |              | cannot eliminate physical wear
+
+    The model uses P = ∏ I_c; only a 0 output produces P = 0 (no degradation).
+    Inputs whose zero value merely means "minimal stress" (temperatures, humidity,
+    contamination, maintenance) carry a non-zero floor so they never falsely gate
+    off all degradation.  Inputs that are truly "off" when zero (machine not
+    running, recoater stationary) map 0 → 0.
+
+    All outputs are non-negative.  The mapping is linear throughout.
+    """
+    X = np.asarray(X, dtype=float)
+    out = np.empty(9)
+
+    # --- Temperatures: T_K / T_ref (Kelvin ratio, never 0 above absolute zero) ---
+    # Reference points chosen so the maximum expected operating temperature ≈ 1.0.
+    # Ambient reference: 70 °C = 343.15 K  (factory floor upper bound)
+    # Chamber reference: 350 °C = 623.15 K (upper bound for powder-bed processes)
+    out[0] = (np.maximum(X[0], -273.15) + 273.15) / 343.15
+    out[1] = (np.maximum(X[1], -273.15) + 273.15) / 623.15
+
+    # --- Humidity: non-zero floor, linear ---
+    # floor=0.25 at 0 %, reaching 1.0 at 100 %.
+    out[2] = 0.25 + 0.75 * np.clip(X[2], 0.0, 100.0) / 100.0
+
+    # --- Powder contamination (AQI 0–500): non-zero floor, linear ---
+    # floor=0.15 at AQI=0; reaches 1.0 at AQI=500.
+    out[3] = 0.15 + 0.85 * np.clip(X[3], 0.0, 500.0) / 500.0
+    out[4] = np.clip(X[4], 0.0, 168.0)   / 168.0    # print hours  (max 168 h/week)
+    out[5] = np.clip(X[5], 0.0, 15000.0) / 15000.0  # build volume (max 15 000 cm³/week)
+    out[6] = np.clip(X[6], 0.0, 150.0)   / 150.0    # recoating speed (max 150 mm/s)
+    out[7] = np.clip(X[7], 0.0, 15000.0) / 15000.0  # recoating cycles (max 15 000/week)
+
+    # --- Maintenance: non-zero floor, linear ---
+    # level=0 (perfect) → 0.2 baseline; level=1 (no maintenance) → 1.0.
+    out[8] = 0.2 + 0.8 * np.clip(X[8], 0.0, 1.0)
+
+    return np.maximum(out, 0.0)  # guarantee non-negative

scheduling_rl.py

@@ -477,17 +477,32 @@ def evaluate(
 # ---------------------------------------------------------------------------
 
 if __name__ == "__main__":
-
-    N, C = 9, 9
-    lambda_rates = np.array([0.05, 0.10, 0.02, 0.03, 0.01, 0.08, 0.06, 0.04, 0.03])
-
-    deg_model = DegradationModel(
-        N=N, C=C, lambda_rates=lambda_rates, seed=0
-    )
-
-    # Synthetic X_series: 8 000 hours of operating conditions drawn from [0, 1]
+    from process_inputs import process_inputs
+
+    deg_model = DegradationModel.load("model.npz")
+    print(f"Loaded model.npz  N={deg_model.N}  C={deg_model.C}")
+
+    # Representative operating-condition scenarios in natural units (matches phase2.py SCENARIOS).
+    # Each row: [ambient_temp_c, chamber_temp_c, humidity_pct, contamination_aqi,
+    #            print_hours, build_volume_cm3, recoating_speed_mm_s, recoating_cycles, maintenance_level]
+    _SCENARIO_CONDITIONS = np.array([
+        [ 22.0, 180.0, 40.0,   20.0,  56.0,  4500.0, 100.0,  5000.0, 0.10],  # nominal
+        [ 22.0, 180.0, 45.0,  150.0,  56.0,  4500.0, 100.0,  5000.0, 0.20],  # high contamination
+        [ 28.0, 185.0, 50.0,   80.0, 168.0, 13500.0, 120.0, 15000.0, 0.20],  # 24/7 heavy use
+        [ 20.0, 175.0, 30.0,    5.0, 300.0,  3000.0,  90.0,  3500.0, 0.05],  # optimal lab
+        [ 40.0, 200.0, 55.0,   60.0,  56.0,  4500.0, 100.0,  5000.0, 0.20],  # hot environment
+        [ 22.0, 180.0, 85.0,   30.0,  56.0,  4500.0, 100.0,  5000.0, 0.15],  # high humidity
+        [ 25.0, 182.0, 45.0,   40.0,  56.0,  4500.0, 100.0,  5000.0, 0.90],  # neglected maintenance
+        [ 38.0, 195.0, 20.0,  200.0,  80.0,  6500.0, 110.0,  7000.0, 0.40],  # desert factory
+    ], dtype=np.float64)
+
+    # Build an 8 000-step X_series by cycling through scenarios with small noise
     rng = np.random.default_rng(42)
-    #X_series = rng.uniform(0.0, 1.0, size=(8_000, C))
+    T = 8_000
+    base_rows = _SCENARIO_CONDITIONS[np.arange(T) % len(_SCENARIO_CONDITIONS)]
+    noise = rng.normal(0.0, 0.02, size=base_rows.shape) * base_rows  # 2% relative noise
+    X_natural = np.clip(base_rows + noise, 0.0, None)
+    X_series = np.stack([process_inputs(row) for row in X_natural])  # (T, C) normalised
 
     env = PrinterEnv(
         model=deg_model,