From a362c2a1a638288cfcdcf51be39de6b4ec07cf0c Mon Sep 17 00:00:00 2001 From: SarahAlidoost Date: Wed, 18 Mar 2026 16:36:57 +0100 Subject: [PATCH 1/3] add model config --- climanet/st_encoder_decoder.py | 5 ++++- 1 file changed, 4 insertions(+), 1 deletion(-) diff --git a/climanet/st_encoder_decoder.py b/climanet/st_encoder_decoder.py index 7df74ad..e09171c 100644 --- a/climanet/st_encoder_decoder.py +++ b/climanet/st_encoder_decoder.py @@ -528,6 +528,10 @@ def __init__( spatial_heads: Number of attention heads in the spatial Transformer """ super().__init__() + + # Store arguments to be used later for model saving/loading + self.config = {k: v for k, v in locals().items() if k not in ('self', '__class__')} + self.encoder = VideoEncoder( in_chans=in_chans, embed_dim=embed_dim, patch_size=patch_size ) @@ -568,7 +572,6 @@ def forward(self, daily_data, daily_mask, land_mask_patch, padded_days_mask=None Tp = T // self.patch_size[0] Hp = H // self.patch_size[1] Wp = W // self.patch_size[2] - Np = Tp * Hp * Wp # check shape and patch compatibility assert daily_mask.shape == daily_data.shape, ( From 710a4d9ee331f68f60949d060efc816d3f3f5ff3 Mon Sep 17 00:00:00 2001 From: SarahAlidoost Date: Wed, 18 Mar 2026 16:37:40 +0100 Subject: [PATCH 2/3] add a util function for training --- climanet/utils.py | 149 ++++++++++++++++++++++++++++++++++++++++++++++ pyproject.toml | 1 + 2 files changed, 150 insertions(+) diff --git a/climanet/utils.py b/climanet/utils.py index aa6cebf..1c4df6b 100644 --- a/climanet/utils.py +++ b/climanet/utils.py @@ -1,8 +1,12 @@ +from pathlib import Path from typing import Tuple import numpy as np +from torch.utils.data import Dataset import xarray as xr import torch +from torch.utils.data import DataLoader +from torch.utils.tensorboard import SummaryWriter def regrid_to_boundary_centered_grid( da: xr.DataArray, @@ -150,3 +154,148 @@ def pred_to_numpy(pred, orig_H=None, orig_W=None, land_mask=None): pred = torch.where(land_mask, torch.full_like(pred, float("nan")), pred) return pred.detach().cpu().numpy() + + +def calc_stats(data: xr.DataArray, time_unit="MS", spatial_dims=("lat", "lon")): + averaged = data.resample(time=time_unit).mean(skipna=True) + mean = averaged.mean(dim=spatial_dims, skipna=True).values + std = averaged.std(dim=spatial_dims, skipna=True).values + return mean, std + + +def train_monthly_model( + model: torch.nn.Module, + dataset: Dataset, + decoder_stats: Tuple[np.ndarray, np.ndarray], + batch_size=2, + num_epoch=100, + patience=10, + accumulation_steps=1, + optimizer_lr=1e-3, + log_dir=".", + save_model=True, + device="cpu", + verbose=True + ): + """ Train the model to predict monthly data from daily data. + Args: + model: the PyTorch model to train + dataset: Dataset object containing the training data + decoder_stats: Tuple of (mean, std) for the decoder + batch_size: number of samples per batch + num_epoch: number of epochs to train + patience: number of epochs to wait for improvement before early stopping + accumulation_steps: number of batches to accumulate gradients over before updating weights + optimizer_lr: learning rate for the optimizer + log_dir: directory to save logs + save_model: whether to save the best model to disk + device: device to run training on ("cpu" or "cuda") + verbose: whether to print training progress + """ + + # Initialize the model + model = model.to(device) + mean, std = decoder_stats + decoder = model.decoder + with torch.no_grad(): + decoder.bias.copy_(torch.from_numpy(mean)) + decoder.scale.copy_(torch.from_numpy(std) + 1e-6) # small epsilon to avoid zero + + # Create data loader + dataloader = DataLoader( + dataset, + batch_size=batch_size, + shuffle=True, + pin_memory=False, + ) + + # Initialize TensorBoard writer + Path(log_dir).mkdir(parents=True, exist_ok=True) + writer = SummaryWriter(log_dir) + + # Set the optimizer + optimizer = torch.optim.Adam(model.parameters(), lr=optimizer_lr) + best_loss = float("inf") + counter = 0 + + model.train() + for epoch in range(num_epoch): + epoch_loss = 0.0 + + optimizer.zero_grad() + + for i, batch in enumerate(dataloader): + # Get batch data + daily_batch = batch["daily_patch"] + daily_mask = batch["daily_mask_patch"] + monthly_target = batch["monthly_patch"] + land_mask = batch["land_mask_patch"] + padded_days_mask = batch["padded_days_mask"] + + # Batch prediction + pred = model(daily_batch, daily_mask, land_mask, padded_days_mask) # (B, M, H, W) + + # Mask out land pixels + ocean = (~land_mask).to(pred.device).unsqueeze(1).float() # (B, M=1, H, W) bool + loss = torch.nn.functional.l1_loss(pred, monthly_target, reduction="none") + loss = loss * ocean + + num = loss.sum(dim=(-2, -1)) # (B, M) + denom = ocean.sum(dim=(-2, -1)).clamp_min(1) # (B, 1) + + loss_per_month = num / denom + loss = loss_per_month.mean() + + # Scale loss for gradient accumulation + scaled_loss = loss / accumulation_steps + scaled_loss.backward() + + # Track unscaled loss for logging + epoch_loss += loss.item() + + # Update weights every accumulation_steps batches + if (i + 1) % accumulation_steps == 0: + optimizer.step() + optimizer.zero_grad() + + # Handle remaining gradients if num_batches is not divisible by accumulation_steps + if (i + 1) % accumulation_steps != 0: + optimizer.step() + optimizer.zero_grad() + + # Calculate average epoch loss + avg_epoch_loss = epoch_loss / (i + 1) + + # Log to TensorBoard + writer.add_scalar('Loss/train', avg_epoch_loss, epoch) + writer.add_scalar('Loss/best', best_loss, epoch) + + # Early stopping check + if avg_epoch_loss < best_loss: + best_loss = avg_epoch_loss + counter = 0 + else: + counter += 1 + + if verbose and epoch % 20 == 0: + print(f"Epoch {epoch}: best_loss = {best_loss:.6f}") + + if counter >= patience: + writer.add_text('Training', f'Early stop at epoch {epoch}', epoch) + break + + # Close the writer when done + writer.close() + + if verbose: + print(f"Training complete. Best loss: {best_loss:.6f}") + + if save_model: + model_path = Path(log_dir) / "best_model.pth" + torch.save( + {"model_state_dict": model.state_dict(), "model_config": model.config}, model_path + ) + if verbose: + print(f"Model saved to {model_path}") + + return model diff --git a/pyproject.toml b/pyproject.toml index 7c9685a..660dfb0 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -14,6 +14,7 @@ dependencies = [ "jupyterlab>=4.5.3", "matplotlib>=3.10.8", "netcdf4>=1.7.4", + "tensorboard", "torch>=2.10.0", "xarray>=2025.12.0", ] From fd3b79e5cacc149977c1bc1c8174cf70fa3dec87 Mon Sep 17 00:00:00 2001 From: SarahAlidoost Date: Wed, 18 Mar 2026 17:01:26 +0100 Subject: [PATCH 3/3] implement the training loop in the example notebook --- notebooks/example.ipynb | 229 ++++++++++++++-------------------------- 1 file changed, 77 insertions(+), 152 deletions(-) diff --git a/notebooks/example.ipynb b/notebooks/example.ipynb index c6d2e0a..bcd05e1 100644 --- a/notebooks/example.ipynb +++ b/notebooks/example.ipynb @@ -13,7 +13,7 @@ "import torch.nn.functional\n", "from torch.utils.data import DataLoader\n", "from climanet.st_encoder_decoder import SpatioTemporalModel\n", - "from climanet.utils import pred_to_numpy, add_month_day_dims\n", + "from climanet.utils import pred_to_numpy, train_monthly_model, calc_stats\n", "from climanet import STDataset" ] }, @@ -32,7 +32,7 @@ "metadata": {}, "outputs": [], "source": [ - "data_folder = Path(\"../../data/output/\")\n", + "data_folder = Path(\"/home/sarah/temp/eso4clima\")\n", "\n", "file_names = [data_folder / \"202001_day_ERA5_masked_ts.nc\", data_folder / \"202002_day_ERA5_masked_ts.nc\"]\n", "daily_data = xr.open_mfdataset(file_names)\n", @@ -95,9 +95,7 @@ ], "source": [ "# create monthly mean to predict mean and std per month\n", - "daily_subset_averaged = daily_subset[\"ts\"].resample(time=\"MS\").mean(skipna=True)\n", - "mean = daily_subset_averaged.mean(dim=[\"lat\", \"lon\"], skipna=True).values\n", - "std = daily_subset_averaged.std(dim=[\"lat\", \"lon\"], skipna=True).values\n", + "mean, std = calc_stats(daily_subset[\"ts\"])\n", "print(f'mean: {mean}, std: {std}')" ] }, @@ -119,172 +117,74 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 8, "id": "bcc04777-5235-4ef3-81bd-2bdcafd8baaa", "metadata": {}, "outputs": [], "source": [ "# create the model\n", - "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n", "patch_size = (1, 4, 4)\n", "overlap = 1\n", - "model = SpatioTemporalModel(patch_size=patch_size, overlap=overlap, num_months=2).to(device)\n", - "optimizer = torch.optim.Adam(model.parameters(), lr=1e-3)\n", - "decoder = model.decoder\n", - "\n", - "with torch.no_grad():\n", - " decoder.bias.copy_(torch.from_numpy(mean))\n", - " decoder.scale.copy_(torch.from_numpy(std) + 1e-6) # small epsilon to avoid zero" - ] - }, - { - "cell_type": "markdown", - "id": "945ec311-53b3-4cac-a1e3-d16f4508e7a7", - "metadata": {}, - "source": [ - "### Start training loop" + "model = SpatioTemporalModel(patch_size=patch_size, overlap=overlap, num_months=2)" ] }, { "cell_type": "code", - "execution_count": 34, + "execution_count": 9, "id": "766cdd9d-8a97-42f0-988f-cf0c003836d2", "metadata": {}, "outputs": [], "source": [ + "num_patches = 20\n", "dataset = STDataset(\n", " daily_da=daily_subset[\"ts\"],\n", " monthly_da=monthly_subset[\"ts\"],\n", " land_mask=lsm_subset[\"lsm\"],\n", - " patch_size=(patch_size[1]*20, patch_size[2]*20), # based on the patch_size in model\n", - ")\n", - "\n", - "# create dataloader\n", - "dataloader = DataLoader(\n", - " dataset,\n", - " batch_size=2, \n", - " shuffle=True,\n", - " pin_memory=False,\n", + " patch_size=(patch_size[1]*num_patches, patch_size[2]*num_patches), # based on the patch_size in model\n", ")" ] }, { - "cell_type": "code", - "execution_count": 35, - "id": "e64d64b9-06b6-4284-956e-1e9ca0ecfeec", + "cell_type": "markdown", + "id": "945ec311-53b3-4cac-a1e3-d16f4508e7a7", "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "torch.Size([2, 1, 2, 31, 80, 80])\n", - "torch.Size([2, 1, 2, 31, 80, 80])\n" - ] - } - ], "source": [ - "for batch in dataloader:\n", - " print(batch[\"daily_patch\"].shape)" + "### Start training loop" ] }, { "cell_type": "code", - "execution_count": 36, - "id": "eb77d5be-a844-4bd0-bf38-4865ac1ca78e", + "execution_count": 10, + "id": "e84304f1-deb2-4f7c-b026-9ee4bbb38272", "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Epoch 0: best_loss = 1.048081\n", - "Epoch 20: best_loss = 0.968199\n", - "Epoch 40: best_loss = 0.730395\n", - "Epoch 60: best_loss = 0.601687\n", - "Epoch 80: best_loss = 0.493798\n", - "Epoch 100: best_loss = 0.377198\n", - "Epoch 120: best_loss = 0.263445\n", - "Epoch 140: best_loss = 0.196352\n", - "No improvement for 10 epochs, stopping early at epoch 159.\n", - "training done!\n", - "0.16787965595722198\n" + "Epoch 0: best_loss = 1.075886\n", + "Epoch 20: best_loss = 1.005486\n", + "Epoch 40: best_loss = 0.776940\n", + "Epoch 60: best_loss = 0.631601\n", + "Epoch 80: best_loss = 0.443409\n", + "Epoch 100: best_loss = 0.329191\n", + "Epoch 120: best_loss = 0.257233\n", + "Epoch 140: best_loss = 0.214589\n", + "Epoch 160: best_loss = 0.161136\n", + "Epoch 180: best_loss = 0.141038\n", + "Epoch 200: best_loss = 0.115889\n", + "Epoch 220: best_loss = 0.102219\n", + "Epoch 240: best_loss = 0.089440\n", + "Training complete. Best loss: 0.087259\n", + "Model saved to runs/best_model.pth\n" ] } ], "source": [ - "best_loss = float(\"inf\")\n", - "patience = 10 # stop if no improvement for epochs\n", - "counter = 0\n", - "\n", - "# Effective batch size = batch_size (fit in memory) * accumulation_steps\n", - "accumulation_steps = 2\n", - "\n", - "# Training loop with DataLoader\n", - "model.train()\n", - "for epoch in range(501):\n", - " epoch_loss = 0.0\n", - " \n", - " optimizer.zero_grad()\n", - " \n", - " for i, batch in enumerate(dataloader):\n", - " # Get batch data\n", - " daily_batch = batch[\"daily_patch\"]\n", - " daily_mask = batch[\"daily_mask_patch\"]\n", - " monthly_target = batch[\"monthly_patch\"]\n", - " land_mask = batch[\"land_mask_patch\"]\n", - " padded_days_mask = batch[\"padded_days_mask\"]\n", - "\n", - " # Batch prediction\n", - " pred = model(daily_batch, daily_mask, land_mask, padded_days_mask) # (B, M, H, W)\n", - " \n", - " # Mask out land pixels\n", - " ocean = (~land_mask).to(pred.device).unsqueeze(1).float() # (B, M=1, H, W) bool \n", - " loss = torch.nn.functional.l1_loss(pred, monthly_target, reduction=\"none\") \n", - " loss = loss * ocean\n", - " \n", - " num = loss.sum(dim=(-2, -1)) # (B, M)\n", - " denom = ocean.sum(dim=(-2, -1)).clamp_min(1) # (B, 1)\n", - " \n", - " loss_per_month = num / denom \n", - " loss = loss_per_month.mean()\n", - "\n", - " # Scale loss for gradient accumulation\n", - " scaled_loss = loss / accumulation_steps\n", - " scaled_loss.backward()\n", - " \n", - " # Track unscaled loss for logging\n", - " epoch_loss += loss.item()\n", - "\n", - " # Update weights every accumulation_steps batches\n", - " if (i + 1) % accumulation_steps == 0:\n", - " optimizer.step()\n", - " optimizer.zero_grad()\n", - " \n", - " # Handle remaining gradients if num_batches is not divisible by accumulation_steps\n", - " if (i + 1) % accumulation_steps != 0:\n", - " optimizer.step()\n", - " optimizer.zero_grad()\n", - " \n", - " # Calculate average epoch loss\n", - " avg_epoch_loss = epoch_loss / (i + 1)\n", - " \n", - " # Early stopping check\n", - " if avg_epoch_loss < best_loss:\n", - " best_loss = avg_epoch_loss\n", - " counter = 0\n", - " else:\n", - " counter += 1\n", - " \n", - " if epoch % 20 == 0:\n", - " print(f\"Epoch {epoch}: best_loss = {best_loss:.6f}\")\n", - " \n", - " if counter >= patience:\n", - " print(f\"No improvement for {patience} epochs, stopping early at epoch {epoch}.\")\n", - " break\n", - "\n", - "print(\"training done!\")\n", - "print(best_loss)" + "# verbose is True\n", + "model = train_monthly_model(\n", + " model, dataset, decoder_stats=(mean, std), batch_size=2, num_epoch=501, patience=10, accumulation_steps=2, log_dir=\"./runs\"\n", + ")" ] }, { @@ -297,7 +197,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 11, "id": "bda9f068", "metadata": {}, "outputs": [ @@ -331,7 +231,32 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 12, + "id": "610e6fbf-1740-47bb-a955-248f9aa8d2ed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# load the model\n", + "model_path = \"runs/best_model.pth\"\n", + "checkpoint = torch.load(model_path, weights_only=False) # weights_only=False we trust the file\n", + "model = SpatioTemporalModel(**checkpoint[\"model_config\"])\n", + "model.load_state_dict(checkpoint[\"model_state_dict\"])" + ] + }, + { + "cell_type": "code", + "execution_count": 13, "id": "1fe7425a-5ab8-423b-8130-1311cd098077", "metadata": {}, "outputs": [], @@ -343,7 +268,7 @@ }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 14, "id": "15d5fbee", "metadata": {}, "outputs": [ @@ -362,7 +287,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 15, "id": "ee2e5efb-d572-4162-95a8-9a299eaa3a7d", "metadata": {}, "outputs": [], @@ -384,23 +309,23 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 16, "id": "e581aa17-3916-47be-a1b6-447015f3f3da", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 41, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -415,17 +340,17 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 17, "id": "65c7de6c-0b13-4cb8-912f-02e8ed953c71", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 42, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, @@ -447,7 +372,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 18, "id": "7d621ae6-52d8-476b-95b4-205bc05589e3", "metadata": {}, "outputs": [], @@ -459,23 +384,23 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 19, "id": "6e18ddd5-81b2-4583-8a35-e9af7978bdf5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 44, + "execution_count": 19, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -490,23 +415,23 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 20, "id": "ea56d33c-fd54-4353-bd88-06990ed9641c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 45, + "execution_count": 20, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ]