Upload 10 files

README.md

@@ -0,0 +1,277 @@
+````markdown
+---
+library_name: transformers
+
+tags:
+- transformers
+- agriculture
+- crop-yield
+- yield-prediction
+- weather
+- soil
+- regression
+- time-series
+---
+
+# Yield Estimation Transformer
+
+A Hugging Face Transformers model for crop yield prediction using weather time-series and soil properties.
+
+This repository contains a pretrained transformer model packaged for inference through the Hugging Face Transformers API and a custom Hugging Face Pipeline. The pipeline automatically performs preprocessing, feature normalization, model inference, and returns the predicted crop yield from daily weather observations and static soil properties.
+
+---
+
+# Features
+
+- Transformer-based crop yield prediction
+- Weather time-series and static soil feature integration
+- Automatic preprocessing and normalization
+- Daily weather input support
+- Hugging Face AutoClass compatible
+- Custom Hugging Face Pipeline
+- CPU and GPU inference
+
+---
+
+# Quick Start
+
+```python
+import json
+from transformers import pipeline
+
+pipe = pipeline(
+    "yield-estimation",
+    model="Sarikaa-Sridhar/yield-estimation-transformer",
+    trust_remote_code=True,
+)
+
+with open("sample_input_daily.json") as f:
+    sample = json.load(f)
+
+prediction = pipe(sample)
+
+print(prediction)
+````
+
+Example output
+
+```json
+{
+  "predicted_yield": 182.28,
+  "cutoff": 4,
+  "effective_cutoff": 4,
+  "crop": "corn",
+  "weather_format": "daily"
+}
+```
+
+---
+
+# Installation
+
+Clone the repository.
+
+```bash
+git clone https://huggingface.co/Sarikaa-Sridhar/yield-estimation-transformer
+cd yield-estimation-transformer
+```
+
+Create a Python environment.
+
+```bash
+conda create -n yield_hf python=3.10
+conda activate yield_hf
+```
+
+Install the required dependencies.
+
+```bash
+pip install -r requirements.txt
+```
+
+---
+
+# Repository Structure
+
+```text
+.
+├── config.json
+├── model.safetensors
+├── configuration_yield.py
+├── modeling_yield.py
+├── pipeline_yield.py
+├── yield_transformer.py
+├── sample_input_daily.json
+├── requirements.txt
+└── README.md
+```
+
+---
+
+# Loading the Model
+
+The model can be loaded directly using the Hugging Face AutoModel interface.
+
+```python
+from transformers import AutoModel
+
+model = AutoModel.from_pretrained(
+    "Sarikaa-Sridhar/yield-estimation-transformer",
+    trust_remote_code=True,
+)
+```
+
+For most users, the recommended interface is the custom Hugging Face Pipeline shown in the Quick Start example.
+
+---
+
+# Input Format
+
+The pipeline accepts a single JSON dictionary.
+
+## Required fields
+
+* `crop`
+* `weather`
+* `soil`
+
+## Optional fields
+
+* `cutoff`
+* `weather_format`
+
+---
+
+# Daily Weather Input
+
+The recommended input format is `"daily"`.
+
+Example:
+
+```json
+{
+  "crop": "corn",
+  "weather_format": "daily",
+  "cutoff": 16,
+  "weather": {
+    "dayl": [...],
+    "prcp": [...],
+    "srad": [...],
+    "tmax": [...],
+    "gdd": [...],
+    "tmin": [...],
+    "vp": [...],
+    "tmean": [...],
+    "precip_3day_avg_perday": [...],
+    "precip_7day_avg_perday": [...],
+    "precip_14day_avg_perday": [...]
+  },
+  "soil": {
+    "ph": 6.5,
+    "om": 3.2,
+    "cec": 15.0,
+    "awc": 0.18,
+    "clay": 25.0,
+    "p_ppm": 30.0,
+    "k_ppm": 150.0,
+    "mg_ppm": 220.0,
+    "ca_ppm": 1800.0,
+    "k_te": 3.0,
+    "mg_te": 12.0,
+    "ca_te": 70.0,
+    "s_ppm": 15.0,
+    "zn_ppm": 1.2,
+    "fe_ppm": 50.0,
+    "mn_ppm": 20.0,
+    "cu_ppm": 0.8,
+    "b_ppm": 0.5,
+    "na_ppm": 10.0,
+    "sand": 40.0,
+    "silt": 35.0,
+    "bd": 1.3,
+    "elevation": 280.0,
+    "slope": 2.0
+  }
+}
+```
+
+The pipeline automatically:
+
+* converts daily weather observations into the feature representation expected by the model
+* applies the normalization statistics stored with the model
+* performs inference
+* returns the predicted crop yield
+
+No external preprocessing is required.
+
+---
+
+# Supported Crops
+
+Current supported crop identifiers are:
+
+* `corn`
+* `maize`
+* `soy`
+* `soybean`
+
+---
+
+# Device Support
+
+The pipeline supports both CPU and NVIDIA CUDA GPUs.
+
+GPU inference:
+
+```python
+from transformers import pipeline
+
+pipe = pipeline(
+    "yield-estimation",
+    model="Sarikaa-Sridhar/yield-estimation-transformer",
+    device=0,
+    trust_remote_code=True,
+)
+```
+
+CPU inference:
+
+```python
+from transformers import pipeline
+
+pipe = pipeline(
+    "yield-estimation",
+    model="Sarikaa-Sridhar/yield-estimation-transformer",
+    device=-1,
+    trust_remote_code=True,
+)
+```
+
+---
+
+# Pipeline Output
+
+The pipeline returns a Python dictionary.
+
+Example:
+
+```json
+{
+  "predicted_yield": 182.28,
+  "cutoff": 16,
+  "effective_cutoff": 16,
+  "crop": "corn",
+  "weather_format": "daily"
+}
+```
+
+---
+
+# Acknowledgements
+
+This work was developed as part of the ICICLE AI Institute.
+
+*National Science Foundation (NSF) AI Institute for Intelligent Cyberinfrastructure with Computational Learning in the Environment (ICICLE), Award OAC-2112606.*
+
+```
+```

config.json

@@ -0,0 +1,184 @@
+{
+  "K": 22,
+  "S": 24,
+  "W": 22,
+  "architectures": [
+    "YieldForRegression"
+  ],
+  "crop_emb_dim": 8,
+  "d_model": 64,
+  "dim_ff": 128,
+  "dropout": 0.4,
+  "dtype": "float32",
+  "eval_cutoffs": [
+    8,
+    12,
+    16,
+    22
+  ],
+  "model_type": "yield-weather-soil",
+  "nhead": 4,
+  "num_layers": 4,
+  "pool": "last",
+  "s_mean": [
+    6.847164154052734,
+    3.9301836490631104,
+    15.024548530578613,
+    0.11498195677995682,
+    28.22588348388672,
+    47.32505798339844,
+    165.28575134277344,
+    439.181640625,
+    2344.830322265625,
+    2.625120162963867,
+    21.69441032409668,
+    60.720855712890625,
+    8.925610542297363,
+    2.972254991531372,
+    195.54396057128906,
+    50.68339157104492,
+    3.3951573371887207,
+    1.1097495555877686,
+    11.323736190795898,
+    28.845870971679688,
+    42.91221618652344,
+    1.6110131740570068,
+    3.024193048477173,
+    0.01876676268875599
+  ],
+  "s_std": [
+    0.3154756426811218,
+    1.066802740097046,
+    2.689357280731201,
+    0.02995595894753933,
+    6.459582328796387,
+    12.300628662109375,
+    34.140281677246094,
+    138.90280151367188,
+    493.52239990234375,
+    0.7019332051277161,
+    4.397585868835449,
+    7.440662860870361,
+    1.4173370599746704,
+    2.256568431854248,
+    34.21792221069336,
+    20.011821746826172,
+    1.11983060836792,
+    0.5050033926963806,
+    11.268291473388672,
+    12.573676109313965,
+    7.386580467224121,
+    0.09427518397569656,
+    1.7381932735443115,
+    0.013877413235604763
+  ],
+  "soil_vars": [
+    "ph",
+    "om",
+    "cec",
+    "awc",
+    "clay",
+    "p_ppm",
+    "k_ppm",
+    "mg_ppm",
+    "ca_ppm",
+    "k_te",
+    "mg_te",
+    "ca_te",
+    "s_ppm",
+    "zn_ppm",
+    "fe_ppm",
+    "mn_ppm",
+    "cu_ppm",
+    "b_ppm",
+    "na_ppm",
+    "sand",
+    "silt",
+    "bd",
+    "elevation",
+    "slope"
+  ],
+  "train_cutoffs": [
+    8,
+    12,
+    16,
+    22
+  ],
+  "transformers_version": "5.13.0",
+  "use_crop": true,
+  "w_mean": [
+    49053.73828125,
+    51464.3359375,
+    22.913280487060547,
+    294.0011291503906,
+    362.58697509765625,
+    376.50128173828125,
+    26.46450424194336,
+    26.286815643310547,
+    73.66980743408203,
+    887.6223754882812,
+    14.769508361816406,
+    14.471501350402832,
+    1747.4173583984375,
+    1715.754638671875,
+    20.6231746673584,
+    20.374893188476562,
+    1.1128652095794678,
+    1.2524775266647339,
+    0.47625812888145447,
+    0.5278241634368896,
+    0.23921121656894684,
+    0.2665020227432251
+  ],
+  "w_std": [
+    4406.49951171875,
+    1378.2545166015625,
+    22.44007110595703,
+    155.5632781982422,
+    53.64530563354492,
+    16.995542526245117,
+    3.947380542755127,
+    2.6959431171417236,
+    27.608686447143555,
+    530.9790649414062,
+    4.153758525848389,
+    2.8188235759735107,
+    401.1476745605469,
+    259.7794189453125,
+    3.952458381652832,
+    2.7360341548919678,
+    1.0096169710159302,
+    0.35198140144348145,
+    0.3805038034915924,
+    0.1445319503545761,
+    0.14427466690540314,
+    0.06612387299537659
+  ],
+  "weather_vars": [
+    "dayl",
+    "prcp",
+    "srad",
+    "tmax",
+    "gdd",
+    "tmin",
+    "vp",
+    "tmean",
+    "precip_3day_avg_perday",
+    "precip_7day_avg_perday",
+    "precip_14day_avg_perday"
+  ],
+  "y_mean": 214.7746124267578,
+  "y_std": 32.72690200805664,
+  "auto_map": {
+    "AutoConfig": "configuration_yield.YieldConfig",
+    "AutoModel": "modeling_yield.YieldForRegression"
+  },
+  "custom_pipelines": {
+    "yield-estimation": {
+      "impl": "pipeline_yield.YieldEstimationPipeline",
+      "pt": [
+        "AutoModel"
+      ]
+    }
+  }
+}

configuration_yield.py

@@ -0,0 +1,58 @@
+from transformers import PretrainedConfig
+
+
+class YieldConfig(PretrainedConfig):
+    model_type = "yield-weather-soil"
+
+    def __init__(
+        self,
+        weather_vars=None,
+        soil_vars=None,
+        w_mean=None,
+        w_std=None,
+        s_mean=None,
+        s_std=None,
+        y_mean=None,
+        y_std=None,
+        K=None,
+        W=None,
+        S=None,
+        train_cutoffs=None,
+        eval_cutoffs=None,
+        d_model=128,
+        nhead=4,
+        num_layers=4,
+        dim_ff=256,
+        dropout=0.3,
+        pool="mean",
+        use_crop=True,
+        crop_emb_dim=8,
+        **kwargs,
+    ):
+        super().__init__(**kwargs)
+
+        self.weather_vars = weather_vars
+        self.soil_vars = soil_vars
+
+        self.w_mean = w_mean
+        self.w_std = w_std
+        self.s_mean = s_mean
+        self.s_std = s_std
+        self.y_mean = y_mean
+        self.y_std = y_std
+
+        self.K = K
+        self.W = W
+        self.S = S
+
+        self.train_cutoffs = train_cutoffs
+        self.eval_cutoffs = eval_cutoffs
+
+        self.d_model = d_model
+        self.nhead = nhead
+        self.num_layers = num_layers
+        self.dim_ff = dim_ff
+        self.dropout = dropout
+        self.pool = pool
+        self.use_crop = use_crop
+        self.crop_emb_dim = crop_emb_dim

model.safetensors

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

modeling_yield.py

@@ -0,0 +1,88 @@
+import sys
+from pathlib import Path
+
+PROJECT_ROOT = Path(__file__).resolve().parents[1]
+sys.path.insert(0, str(PROJECT_ROOT))
+
+import torch
+from torch import nn
+from transformers import PreTrainedModel
+from transformers.modeling_outputs import ModelOutput
+from dataclasses import dataclass
+
+from configuration_yield import YieldConfig
+from yield_transformer import YieldTransformer
+
+
+@dataclass
+class YieldModelOutput(ModelOutput):
+    loss: torch.Tensor | None = None
+    logits: torch.Tensor | None = None
+    predictions: torch.Tensor | None = None
+
+
+class YieldForRegression(PreTrainedModel):
+    config_class = YieldConfig
+    base_model_prefix = "yield_model"
+
+    def __init__(self, config: YieldConfig):
+        super().__init__(config)
+
+        self.yield_model = YieldTransformer(
+            w_dim=config.W,
+            soil_dim=config.S,
+            d_model=config.d_model,
+            nhead=config.nhead,
+            num_layers=config.num_layers,
+            dim_ff=config.dim_ff,
+            dropout=config.dropout,
+            use_crop=config.use_crop,
+            crop_emb_dim=config.crop_emb_dim,
+            max_weeks=max(32, config.K),
+            pool=config.pool,
+        )
+
+        self.post_init()
+
+    def forward(
+        self,
+        weather,
+        soil,
+        crop_id,
+        labels=None,
+        horizon_idx=None,
+        causal=True,
+        return_sequence=False,
+        return_dict=True,
+    ):
+        if horizon_idx is None:
+            horizon_idx = weather.shape[1]
+
+        logits = self.yield_model(
+            weather,
+            soil,
+            crop_id,
+            horizon_idx=horizon_idx,
+            causal=causal,
+            return_sequence=return_sequence,
+        )
+
+        y_mean = torch.tensor(self.config.y_mean, device=logits.device, dtype=logits.dtype)
+        y_std = torch.tensor(self.config.y_std, device=logits.device, dtype=logits.dtype)
+
+        #predictions = torch.expm1(logits * y_std + y_mean)
+        predictions = logits * y_std + y_mean
+
+        loss = None
+        if labels is not None:
+            labels_norm = (labels - y_mean) / y_std
+            loss = nn.functional.mse_loss(logits, labels_norm)
+
+        if not return_dict:
+            return (loss, logits, predictions)
+
+        return YieldModelOutput(
+            loss=loss,
+            logits=logits,
+            predictions=predictions,
+        )

pipeline_yield.py

@@ -0,0 +1,278 @@
+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"],
+        }

requirements.txt

@@ -0,0 +1,153 @@
+annotated-types==0.7.0
+anyio==4.11.0
+argon2-cffi==25.1.0
+argon2-cffi-bindings==25.1.0
+arrow==1.4.0
+ase==3.22.1
+asttokens==2.2.1
+async-lru==2.0.5
+attrs==25.4.0
+babel==2.17.0
+backcall==0.2.0
+beautifulsoup4==4.14.2
+bleach==6.3.0
+blosc2==4.3.3
+certifi==2026.6.17
+charset-normalizer==3.4.7
+comm==0.2.3
+contourpy==1.0.7
+cycler==0.11.0
+debugpy==1.8.17
+decorator==5.1.1
+defusedxml==0.7.1
+exceptiongroup==1.3.1
+executing==1.2.0
+fastjsonschema==2.21.2
+filelock==3.29.0
+fonttools==4.39.3
+fqdn==1.5.1
+fsspec==2026.4.0
+googledrivedownloader==0.4
+h11==0.16.0
+h5py==3.8.0
+hf-xet==1.5.1
+httpcore==1.0.9
+httpx==0.28.1
+huggingface-hub==0.32.4
+idna==3.18
+ipdb==0.13.7
+ipykernel==7.1.0
+ipython==8.12.0
+ipywidgets==8.1.8
+isodate==0.6.1
+isoduration==20.11.0
+jedi==0.18.2
+Jinja2==3.1.6
+joblib==1.2.0
+json5==0.12.1
+jsonschema==4.25.1
+jsonschema-specifications==2025.9.1
+jupyter==1.1.1
+jupyter-console==6.6.3
+jupyter-events==0.12.0
+jupyter-lsp==2.3.0
+jupyter_client==8.6.3
+jupyter_core==5.9.1
+jupyter_server==2.17.0
+jupyter_server_terminals==0.5.3
+jupyterlab==4.5.0
+jupyterlab_pygments==0.3.0
+jupyterlab_server==2.28.0
+jupyterlab_widgets==3.0.16
+kiwisolver==1.4.4
+lark==1.3.1
+llvmlite==0.39.1
+MarkupSafe==3.0.3
+matplotlib==3.10.7
+matplotlib-inline==0.1.6
+mistune==3.1.4
+mpmath==1.3.0
+msgpack==1.2.1
+nbclient==0.10.2
+nbconvert==7.16.6
+nbformat==5.10.4
+ndindex==1.10.1
+nest-asyncio==1.6.0
+networkx==3.4.2
+notebook==7.5.0
+notebook_shim==0.2.4
+numba==0.56.4
+numexpr==2.14.1
+numpy==2.2.6
+nvidia-cufile-cu12==1.13.1.3
+nvidia-cusparselt-cu12==0.7.1
+nvidia-nvjitlink-cu12==12.8.93
+nvidia-nvshmem-cu12==3.3.20
+overrides==7.7.0
+packaging==26.0
+pandas==2.3.3
+pandocfilters==1.5.1
+parso==0.8.3
+pexpect==4.8.0
+pickleshare==0.7.5
+pillow==12.0.0
+prometheus_client==0.23.1
+prompt-toolkit==3.0.38
+psutil==7.1.3
+ptyprocess==0.7.0
+pure-eval==0.2.2
+py-cpuinfo==9.0.0
+pydantic==2.13.4
+pydantic_core==2.46.4
+Pygments==2.14.0
+pyparsing==3.0.9
+python-dateutil==2.8.2
+python-json-logger==4.0.0
+python-louvain==0.16
+pytz==2023.3
+PyYAML==6.0.3
+pyzmq==27.1.0
+rdflib==6.3.2
+referencing==0.37.0
+regex==2026.6.28
+requests==2.34.2
+rfc3339-validator==0.1.4
+rfc3986-validator==0.1.1
+rfc3987-syntax==1.1.0
+rpds-py==0.29.0
+safetensors==0.8.0
+scikit-learn==1.7.2
+scipy==1.15.3
+seaborn==0.12.2
+Send2Trash==1.8.3
+six==1.16.0
+sklearn==0.0.post1
+sniffio==1.3.1
+soupsieve==2.8
+stack-data==0.6.2
+sympy==1.14.0
+tables==3.10.1
+terminado==0.18.1
+threadpoolctl==3.1.0
+tinycss2==1.4.0
+tokenizers==0.21.1
+toml==0.10.2
+tomli==2.3.0
+torch==2.12.1+cpu
+torch-geometric==1.7.0
+torchcodec==0.8.1
+torchvision==0.27.1+cpu
+tornado==6.5.2
+tqdm==4.68.3
+traitlets==5.9.0
+transformers==4.48.3
+typing-inspection==0.4.2
+typing_extensions==4.15.0
+tzdata==2025.2
+uri-template==1.3.0
+urllib3==2.7.0
+wcwidth==0.2.6
+webcolors==25.10.0
+webencodings==0.5.1
+websocket-client==1.9.0
+widgetsnbextension==4.0.15

sample_input_daily.json

@@ -0,0 +1,43 @@
+{
+    "crop": "corn",
+    "weather_format": "daily",
+    "weather": {
+      "dayl": [45000,45100,45200,45300,45400,45500,45600,45700,45800,45900,46000,46100,46200,46300,46400,46500,46600,46700,46800,46900,47000,47100,47200,47300,47400,47500,47600,47700],
+      "prcp": [1,0,3,2,0,5,1,0,2,1,4,0,0,3,2,1,0,4,1,0,2,1,0,3,2,1,0,4],
+      "srad": [300,305,310,315,320,325,330,335,340,345,350,355,360,365,370,375,380,385,390,395,400,405,410,415,420,425,430,435],
+      "tmax": [25,26,27,28,29,30,29,28,27,26,28,29,30,31,32,31,30,29,28,27,26,25,26,27,28,29,30,31],
+      "gdd": [10,12,13,14,15,16,15,14,13,12,14,15,16,17,18,17,16,15,14,13,12,11,12,13,14,15,16,17],
+      "tmin": [15,16,16,17,18,19,18,17,16,15,16,17,18,19,20,19,18,17,16,15,14,14,15,16,17,18,19,20],
+      "vp": [1000,1010,1020,1030,1040,1050,1040,1030,1020,1010,1020,1030,1040,1050,1060,1050,1040,1030,1020,1010,1000,995,1000,1010,1020,1030,1040,1050],
+      "tmean": [20,21,21.5,22.5,23.5,24.5,23.5,22.5,21.5,20.5,22,23,24,25,26,25,24,23,22,21,20,19.5,20.5,21.5,22.5,23.5,24.5,25.5],
+      "precip_3day_avg_perday": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
+      "precip_7day_avg_perday": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1],
+      "precip_14day_avg_perday": [1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1,1]
+    },
+    "soil": {
+      "ph": 6.5,
+      "om": 3.2,
+      "cec": 15.0,
+      "awc": 0.18,
+      "clay": 25.0,
+      "p_ppm": 30.0,
+      "k_ppm": 150.0,
+      "mg_ppm": 220.0,
+      "ca_ppm": 1800.0,
+      "k_te": 3.0,
+      "mg_te": 12.0,
+      "ca_te": 70.0,
+      "s_ppm": 15.0,
+      "zn_ppm": 1.2,
+      "fe_ppm": 50.0,
+      "mn_ppm": 20.0,
+      "cu_ppm": 0.8,
+      "b_ppm": 0.5,
+      "na_ppm": 10.0,
+      "sand": 40.0,
+      "silt": 35.0,
+      "bd": 1.3,
+      "elevation": 280.0,
+      "slope": 2.0
+    }
+  }

sample_test.py

@@ -0,0 +1,14 @@
+import json
+from transformers import pipeline
+
+with open(f"sample_input_daily.json", "r") as f:
+    sample = json.load(f)
+
+pipe = pipeline(
+    "yield-estimation",
+    model=".",
+    trust_remote_code=True,
+)
+
+out = pipe(sample)
+print(json.dumps(out, indent=2))

yield_transformer.py

@@ -0,0 +1,159 @@
+import torch
+import torch.nn as nn
+
+
+class MLP(nn.Module):
+    def __init__(self, in_dim: int, out_dim: int, hidden: int = 128, dropout: float = 0.05):
+        super().__init__()
+        self.net = nn.Sequential(
+            nn.Linear(in_dim, hidden//2),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden//2, hidden),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(hidden, out_dim)
+        )
+
+    def forward(self, x):
+        return self.net(x)
+
+class YieldTransformer(nn.Module):
+    def __init__(
+        self,
+        w_dim: int,
+        soil_dim: int,
+        d_model: int = 128,
+        nhead: int = 4,
+        num_layers: int = 2,
+        dim_ff: int = 256,
+        dropout: float = 0.05,
+        use_crop: bool = True,
+        crop_emb_dim: int = 8,
+        max_weeks: int = 32,
+        pool: str = "mean", # Changed default to mean
+        farm_emb_dim: int = 8,
+        horizon_emb_dim: int = 16,
+    ):
+        super().__init__()
+        assert pool in ["last", "cls", "mean"]
+        self.pool = pool
+        self.use_crop = use_crop
+        self.max_weeks = max_weeks
+
+        crop_in = crop_emb_dim if use_crop else 0
+        if use_crop:
+            self.crop_emb = nn.Embedding(2, crop_emb_dim)
+
+        self.horizon_emb = nn.Embedding(max_weeks + 1, horizon_emb_dim)
+        self.horizon_proj = nn.Linear(horizon_emb_dim, d_model)
+
+        self.week_proj = nn.Linear(1, d_model) 
+
+        self.weather_enc = MLP(w_dim + crop_in, d_model, hidden=d_model, dropout=dropout)
+        self.soil_enc = MLP(soil_dim + crop_in, d_model, hidden=d_model, dropout=dropout)
+
+        self.ws_cross_attn = nn.MultiheadAttention(
+            embed_dim=d_model,
+            num_heads=nhead,
+            dropout=dropout,
+            batch_first=True,
+        )
+        self.ws_ln = nn.LayerNorm(d_model)
+
+        self.pos_emb = nn.Parameter(torch.zeros(1, max_weeks + 1, d_model))
+        nn.init.trunc_normal_(self.pos_emb, std=0.02)
+
+        if pool == "cls":
+            self.cls_token = nn.Parameter(torch.zeros(1, 1, d_model))
+            nn.init.trunc_normal_(self.cls_token, std=0.02)
+
+        enc_layer = nn.TransformerEncoderLayer(
+            d_model=d_model, nhead=nhead, dim_feedforward=dim_ff,
+            dropout=dropout, activation="gelu", batch_first=True, norm_first=True,
+        )
+        self.temporal_tf = nn.TransformerEncoder(enc_layer, num_layers=num_layers)
+
+        self.head = nn.Sequential(
+            nn.LayerNorm(d_model + horizon_emb_dim + d_model), 
+            nn.Linear(d_model + horizon_emb_dim + d_model, d_model),
+            nn.GELU(),
+            nn.Dropout(dropout),
+            nn.Linear(d_model, 1),
+        )
+
+    def forward(
+        self,
+        weather,
+        soil,
+        crop_id,
+        farm_field_encoded=None, 
+        week_mask=None,
+        causal=False,
+        return_sequence=False,
+        horizon_idx=None,
+    ):
+        B, t, W = weather.shape
+        device = weather.device
+
+
+        if horizon_idx is None: horizon_idx = torch.tensor(t, device=device).expand(B)
+        if not torch.is_tensor(horizon_idx): horizon_idx = torch.tensor(horizon_idx, device=device).expand(B)
+        
+        h_idx = horizon_idx.long().clamp(min=1, max=self.max_weeks)
+        h_emb = self.horizon_emb(h_idx)
+        h_tok = self.horizon_proj(h_emb) 
+
+        if self.use_crop:
+            c = self.crop_emb(crop_id)
+            weather_in = torch.cat([weather, c[:, None, :].expand(-1, t, -1)], dim=-1)
+            soil_in = torch.cat([soil, c], dim=-1)
+        else:
+            weather_in, soil_in = weather, soil
+
+        w_tok = self.weather_enc(weather_in)
+        s_encoded = self.soil_enc(soil_in) 
+
+        fused = self.ws_ln(w_tok + s_encoded[:, None, :])
+        fused = fused + h_tok[:, None, :] 
+
+        weeks = torch.arange(1, t + 1, device=device).float() / self.max_weeks
+        week_signal = self.week_proj(weeks[None, :, None].expand(B, -1, -1))
+        
+        x = fused + week_signal + self.pos_emb[:, :t, :]
+        
+        if self.pool == "cls":
+            x = torch.cat([self.cls_token.expand(B, -1, -1), x], dim=1)
+            t_idx = t + 1
+        else: t_idx = t
+
+        src_key_padding_mask = ~week_mask.bool() if week_mask is not None else None
+
+        attn_mask = None
+        if causal:
+            L = x.size(1)
+            attn_mask = torch.triu(
+                torch.ones(L, L, device=device, dtype=torch.bool),
+                diagonal=1,
+            )
+
+        h = self.temporal_tf(
+            x,
+            mask=attn_mask,
+            src_key_padding_mask=src_key_padding_mask,
+        )
+
+        if self.pool == "mean":
+            if week_mask is not None:
+                mask = week_mask.unsqueeze(-1).float()
+                pooled = (h * mask).sum(dim=1) / mask.sum(dim=1).clamp(min=1e-9)
+            else:
+                pooled = h.mean(dim=1)
+        elif self.pool == "cls":
+            pooled = h[:, 0, :]
+        else: 
+            pooled = h[:, -1, :]
+
+        out = torch.cat([pooled, h_emb, s_encoded], dim=-1)
+        return self.head(out).squeeze(-1)
+