diff --git a/climanet/dataset.py b/climanet/dataset.py index 70fd091..344d737 100644 --- a/climanet/dataset.py +++ b/climanet/dataset.py @@ -1,7 +1,7 @@ import warnings import numpy as np -from .utils import add_month_day_dims +from .utils import add_month_day_dims, calc_stats import xarray as xr import torch from torch.utils.data import Dataset @@ -52,6 +52,9 @@ def __init__( self.lat_coords = daily_da[spatial_dims[0]].to_numpy().copy() self.lon_coords = daily_da[spatial_dims[1]].to_numpy().copy() + # Store the stats of the daily data before filling NaNs + self.daily_mean, self.daily_std = calc_stats(self.daily_np) + if land_mask is not None: lm = land_mask.to_numpy().copy() if lm.ndim == 3: 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, ( diff --git a/climanet/train.py b/climanet/train.py new file mode 100644 index 0000000..4344d12 --- /dev/null +++ b/climanet/train.py @@ -0,0 +1,180 @@ +import copy +from pathlib import Path +from torch.utils.data import Dataset +from torch.optim.lr_scheduler import ReduceLROnPlateau +from torch.utils.data import DataLoader +from torch.utils.tensorboard import SummaryWriter +import torch + + +def _setup_logging(log_dir: str) -> SummaryWriter: + """Set up TensorBoard logging directory and writer.""" + Path(log_dir).mkdir(parents=True, exist_ok=True) + return SummaryWriter(log_dir) + + +def _compute_masked_loss( + pred: torch.Tensor, target: torch.Tensor, land_mask: torch.Tensor +) -> torch.Tensor: + """Compute L1 loss masked to ocean pixels only.""" + ocean = (~land_mask).to(pred.device).unsqueeze(1).float() + loss = torch.nn.functional.l1_loss(pred, target, reduction="none") * ocean + + num = loss.sum(dim=(-2, -1)) + denom = ocean.sum(dim=(-2, -1)).clamp_min(1) + + return (num / denom).mean() + + +def _save_model(model: torch.nn.Module, run_dir: str, verbose: bool) -> None: + """Save model state and config to disk.""" + model_path = Path(run_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}") + + +def train_monthly_model( + model: torch.nn.Module, + dataset: Dataset, + shuffle: bool = True, + batch_size: int = 2, + num_epoch: int = 100, + patience: int = 10, + accumulation_steps: int = 1, + optimizer_lr: float = 1e-3, + run_dir: str = ".", + save_model: bool = True, + device: str = "cpu", + verbose: bool = 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 + shuffle: whether to shuffle the data each epoch + 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 + run_dir: directory to save logs and model + 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) + decoder = model.decoder + with torch.no_grad(): + decoder.bias.copy_(torch.from_numpy(dataset.daily_mean)) + decoder.scale.copy_(torch.from_numpy(dataset.daily_std) + 1e-6) + + # Create data loader + dataloader = DataLoader( + dataset, + batch_size=batch_size, + shuffle=shuffle, + pin_memory=False, + ) + + # Set up logging + writer = _setup_logging(run_dir) + + # Set the optimizer + optimizer = torch.optim.Adam(model.parameters(), lr=optimizer_lr) + best_loss = float("inf") + counter = 0 + best_state_dict = None # Store best model state + + # Add scheduler - reduces LR instead of stopping immediately + scheduler = ReduceLROnPlateau( + optimizer, + mode="min", + factor=0.5, + patience=patience // 2, # Reduce LR before early stop triggers + min_lr=1e-7, + ) + + model.train() + for epoch in range(num_epoch): + epoch_loss = 0.0 + + optimizer.zero_grad() + + for i, batch in enumerate(dataloader): + # Batch prediction + pred = model( + batch["daily_patch"], + batch["daily_mask_patch"], + batch["land_mask_patch"], + batch["padded_days_mask"], + ) # (B, M, H, W) + + # Compute masked loss + loss = _compute_masked_loss( + pred, batch["monthly_patch"], batch["land_mask_patch"] + ) + + # 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) + + # Step scheduler + scheduler.step(avg_epoch_loss) + + # 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 + best_state_dict = copy.deepcopy(model.state_dict()) + counter = 0 + else: + counter += 1 + + if verbose and epoch % 20 == 0: + print(f"Epoch {epoch}: best_loss = {best_loss:.6f}") + + # Only stop if LR is at minimum AND no improvement + current_lr = optimizer.param_groups[0]["lr"] + if counter >= patience and current_lr <= scheduler.min_lrs[0]: + writer.add_text("Training", f"Early stop at epoch {epoch}", epoch) + break + + # Restore best model + if best_state_dict is not None: + model.load_state_dict(best_state_dict) + + # Close the writer when done + writer.close() + + if verbose: + print(f"Training complete. Best loss: {best_loss:.6f}") + + if save_model: + _save_model(model, run_dir, verbose) + + return model diff --git a/climanet/utils.py b/climanet/utils.py index aa6cebf..0d5688b 100644 --- a/climanet/utils.py +++ b/climanet/utils.py @@ -1,13 +1,11 @@ -from typing import Tuple +from typing import Tuple import numpy as np import xarray as xr import torch -def regrid_to_boundary_centered_grid( - da: xr.DataArray, - roll = False -) -> xr.DataArray: + +def regrid_to_boundary_centered_grid(da: xr.DataArray, roll=False) -> xr.DataArray: """ Interpolates a DataArray from its current center-based grid onto a new grid whose coordinates are derived from user-specified boundaries. @@ -20,7 +18,7 @@ def regrid_to_boundary_centered_grid( # --- 0. Longitude Domain Check and Correction --- - input_lon = da['longitude'] + input_lon = da["longitude"] # Check if roll for 0-360 to -180-180 is requested if roll: @@ -30,18 +28,24 @@ def regrid_to_boundary_centered_grid( lon_diff = np.abs(input_lon - 180.0) # We need to roll such that the 180-degree line is moved to the edge # and the new array starts near -180 - roll_amount = int(lon_diff.argmin().item() + (input_lon.size / 2)) % input_lon.size + roll_amount = ( + int(lon_diff.argmin().item() + (input_lon.size / 2)) % input_lon.size + ) # Roll the DataArray and its coordinates da = da.roll(longitude=roll_amount, roll_coords=True) # Correct the longitude coordinate values: shift values > 180 down by 360 - new_lon_coords = da['longitude'].where(da['longitude'] <= 180, da['longitude'] - 360) + new_lon_coords = da["longitude"].where( + da["longitude"] <= 180, da["longitude"] - 360 + ) # Assign the corrected and sorted coordinates - da = da.assign_coords(longitude=new_lon_coords).sortby('longitude') - print(f"Longitudes adjusted. New range: {da['longitude'].min().item():.2f} " - f"to {da['longitude'].max().item():.2f}") + da = da.assign_coords(longitude=new_lon_coords).sortby("longitude") + print( + f"Longitudes adjusted. New range: {da['longitude'].min().item():.2f} " + f"to {da['longitude'].max().item():.2f}" + ) # --- 1. Define Target Grid Boundaries --- @@ -67,23 +71,19 @@ def regrid_to_boundary_centered_grid( # Use linear interpolation (suitable for gappy data) to map data onto the # new centers. xarray handles the NaNs automatically. - da_regridded = da.interp( - latitude=new_lats, - longitude=new_lons, - method="linear" - ) + da_regridded = da.interp(latitude=new_lats, longitude=new_lons, method="linear") print(f"Regridding complete. New dimensions: {da_regridded.dims}") return da_regridded def add_month_day_dims( - daily_ts: xr.DataArray, # (time, H, W) daily + daily_ts: xr.DataArray, # (time, H, W) daily monthly_ts: xr.DataArray, # (time, H, W) monthly time_dim: str = "time", - spatial_dims: Tuple[str, str] = ("lat", "lon") + spatial_dims: Tuple[str, str] = ("lat", "lon"), ): - """ Reshape daily and monthly data to have explicit month (M) and day (T) dimensions. + """Reshape daily and monthly data to have explicit month (M) and day (T) dimensions. Here we assume maximum 31 days in a month, and invalid day entries will be padded with NaN. @@ -104,8 +104,9 @@ def add_month_day_dims( # Add M (month key) and T (day of month) coordinates to daily data daily_indexed = ( - daily_ts - .assign_coords(M=(time_dim, dkey.values), T=(time_dim, daily_ts[time_dim].dt.day.values)) + daily_ts.assign_coords( + M=(time_dim, dkey.values), T=(time_dim, daily_ts[time_dim].dt.day.values) + ) .set_index({time_dim: ("M", "T")}) .unstack(time_dim) .reindex(T=np.arange(1, 32), M=month_keys) @@ -119,8 +120,7 @@ def add_month_day_dims( # Align monthly data to same month keys/order monthly_m = ( - monthly_ts - .assign_coords(M=(time_dim, mkey.values)) + monthly_ts.assign_coords(M=(time_dim, mkey.values)) .swap_dims({time_dim: "M"}) .drop_vars(time_dim) .sel(M=month_keys) @@ -146,7 +146,16 @@ def pred_to_numpy(pred, orig_H=None, orig_W=None, land_mask=None): if land_mask is not None: pred = pred.clone().to(torch.float32) land_mask = land_mask.bool() - land_mask = land_mask.unsqueeze(1) # (B, H,W) -> (B, 1, H, W) for broadcasting + land_mask = land_mask.unsqueeze(1) # (B, H,W) -> (B, 1, H, W) for broadcasting pred = torch.where(land_mask, torch.full_like(pred, float("nan")), pred) return pred.detach().cpu().numpy() + + +def calc_stats(arr: np.ndarray, mean_axis: int = 0) -> Tuple[np.ndarray, np.ndarray]: + """Calculate mean and std along the specified axis, ignoring NaNs.""" + axes_to_reduce = tuple(i for i in range(arr.ndim) if i != mean_axis) + + mean = np.nanmean(arr, axis=axes_to_reduce) # shape: (M,) + std = np.nanstd(arr, axis=axes_to_reduce) # shape: (M,) + return mean, std diff --git a/notebooks/example.ipynb b/notebooks/example.ipynb index c6d2e0a..5c5528e 100644 --- a/notebooks/example.ipynb +++ b/notebooks/example.ipynb @@ -2,7 +2,7 @@ "cells": [ { "cell_type": "code", - "execution_count": 1, + "execution_count": 2, "id": "11ad68b2-7502-4dc4-8b78-d0a4fb53255d", "metadata": {}, "outputs": [], @@ -13,7 +13,8 @@ "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\n", + "from climanet.train import train_monthly_model\n", "from climanet import STDataset" ] }, @@ -27,12 +28,12 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 3, "id": "13a3b0c8-1d92-460d-84a4-a3a59ca081af", "metadata": {}, "outputs": [], "source": [ - "data_folder = Path(\"../../data/output/\")\n", + "data_folder = Path(\"./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", @@ -55,7 +56,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 4, "id": "11d14431-a9f1-4cb6-a18e-b92124f55209", "metadata": {}, "outputs": [ @@ -79,28 +80,6 @@ "print(daily_subset[\"ts\"].shape, monthly_subset[\"ts\"].shape) # (time, lat, lon)" ] }, - { - "cell_type": "code", - "execution_count": 4, - "id": "d70ba708-843c-42c2-9d44-3bd60bb3b13b", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "mean: [299.9357 300.31335], std: [1.187207 1.2649659]\n" - ] - } - ], - "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", - "print(f'mean: {mean}, std: {std}')" - ] - }, { "cell_type": "markdown", "id": "11a1c896-a876-40bc-8f0a-9e7373d734b1", @@ -119,172 +98,87 @@ }, { "cell_type": "code", - "execution_count": 33, + "execution_count": 5, "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, - "id": "766cdd9d-8a97-42f0-988f-cf0c003836d2", + "execution_count": 6, + "id": "09eeabbe-36ef-46a4-ad39-b82559a2da2e", "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": 7, + "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.064811\n", + "Epoch 20: best_loss = 0.848913\n", + "Epoch 40: best_loss = 0.742154\n", + "Epoch 60: best_loss = 0.590368\n", + "Epoch 80: best_loss = 0.474284\n", + "Epoch 100: best_loss = 0.373293\n", + "Epoch 120: best_loss = 0.313690\n", + "Epoch 140: best_loss = 0.262067\n", + "Epoch 160: best_loss = 0.233068\n", + "Epoch 180: best_loss = 0.198232\n", + "Epoch 200: best_loss = 0.174762\n", + "Epoch 220: best_loss = 0.157859\n", + "Epoch 240: best_loss = 0.144779\n", + "Epoch 260: best_loss = 0.134052\n", + "Epoch 280: best_loss = 0.127401\n", + "Epoch 300: best_loss = 0.122035\n", + "Epoch 320: best_loss = 0.117025\n", + "Epoch 340: best_loss = 0.112626\n", + "Epoch 360: best_loss = 0.108094\n", + "Epoch 380: best_loss = 0.105740\n", + "Epoch 400: best_loss = 0.103568\n", + "Epoch 420: best_loss = 0.101469\n", + "Epoch 440: best_loss = 0.099437\n", + "Epoch 460: best_loss = 0.097428\n", + "Epoch 480: best_loss = 0.095427\n", + "Epoch 500: best_loss = 0.093429\n", + "Training complete. Best loss: 0.093429\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", + "trained_model = train_monthly_model(\n", + " model, dataset, batch_size=2, num_epoch=501, patience=10, accumulation_steps=2, run_dir=\"./runs\"\n", + ")" ] }, { @@ -297,7 +191,7 @@ }, { "cell_type": "code", - "execution_count": 37, + "execution_count": 8, "id": "bda9f068", "metadata": {}, "outputs": [ @@ -331,19 +225,44 @@ }, { "cell_type": "code", - "execution_count": 38, + "execution_count": 9, + "id": "610e6fbf-1740-47bb-a955-248f9aa8d2ed", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "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": 10, "id": "1fe7425a-5ab8-423b-8130-1311cd098077", "metadata": {}, "outputs": [], "source": [ - "model.eval()\n", + "trained_model.eval()\n", "with torch.no_grad():\n", - " pred = model(daily_batch, daily_mask, land_mask, padded_days_mask)" + " pred = trained_model(daily_batch, daily_mask, land_mask, padded_days_mask)" ] }, { "cell_type": "code", - "execution_count": 39, + "execution_count": 11, "id": "15d5fbee", "metadata": {}, "outputs": [ @@ -362,7 +281,7 @@ }, { "cell_type": "code", - "execution_count": 40, + "execution_count": 12, "id": "ee2e5efb-d572-4162-95a8-9a299eaa3a7d", "metadata": {}, "outputs": [], @@ -384,23 +303,23 @@ }, { "cell_type": "code", - "execution_count": 41, + "execution_count": 13, "id": "e581aa17-3916-47be-a1b6-447015f3f3da", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 41, + "execution_count": 13, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -415,17 +334,17 @@ }, { "cell_type": "code", - "execution_count": 42, + "execution_count": 14, "id": "65c7de6c-0b13-4cb8-912f-02e8ed953c71", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 42, + "execution_count": 14, "metadata": {}, "output_type": "execute_result" }, @@ -447,7 +366,7 @@ }, { "cell_type": "code", - "execution_count": 43, + "execution_count": 15, "id": "7d621ae6-52d8-476b-95b4-205bc05589e3", "metadata": {}, "outputs": [], @@ -459,23 +378,23 @@ }, { "cell_type": "code", - "execution_count": 44, + "execution_count": 16, "id": "6e18ddd5-81b2-4583-8a35-e9af7978bdf5", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 44, + "execution_count": 16, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -490,23 +409,23 @@ }, { "cell_type": "code", - "execution_count": 45, + "execution_count": 17, "id": "ea56d33c-fd54-4353-bd88-06990ed9641c", "metadata": {}, "outputs": [ { "data": { "text/plain": [ - "" + "" ] }, - "execution_count": 45, + "execution_count": 17, "metadata": {}, "output_type": "execute_result" }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] 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", ]