Delete pipeline_yield.py

pipeline_yield.py

@@ -1,278 +0,0 @@
-import sys
-from pathlib import Path
-
-PROJECT_ROOT = Path(__file__).resolve().parents[1]
-if str(PROJECT_ROOT) not in sys.path:
-    sys.path.insert(0, str(PROJECT_ROOT))
-
-import numpy as np
-import torch
-from transformers import Pipeline
-import math 
-
-DEFAULT_WEATHER_AGG_RULES = {
-    "dayl": "mean",
-    "prcp": "sum",
-    "srad": "mean",
-    "tmax": "mean",
-    "tmin": "mean",
-    "vp": "mean",
-    "tmean": "mean",
-    "gdd": "sum",
-    "precip_3day_avg_perday": "mean",
-    "precip_7day_avg_perday": "mean",
-    "precip_14day_avg_perday": "mean",
-}
-
-def daily_to_cumulative_weekly(
-    daily: np.ndarray,
-    agg: str,
-    week_len: int = 7,
-) -> np.ndarray:
-    daily = daily.astype(np.float32)
-    T = daily.shape[0]
-    K = int(math.ceil(T / week_len))
-
-    weekly = np.zeros(K, dtype=np.float32)
-    cumulative = np.zeros(K, dtype=np.float32)
-
-    for w in range(K):
-        s = w * week_len
-        e = min((w + 1) * week_len, T)
-
-        week_chunk = daily[s:e]
-        cumulative_chunk = daily[:e]
-
-        if agg == "sum":
-            weekly[w] = np.nansum(week_chunk)
-            cumulative[w] = np.nansum(cumulative_chunk)
-        else:
-            weekly[w] = np.nanmean(week_chunk)
-            cumulative[w] = np.nanmean(cumulative_chunk)
-
-    return np.stack([weekly, cumulative], axis=1).astype(np.float32)
-
-class YieldEstimationPipeline(Pipeline):
-    """
-    Pipeline API for yield prediction using weather + soil inputs.
-
-    Supports:
-    - old models: one feature per weather variable, W = len(weather_vars)
-    - new models: weekly + cumulative per weather variable, W = 2 * len(weather_vars)
-    """
-
-    def _sanitize_parameters(self, cutoff=None, weather_format=None, **kwargs):
-        preprocess_kwargs = {}
-
-        if cutoff is not None:
-            preprocess_kwargs["cutoff"] = cutoff
-
-        if weather_format is not None:
-            preprocess_kwargs["weather_format"] = weather_format
-
-        return preprocess_kwargs, {}, {}
-
-    def preprocess(self, inputs, cutoff=None, weather_format=None):
-        cfg = self.model.config
-
-        if not isinstance(inputs, dict):
-            raise ValueError("Input must be a dictionary.")
-
-        if "weather" not in inputs:
-            raise ValueError("Input must contain a 'weather' dictionary.")
-
-        if "soil" not in inputs:
-            raise ValueError("Input must contain a 'soil' dictionary.")
-
-        requested_cutoff = inputs.get("cutoff", cutoff)
-        weather_format = inputs.get(
-            "weather_format",
-            weather_format if weather_format is not None else "weekly_cumulative",
-        )
-
-        n_weather_vars = len(cfg.weather_vars)
-        model_w_dim = int(cfg.W)
-
-        use_weekly_and_cumulative = model_w_dim == 2 * n_weather_vars
-        use_cumulative_only = model_w_dim == n_weather_vars
-
-        if not (use_weekly_and_cumulative or use_cumulative_only):
-            raise ValueError(
-                f"Unsupported weather dimension. Model has W={model_w_dim}, "
-                f"but len(weather_vars)={n_weather_vars}. Expected W={n_weather_vars} "
-                f"or W={2 * n_weather_vars}."
-            )
-
-        weather_cols = []
-
-        for v in cfg.weather_vars:
-            if v not in inputs["weather"]:
-                raise ValueError(f"Missing weather variable: {v}")
-
-            arr = np.asarray(inputs["weather"][v], dtype=np.float32)
-
-            if weather_format == "daily":
-                agg = DEFAULT_WEATHER_AGG_RULES.get(v, "mean")
-                arr = daily_to_cumulative_weekly(arr, agg=agg, week_len=7)
-
-                if arr.ndim != 2 or arr.shape[1] != 2:
-                    raise ValueError(
-                        f"daily_to_cumulative_weekly for '{v}' should return shape [K, 2], "
-                        f"but got {arr.shape}."
-                    )
-
-                if use_weekly_and_cumulative:
-                    weather_cols.append(arr[:, 0])  # weekly
-                    weather_cols.append(arr[:, 1])  # cumulative
-                else:
-                    weather_cols.append(arr[:, 1])  # cumulative only
-
-            elif weather_format == "weekly_cumulative":
-                arr = np.asarray(arr, dtype=np.float32)
-
-                if use_cumulative_only:
-                    if arr.ndim != 1:
-                        raise ValueError(
-                            f"For W={model_w_dim}, weather variable '{v}' must be 1D, "
-                            f"but got shape {arr.shape}."
-                        )
-                    weather_cols.append(arr)
-
-                else:
-                    # For W=22 models, weekly_cumulative input must provide either:
-                    # 1. a [K, 2] array for each variable, or
-                    # 2. separate keys: var_weekly and var_cumulative.
-                    if arr.ndim == 2 and arr.shape[1] == 2:
-                        weather_cols.append(arr[:, 0])
-                        weather_cols.append(arr[:, 1])
-                    else:
-                        weekly_key = f"{v}_weekly"
-                        cumulative_key = f"{v}_cumulative"
-
-                        if weekly_key not in inputs["weather"] or cumulative_key not in inputs["weather"]:
-                            raise ValueError(
-                                f"Model expects weekly + cumulative features for '{v}'. "
-                                f"For weather_format='weekly_cumulative', provide either "
-                                f"weather['{v}'] as shape [K, 2], or provide "
-                                f"weather['{weekly_key}'] and weather['{cumulative_key}']."
-                            )
-
-                        weekly = np.asarray(inputs["weather"][weekly_key], dtype=np.float32)
-                        cumulative = np.asarray(inputs["weather"][cumulative_key], dtype=np.float32)
-
-                        if weekly.ndim != 1 or cumulative.ndim != 1:
-                            raise ValueError(
-                                f"{weekly_key} and {cumulative_key} must both be 1D."
-                            )
-
-                        weather_cols.append(weekly)
-                        weather_cols.append(cumulative)
-
-            else:
-                raise ValueError(
-                    "weather_format must be either 'daily' or 'weekly_cumulative'."
-                )
-
-        lengths = [len(x) for x in weather_cols]
-        if len(set(lengths)) != 1:
-            raise ValueError(
-                f"Weather variable lengths do not match after preprocessing: {lengths}"
-            )
-
-        weather = np.stack(weather_cols, axis=1).astype(np.float32)
-
-        if requested_cutoff is None:
-            cutoff = weather.shape[0]
-        else:
-            cutoff = int(requested_cutoff)
-
-        t_eff = min(cutoff, weather.shape[0])
-
-        if weather.shape[1] != model_w_dim:
-            raise ValueError(
-                f"Processed weather has shape {weather.shape}, but model expects W={model_w_dim}."
-            )
-
-        soil = []
-        for v in cfg.soil_vars:
-            if v not in inputs["soil"]:
-                raise ValueError(f"Missing soil variable: {v}")
-            soil.append(float(inputs["soil"][v]))
-
-        soil = np.asarray(soil, dtype=np.float32)
-
-        w_mean = np.asarray(cfg.w_mean, dtype=np.float32)
-        w_std = np.asarray(cfg.w_std, dtype=np.float32)
-        s_mean = np.asarray(cfg.s_mean, dtype=np.float32)
-        s_std = np.asarray(cfg.s_std, dtype=np.float32)
-
-        if len(w_mean) != weather.shape[1]:
-            raise ValueError(
-                f"Normalization mismatch: len(w_mean)={len(w_mean)}, "
-                f"but weather feature dimension={weather.shape[1]}."
-            )
-
-        weather = np.where(np.isnan(weather), w_mean[None, :], weather)
-        weather = (weather - w_mean[None, :]) / w_std[None, :]
-
-        soil = np.where(np.isnan(soil), s_mean, soil)
-        soil = (soil - s_mean) / s_std
-
-        crop_map = {
-            "corn": 0,
-            "maize": 0,
-            "soybean": 1,
-            "soy": 1,
-        }
-
-        crop = str(inputs.get("crop", "corn")).strip().lower()
-        crop_id = crop_map.get(crop, 0)
-
-        return {
-            "weather": torch.from_numpy(weather[:t_eff]).unsqueeze(0),
-            "soil": torch.from_numpy(soil).unsqueeze(0),
-            "crop_id": torch.tensor([crop_id], dtype=torch.long),
-            "horizon_idx": t_eff,
-            "cutoff": cutoff,
-            "effective_cutoff": t_eff,
-            "crop": crop,
-            "weather_format": weather_format,
-            "weather_shape": list(weather[:t_eff].shape),
-        }
-
-    def _forward(self, model_inputs):
-        cutoff = model_inputs.pop("cutoff")
-        effective_cutoff = model_inputs.pop("effective_cutoff")
-        crop = model_inputs.pop("crop")
-        weather_format = model_inputs.pop("weather_format")
-        weather_shape = model_inputs.pop("weather_shape")
-
-        outputs = self.model(
-            weather=model_inputs["weather"],
-            soil=model_inputs["soil"],
-            crop_id=model_inputs["crop_id"],
-            horizon_idx=model_inputs["horizon_idx"],
-            causal=True,
-            return_sequence=False,
-        )
-
-        return {
-            "outputs": outputs,
-            "cutoff": cutoff,
-            "effective_cutoff": effective_cutoff,
-            "crop": crop,
-            "weather_format": weather_format,
-            "weather_shape": weather_shape,
-        }
-
-    def postprocess(self, model_outputs):
-        pred = float(model_outputs["outputs"].predictions.detach().cpu().item())
-
-        return {
-            "predicted_yield": pred,
-            "cutoff": int(model_outputs["cutoff"]),
-            "effective_cutoff": int(model_outputs["effective_cutoff"]),
-            "crop": model_outputs["crop"],
-            "weather_format": model_outputs["weather_format"],
-            "weather_shape": model_outputs["weather_shape"],
-        }