diff --git a/1_pytorch_mnist_unet.ipynb b/1_pytorch_mnist_unet.ipynb deleted file mode 100644 index f21c78f..0000000 --- a/1_pytorch_mnist_unet.ipynb +++ /dev/null @@ -1,315 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Epoch 1/10, Batch 0/750, Loss: 0.4551\n", - "Epoch 1/10, Batch 100/750, Loss: 0.0079\n", - "Epoch 1/10, Batch 200/750, Loss: 0.0026\n", - "Epoch 1/10, Batch 300/750, Loss: 0.0017\n", - "Epoch 1/10, Batch 400/750, Loss: 0.0012\n", - "Epoch 1/10, Batch 500/750, Loss: 0.0009\n", - "Epoch 1/10, Batch 600/750, Loss: 0.0009\n", - "Epoch 1/10, Batch 700/750, Loss: 0.0008\n", - "Validation Loss: 0.0007\n", - "Epoch 2/10, Batch 0/750, Loss: 0.0007\n", - "Epoch 2/10, Batch 100/750, Loss: 0.0007\n", - "Epoch 2/10, Batch 200/750, Loss: 0.0006\n", - "Epoch 2/10, Batch 300/750, Loss: 0.0005\n", - "Epoch 2/10, Batch 400/750, Loss: 0.0005\n", - "Epoch 2/10, Batch 500/750, Loss: 0.0005\n", - "Epoch 2/10, Batch 600/750, Loss: 0.0005\n", - "Epoch 2/10, Batch 700/750, Loss: 0.0007\n", - "Validation Loss: 0.0004\n", - "Epoch 3/10, Batch 0/750, Loss: 0.0005\n", - "Epoch 3/10, Batch 100/750, Loss: 0.0004\n", - "Epoch 3/10, Batch 200/750, Loss: 0.0004\n", - "Epoch 3/10, Batch 300/750, Loss: 0.0004\n", - "Epoch 3/10, Batch 400/750, Loss: 0.0004\n", - "Epoch 3/10, Batch 500/750, Loss: 0.0003\n", - "Epoch 3/10, Batch 600/750, Loss: 0.0004\n", - "Epoch 3/10, Batch 700/750, Loss: 0.0003\n", - "Validation Loss: 0.0003\n", - "Epoch 4/10, Batch 0/750, Loss: 0.0003\n", - "Epoch 4/10, Batch 100/750, Loss: 0.0003\n", - "Epoch 4/10, Batch 200/750, Loss: 0.0004\n", - "Epoch 4/10, Batch 300/750, Loss: 0.0003\n", - "Epoch 4/10, Batch 400/750, Loss: 0.0006\n", - "Epoch 4/10, Batch 500/750, Loss: 0.0003\n", - "Epoch 4/10, Batch 600/750, Loss: 0.0003\n", - "Epoch 4/10, Batch 700/750, Loss: 0.0003\n", - "Validation Loss: 0.0004\n", - "Epoch 5/10, Batch 0/750, Loss: 0.0004\n", - "Epoch 5/10, Batch 100/750, Loss: 0.0003\n", - "Epoch 5/10, Batch 200/750, Loss: 0.0003\n", - "Epoch 5/10, Batch 300/750, Loss: 0.0003\n", - "Epoch 5/10, Batch 400/750, Loss: 0.0004\n", - "Epoch 5/10, Batch 500/750, Loss: 0.0002\n", - "Epoch 5/10, Batch 600/750, Loss: 0.0002\n", - "Epoch 5/10, Batch 700/750, Loss: 0.0004\n", - "Validation Loss: 0.0003\n", - "Epoch 6/10, Batch 0/750, Loss: 0.0003\n", - "Epoch 6/10, Batch 100/750, Loss: 0.0002\n", - "Epoch 6/10, Batch 200/750, Loss: 0.0004\n", - "Epoch 6/10, Batch 300/750, Loss: 0.0004\n", - "Epoch 6/10, Batch 400/750, Loss: 0.0002\n", - "Epoch 6/10, Batch 500/750, Loss: 0.0002\n", - "Epoch 6/10, Batch 600/750, Loss: 0.0003\n", - "Epoch 6/10, Batch 700/750, Loss: 0.0003\n", - "Validation Loss: 0.0002\n", - "Epoch 7/10, Batch 0/750, Loss: 0.0002\n", - "Epoch 7/10, Batch 100/750, Loss: 0.0002\n", - "Epoch 7/10, Batch 200/750, Loss: 0.0002\n", - "Epoch 7/10, Batch 300/750, Loss: 0.0002\n", - "Epoch 7/10, Batch 400/750, Loss: 0.0002\n", - "Epoch 7/10, Batch 500/750, Loss: 0.0002\n", - "Epoch 7/10, Batch 600/750, Loss: 0.0002\n", - "Epoch 7/10, Batch 700/750, Loss: 0.0003\n", - "Validation Loss: 0.0002\n", - "Epoch 8/10, Batch 0/750, Loss: 0.0002\n", - "Epoch 8/10, Batch 100/750, Loss: 0.0002\n", - "Epoch 8/10, Batch 200/750, Loss: 0.0002\n", - "Epoch 8/10, Batch 300/750, Loss: 0.0002\n", - "Epoch 8/10, Batch 400/750, Loss: 0.0002\n", - "Epoch 8/10, Batch 500/750, Loss: 0.0002\n", - "Epoch 8/10, Batch 600/750, Loss: 0.0002\n", - "Epoch 8/10, Batch 700/750, Loss: 0.0002\n", - "Validation Loss: 0.0002\n", - "Epoch 9/10, Batch 0/750, Loss: 0.0002\n", - "Epoch 9/10, Batch 100/750, Loss: 0.0002\n", - "Epoch 9/10, Batch 200/750, Loss: 0.0002\n", - "Epoch 9/10, Batch 300/750, Loss: 0.0002\n", - "Epoch 9/10, Batch 400/750, Loss: 0.0002\n", - "Epoch 9/10, Batch 500/750, Loss: 0.0001\n", - "Epoch 9/10, Batch 600/750, Loss: 0.0003\n", - "Epoch 9/10, Batch 700/750, Loss: 0.0002\n", - "Validation Loss: 0.0002\n", - "Epoch 10/10, Batch 0/750, Loss: 0.0002\n", - "Epoch 10/10, Batch 100/750, Loss: 0.0001\n", - "Epoch 10/10, Batch 200/750, Loss: 0.0003\n", - "Epoch 10/10, Batch 300/750, Loss: 0.0001\n", - "Epoch 10/10, Batch 400/750, Loss: 0.0002\n", - "Epoch 10/10, Batch 500/750, Loss: 0.0002\n", - "Epoch 10/10, Batch 600/750, Loss: 0.0002\n", - "Epoch 10/10, Batch 700/750, Loss: 0.0001\n", - "Validation Loss: 0.0002\n", - "Training complete!\n" - ] - } - ], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "from torch.utils.data import DataLoader, random_split\n", - "from torchvision import datasets, transforms\n", - "\n", - "# Define U-Net architecture\n", - "class UNet(nn.Module):\n", - " def __init__(self):\n", - " super(UNet, self).__init__()\n", - "\n", - " # Encoder\n", - " self.encoder = nn.Sequential(\n", - " nn.Conv2d(1, 64, kernel_size=3, padding=1),\n", - " nn.ReLU(inplace=True),\n", - " nn.Conv2d(64, 64, kernel_size=3, padding=1),\n", - " nn.ReLU(inplace=True),\n", - " nn.MaxPool2d(kernel_size=2, stride=2)\n", - " )\n", - "\n", - " # Decoder\n", - " self.decoder = nn.Sequential(\n", - " nn.Conv2d(64, 64, kernel_size=3, padding=1),\n", - " nn.ReLU(inplace=True),\n", - " nn.Conv2d(64, 64, kernel_size=3, padding=1),\n", - " nn.ReLU(inplace=True),\n", - " nn.ConvTranspose2d(64, 1, kernel_size=2, stride=2)\n", - " )\n", - "\n", - " def forward(self, x):\n", - " x1 = self.encoder(x)\n", - " x2 = self.decoder(x1)\n", - " return x2\n", - "\n", - "# Set device\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "\n", - "# Load MNIST dataset and split into train, validation, and test sets\n", - "transform = transforms.Compose([transforms.ToTensor()])\n", - "full_dataset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)\n", - "\n", - "train_size = int(0.8 * len(full_dataset))\n", - "val_size = int(0.1 * len(full_dataset))\n", - "test_size = len(full_dataset) - train_size - val_size\n", - "\n", - "train_dataset, val_dataset, test_dataset = random_split(full_dataset, [train_size, val_size, test_size])\n", - "\n", - "train_loader = DataLoader(train_dataset, batch_size=64, shuffle=True, num_workers=4)\n", - "val_loader = DataLoader(val_dataset, batch_size=64, shuffle=False, num_workers=4)\n", - "test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=4)\n", - "\n", - "# Instantiate the U-Net model and move it to the device\n", - "model = UNet().to(device)\n", - "\n", - "# Define loss function and optimizer\n", - "criterion = nn.MSELoss()\n", - "optimizer = optim.Adam(model.parameters(), lr=0.001)\n", - "\n", - "# Training loop\n", - "num_epochs = 10\n", - "for epoch in range(num_epochs):\n", - " model.train()\n", - " for batch_idx, (data, _) in enumerate(train_loader):\n", - " data = data.to(device)\n", - "\n", - " # Forward pass\n", - " output = model(data)\n", - "\n", - " # Compute loss\n", - " loss = criterion(output, data)\n", - "\n", - " # Backward pass and optimization\n", - " optimizer.zero_grad()\n", - " loss.backward()\n", - " optimizer.step()\n", - "\n", - " if batch_idx % 100 == 0:\n", - " print(f\"Epoch {epoch+1}/{num_epochs}, Batch {batch_idx}/{len(train_loader)}, Loss: {loss.item():.4f}\")\n", - "\n", - " # Validation loop\n", - " model.eval()\n", - " with torch.no_grad():\n", - " total_loss = 0.0\n", - " for data, _ in val_loader:\n", - " data = data.to(device)\n", - " output = model(data)\n", - " total_loss += criterion(output, data).item()\n", - "\n", - " average_loss = total_loss / len(val_loader)\n", - " print(f\"Validation Loss: {average_loss:.4f}\")\n", - "\n", - "print(\"Training complete!\")\n", - "\n", - "# Save the trained model\n", - "torch.save(model.state_dict(), 'unet_mnist.pth')" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "from PIL import Image\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# Define U-Net architecture (make sure it matches the architecture used during training)\n", - "class UNet(nn.Module):\n", - " def __init__(self):\n", - " super(UNet, self).__init__()\n", - "\n", - " # Encoder\n", - " self.encoder = nn.Sequential(\n", - " nn.Conv2d(1, 64, kernel_size=3, padding=1),\n", - " nn.ReLU(inplace=True),\n", - " nn.Conv2d(64, 64, kernel_size=3, padding=1),\n", - " nn.ReLU(inplace=True),\n", - " nn.MaxPool2d(kernel_size=2, stride=2)\n", - " )\n", - "\n", - " # Decoder\n", - " self.decoder = nn.Sequential(\n", - " nn.Conv2d(64, 64, kernel_size=3, padding=1),\n", - " nn.ReLU(inplace=True),\n", - " nn.Conv2d(64, 64, kernel_size=3, padding=1),\n", - " nn.ReLU(inplace=True),\n", - " nn.ConvTranspose2d(64, 1, kernel_size=2, stride=2)\n", - " )\n", - "\n", - " def forward(self, x):\n", - " x1 = self.encoder(x)\n", - " x2 = self.decoder(x1)\n", - " return x2\n", - "\n", - "# Set device\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "\n", - "# Load the trained model\n", - "model = UNet()\n", - "model.load_state_dict(torch.load('unet_mnist.pth'))\n", - "model.to(device)\n", - "model.eval()\n", - "\n", - "# Transform for input image\n", - "transform = transforms.Compose([transforms.Grayscale(num_output_channels=1),\n", - " transforms.ToTensor()])\n", - "\n", - "# # Load the test dataset\n", - "# test_dataset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)\n", - "# test_loader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=4)\n", - "\n", - "# Testing loop\n", - "with torch.no_grad():\n", - " for batch_idx, (data, _) in enumerate(test_loader):\n", - " data = data.to(device)\n", - "\n", - " # Forward pass\n", - " output = model(data)\n", - "\n", - " # Visualize the input and output for the first batch\n", - " if batch_idx == 0:\n", - " for i in range(min(4, data.size(0))): # Visualize up to 4 samples\n", - " plt.subplot(2, 4, i + 1)\n", - " plt.title('Input')\n", - " plt.imshow(data[i].cpu().squeeze().numpy(), cmap='gray')\n", - "\n", - " plt.subplot(2, 4, i + 5)\n", - " plt.title('Output')\n", - " plt.imshow(output[i].cpu().squeeze().numpy(), cmap='gray')\n", - "\n", - " plt.show()\n", - "\n", - "# You can also calculate metrics like accuracy, precision, recall, etc., for more detailed evaluation." - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pytorch", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/6_pytorch_dataloading_tests_custom_Unet.ipynb b/6_pytorch_dataloading_tests_custom_Unet.ipynb deleted file mode 100644 index f9746e0..0000000 --- a/6_pytorch_dataloading_tests_custom_Unet.ipynb +++ /dev/null @@ -1,9532 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "from torch.utils.data import DataLoader, random_split\n", - "from torchvision import datasets, transforms\n", - "\n", - "# Set device\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "\n", - "# torch.set_float32_matmul_precision('medium')" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import os\n", - "import random\n", - "import matplotlib.pyplot as plt\n", - "\n", - "# We also set the logging level so that we get some feedback from the API\n", - "import logging\n", - "logging.basicConfig(level=logging.INFO)" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running in /data/hpcdata/users/bryald/git/icenet/notebook-pipeline\n" - ] - } - ], - "source": [ - "# Quick hack to put us in the icenet-pipeline folder,\n", - "# assuming it was created as per 01.cli_demonstration.ipynb\n", - "import os\n", - "if os.path.exists(\"pytorch_example.ipynb\"):\n", - " os.chdir(\"../notebook-pipeline\")\n", - "print(\"Running in {}\".format(os.getcwd()))\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [], - "source": [ - "def plot_image(array, title=\"\"):\n", - " fig = plt.figure(figsize=(18, 10))\n", - " plt.imshow(array[0, :, :, 0, 0])\n", - " plt.colorbar(shrink=0.6)\n", - " plt.suptitle(title)\n", - " plt.tight_layout()\n", - "\n", - " iter = 0\n", - " out_dir = \"image-outputs\"\n", - " out_path = os.path.join(out_dir, f\"{iter}_{title}.jpg\")\n", - " if not os.path.isdir(out_dir): os.makedirs(out_dir)\n", - " \n", - " while os.path.exists(out_path):\n", - " iter += 1\n", - " out_path = os.path.join(out_dir, f\"{iter}_{title}.jpg\")\n", - " plt.savefig(out_path)\n", - " plt.close()" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-12-30 00:19:41.214859: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-30 00:19:41.215362: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-30 00:19:41.216466: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "INFO:root:Loading configuration loader.notebook_api_data.json\n" - ] - } - ], - "source": [ - "from icenet.data.loaders import IceNetDataLoaderFactory\n", - "\n", - "implementation = \"dask\"\n", - "loader_config = \"loader.notebook_api_data.json\"\n", - "dataset_name = \"pytorch_notebook\"\n", - "lag = 1\n", - "\n", - "dl = IceNetDataLoaderFactory().create_data_loader(\n", - " implementation,\n", - " loader_config,\n", - " dataset_name,\n", - " lag,\n", - " n_forecast_days=7,\n", - " north=False,\n", - " south=True,\n", - " output_batch_size=1,\n", - " generate_workers=4)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We generate a config only dataset, which will get saved in `dataset_config.pytorch_notebook.json`." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:root:Writing dataset configuration without data generation\n", - "INFO:root:91 train dates in total, NOT generating cache data.\n", - "INFO:root:21 val dates in total, NOT generating cache data.\n", - "INFO:root:2 test dates in total, NOT generating cache data.\n", - "INFO:root:Writing configuration to ./dataset_config.pytorch_notebook.json\n" - ] - } - ], - "source": [ - "dl.write_dataset_config_only()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "We can now create the IceNetDataSet object:" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [], - "source": [ - "dataset_config = \"dataset_config.pytorch_notebook.json\"" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:root:Loading configuration dataset_config.pytorch_notebook.json\n", - "WARNING:root:Running in configuration only mode, tfrecords were not generated for this dataset\n" - ] - } - ], - "source": [ - "from icenet.data.dataset import IceNetDataSet\n", - "\n", - "dataset = IceNetDataSet(dataset_config, batch_size=1)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Custom PyTorch Dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [], - "source": [ - "from torch.utils.data import Dataset, DataLoader\n", - "\n", - "class IceNetDataSetPyTorch(Dataset):\n", - " def __init__(self,\n", - " configuration_path: str,\n", - " mode: str,\n", - " batch_size: int = 1,\n", - " shuffling: bool = False,\n", - " prediction: bool = False,\n", - " start_dates: object = None,\n", - " ):\n", - " self._ds = IceNetDataSet(configuration_path=configuration_path,\n", - " batch_size=batch_size,\n", - " shuffling=shuffling)\n", - " self._dl = self._ds.get_data_loader()\n", - "\n", - " # check mode option\n", - " if mode not in [\"train\", \"val\", \"test\", \"pred\"]:\n", - " raise ValueError(\"mode must be either 'train', 'val', 'test' or 'pred'\")\n", - " self._mode = mode\n", - "\n", - "\n", - " if mode.casefold() == \"pred\":\n", - " self._prediction = True\n", - " self._dates = start_dates\n", - " else:\n", - " self._prediction = False\n", - " self._dates = self._dl._config[\"sources\"][\"osisaf\"][\"dates\"][self._mode]\n", - "\n", - " def __len__(self):\n", - " if not self._prediction:\n", - " return self._ds._counts[self._mode]\n", - " else:\n", - " return len(self._dates)\n", - " \n", - " def __getitem__(self, idx):\n", - " # return tuple( map(lambda x: torch.from_numpy(x).float().contiguous(), self._dl.generate_sample(date=pd.Timestamp(self._dates[idx].replace('_', '-'))) ) )\n", - " return self._dl.generate_sample(date=pd.Timestamp(self._dates[idx].replace('_', '-')),\n", - " prediction=self._prediction,\n", - " parallel=False,\n", - " )\n", - "\n", - " def get_data_loader(self):\n", - " return self._ds.get_data_loader()\n", - " \n", - " @property\n", - " def dates(self):\n", - " return self._dates" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:root:Loading configuration dataset_config.pytorch_notebook.json\n", - "WARNING:root:Running in configuration only mode, tfrecords were not generated for this dataset\n", - "INFO:root:Loading configuration /data/hpcdata/users/bryald/git/icenet/notebook-pipeline/loader.notebook_api_data.json\n" - ] - }, - { - "data": { - "text/plain": [ - "91" - ] - }, - "execution_count": 10, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "ds_torch = IceNetDataSetPyTorch(configuration_path=dataset_config,\n", - " mode=\"train\")\n", - "len(ds_torch)" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:root:Loading configuration dataset_config.pytorch_notebook.json\n", - "WARNING:root:Running in configuration only mode, tfrecords were not generated for this dataset\n", - "INFO:root:Loading configuration /data/hpcdata/users/bryald/git/icenet/notebook-pipeline/loader.notebook_api_data.json\n", - "INFO:root:Loading configuration dataset_config.pytorch_notebook.json\n", - "WARNING:root:Running in configuration only mode, tfrecords were not generated for this dataset\n", - "INFO:root:Loading configuration /data/hpcdata/users/bryald/git/icenet/notebook-pipeline/loader.notebook_api_data.json\n", - "INFO:root:Loading configuration dataset_config.pytorch_notebook.json\n", - "WARNING:root:Running in configuration only mode, tfrecords were not generated for this dataset\n", - "INFO:root:Loading configuration /data/hpcdata/users/bryald/git/icenet/notebook-pipeline/loader.notebook_api_data.json\n" - ] - } - ], - "source": [ - "train_dataset = IceNetDataSetPyTorch(configuration_path=dataset_config, mode=\"train\")\n", - "val_dataset = IceNetDataSetPyTorch(configuration_path=dataset_config, mode=\"val\")\n", - "test_dataset = IceNetDataSetPyTorch(configuration_path=dataset_config, mode=\"test\")" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [], - "source": [ - "batch_size = 4\n", - "shuffle = False\n", - "persistent_workers=True\n", - "num_workers = 4" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [], - "source": [ - "# train_dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, persistent_workers=persistent_workers, num_workers=num_workers)\n", - "# val_dataloader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, persistent_workers=persistent_workers, num_workers=num_workers)\n", - "# test_dataloader = DataLoader(test_dataset, batch_size=batch_size, shuffle=shuffle, persistent_workers=persistent_workers, num_workers=num_workers)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [], - "source": [ - "# train_data = iter(train_dataloader)" - ] - }, - { - "cell_type": "code", - "execution_count": 15, - "metadata": {}, - "outputs": [], - "source": [ - "# # Checking inputs X, target, sample_weights\n", - "# for i, data in enumerate(train_dataloader):\n", - "# # X, y, sample_weights\n", - "# print(type(data), len(data))\n", - "# # print(data[0].shape, data[1].shape, data[2].shape)\n", - "# # print(data[0])\n", - "# fmin = torch.min(data[1])\n", - "# fmax = torch.max(data[1])\n", - "# print( f\"Target SIC min: {fmin:.4f}, max: {fmax:.4f}\" )\n", - "# target = torch.round(data[1], decimals=2)\n", - "# # target = data[1]\n", - "# unique_vals, counts = torch.unique(target, return_counts=True)\n", - "# for value, count in zip(unique_vals, counts):\n", - "# print(f\"{value}: {count} times\")\n", - "# if i == 2:\n", - "# break" - ] - }, - { - "cell_type": "code", - "execution_count": 16, - "metadata": {}, - "outputs": [], - "source": [ - "# for i, data in enumerate(val_dataloader):\n", - "# # X, y, sample_weights\n", - "# print(type(data), len(data))\n", - "# # torch.Size([4, 432, 432, 9]) torch.Size([4, 432, 432, 7, 1]) torch.Size([4, 432, 432, 7, 1])\n", - "# print(data[0].shape, data[1].shape, data[2].shape)\n", - "# # print(data[0])\n", - "# if i == 2:\n", - "# break" - ] - }, - { - "cell_type": "code", - "execution_count": 17, - "metadata": {}, - "outputs": [], - "source": [ - "# for i, data in enumerate(test_dataloader):\n", - "# # X, y, sample_weights\n", - "# print(type(data), len(data))\n", - "# print(data[0].shape, data[1].shape, data[2].shape)\n", - "# # print(data[0])\n", - "# if i == 2:\n", - "# break" - ] - }, - { - "cell_type": "code", - "execution_count": 18, - "metadata": {}, - "outputs": [], - "source": [ - "# val0 = next(train_data)" - ] - }, - { - "cell_type": "code", - "execution_count": 19, - "metadata": {}, - "outputs": [], - "source": [ - "# val1 = next(train_data)" - ] - }, - { - "cell_type": "code", - "execution_count": 20, - "metadata": {}, - "outputs": [], - "source": [ - "# try:\n", - "# print( iter(train_dataloader) )\n", - "# print(\"train_dataloader is iterable\")\n", - "# except TypeError:\n", - "# print(\"train_dataloader is not iterable\")" - ] - }, - { - "cell_type": "code", - "execution_count": 21, - "metadata": {}, - "outputs": [], - "source": [ - "# for batch_idx, (data, _) in enumerate(train_loader):\n", - "# # print(type(data))\n", - "# # print(data)\n", - "# # print(batch_idx)\n", - "# break" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## IceNet UNet model\n", - "\n", - "As a first attempt to implement a PyTorch example, we adapt code from https://github.com/ampersandmcd/icenet-gan/.\n", - "\n", - "Below is a PyTorch implementation of the UNet architecture." - ] - }, - { - "cell_type": "code", - "execution_count": 22, - "metadata": {}, - "outputs": [], - "source": [ - "# import torch\n", - "# from torch import nn\n", - "# import torch.nn.functional as F\n", - "\n", - "# class UNet(nn.Module):\n", - "# \"\"\"\n", - "# An implementation of a UNet for pixelwise classification.\n", - "# \"\"\"\n", - " \n", - "# def __init__(self,\n", - "# input_channels, \n", - "# filter_size=3, \n", - "# n_filters_factor=1, \n", - "# n_forecast_days=7, \n", - "# n_output_classes=1,\n", - "# **kwargs):\n", - "# super(UNet, self).__init__()\n", - "\n", - "# self.input_channels = input_channels\n", - "# self.filter_size = filter_size\n", - "# self.n_filters_factor = n_filters_factor\n", - "# self.n_forecast_days = n_forecast_days\n", - "# self.n_output_classes = n_output_classes\n", - "\n", - "# self.conv1a = nn.Conv2d(in_channels=input_channels, \n", - "# out_channels=int(128*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv1b = nn.Conv2d(in_channels=int(128*n_filters_factor),\n", - "# out_channels=int(128*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn1 = nn.BatchNorm2d(num_features=int(128*n_filters_factor))\n", - "\n", - "# self.conv2a = nn.Conv2d(in_channels=int(128*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv2b = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn2 = nn.BatchNorm2d(num_features=int(256*n_filters_factor))\n", - "\n", - "# self.conv3a = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv3b = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn3 = nn.BatchNorm2d(num_features=int(512*n_filters_factor))\n", - "\n", - "# self.conv4a = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv4b = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn4 = nn.BatchNorm2d(num_features=int(512*n_filters_factor))\n", - "\n", - "# self.conv5a = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(1024*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv5b = nn.Conv2d(in_channels=int(1024*n_filters_factor),\n", - "# out_channels=int(1024*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn5 = nn.BatchNorm2d(num_features=int(1024*n_filters_factor))\n", - "\n", - "# self.conv6a = nn.Conv2d(in_channels=int(1024*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv6b = nn.Conv2d(in_channels=int(1024*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv6c = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn6 = nn.BatchNorm2d(num_features=int(512*n_filters_factor))\n", - "\n", - "# self.conv7a = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv7b = nn.Conv2d(in_channels=int(1024*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv7c = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn7 = nn.BatchNorm2d(num_features=int(512*n_filters_factor))\n", - "\n", - "# self.conv8a = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv8b = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv8c = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn8 = nn.BatchNorm2d(num_features=int(256*n_filters_factor))\n", - "\n", - "# self.conv9a = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(128*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv9b = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(128*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv9c = nn.Conv2d(in_channels=int(128*n_filters_factor),\n", - "# out_channels=int(128*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\") # no batch norm on last layer\n", - "\n", - "# self.final_conv = nn.Conv2d(in_channels=int(128*n_filters_factor),\n", - "# out_channels=n_output_classes*n_forecast_days,\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - " \n", - "# def forward(self, x):\n", - "\n", - "# # transpose from shape (b, h, w, c) to (b, c, h, w) for pytorch conv2d layers\n", - "# x = torch.movedim(x, -1, 1) # move c from last to second dim\n", - "\n", - "# # run through network\n", - "# conv1 = self.conv1a(x) # input to 128\n", - "# conv1 = F.relu(conv1)\n", - "# conv1 = self.conv1b(conv1) # 128 to 128\n", - "# conv1 = F.relu(conv1)\n", - "# bn1 = self.bn1(conv1)\n", - "# pool1 = F.max_pool2d(bn1, kernel_size=(2, 2))\n", - "\n", - "# conv2 = self.conv2a(pool1) # 128 to 256\n", - "# conv2 = F.relu(conv2)\n", - "# conv2 = self.conv2b(conv2) # 256 to 256\n", - "# conv2 = F.relu(conv2)\n", - "# bn2 = self.bn2(conv2)\n", - "# pool2 = F.max_pool2d(bn2, kernel_size=(2, 2))\n", - "\n", - "# conv3 = self.conv3a(pool2) # 256 to 512\n", - "# conv3 = F.relu(conv3)\n", - "# conv3 = self.conv3b(conv3) # 512 to 512\n", - "# conv3 = F.relu(conv3)\n", - "# bn3 = self.bn3(conv3)\n", - "# pool3 = F.max_pool2d(bn3, kernel_size=(2, 2))\n", - "\n", - "# conv4 = self.conv4a(pool3) # 512 to 512\n", - "# conv4 = F.relu(conv4)\n", - "# conv4 = self.conv4b(conv4) # 512 to 512\n", - "# conv4 = F.relu(conv4)\n", - "# bn4 = self.bn4(conv4)\n", - "# pool4 = F.max_pool2d(bn4, kernel_size=(2, 2))\n", - "\n", - "# conv5 = self.conv5a(pool4) # 512 to 1024\n", - "# conv5 = F.relu(conv5)\n", - "# conv5 = self.conv5b(conv5) # 1024 to 1024\n", - "# conv5 = F.relu(conv5)\n", - "# bn5 = self.bn5(conv5)\n", - "\n", - "# up6 = F.interpolate(bn5, scale_factor=2, mode=\"nearest\")\n", - "# up6 = self.conv6a(up6) # 1024 to 512\n", - "# up6 = F.relu(up6)\n", - "# merge6 = torch.cat([bn4, up6], dim=1) # 512 and 512 to 1024 along c dimension\n", - "# conv6 = self.conv6b(merge6) # 1024 to 512\n", - "# conv6 = F.relu(conv6)\n", - "# conv6 = self.conv6c(conv6) # 512 to 512\n", - "# conv6 = F.relu(conv6)\n", - "# bn6 = self.bn6(conv6)\n", - "\n", - "# up7 = F.interpolate(bn6, scale_factor=2, mode=\"nearest\")\n", - "# up7 = self.conv7a(up7) # 1024 to 512\n", - "# up7 = F.relu(up7)\n", - "# merge7 = torch.cat([bn3, up7], dim=1) # 512 and 512 to 1024 along c dimension\n", - "# conv7 = self.conv7b(merge7) # 1024 to 512\n", - "# conv7 = F.relu(conv7)\n", - "# conv7 = self.conv7c(conv7) # 512 to 512\n", - "# conv7 = F.relu(conv7)\n", - "# bn7 = self.bn7(conv7)\n", - "\n", - "# up8 = F.interpolate(bn7, scale_factor=2, mode=\"nearest\")\n", - "# up8 = self.conv8a(up8) # 512 to 256\n", - "# up8 = F.relu(up8)\n", - "# merge8 = torch.cat([bn2, up8], dim=1) # 256 and 256 to 512 along c dimension\n", - "# conv8 = self.conv8b(merge8) # 512 to 256\n", - "# conv8 = F.relu(conv8)\n", - "# conv8 = self.conv8c(conv8) # 256 to 256\n", - "# conv8 = F.relu(conv8)\n", - "# bn8 = self.bn8(conv8)\n", - "\n", - "# up9 = F.interpolate(bn8, scale_factor=2, mode=\"nearest\")\n", - "# up9 = self.conv9a(up9) # 256 to 128\n", - "# up9 = F.relu(up9)\n", - "# merge9 = torch.cat([bn1, up9], dim=1) # 128 and 128 to 256 along c dimension\n", - "# conv9 = self.conv9b(merge9) # 256 to 128\n", - "# conv9 = F.relu(conv9)\n", - "# conv9 = self.conv9c(conv9) # 128 to 128\n", - "# conv9 = F.relu(conv9) # no batch norm on last layer\n", - " \n", - "# final_layer_logits = self.final_conv(conv9)\n", - "\n", - "# # transpose from shape (b, c, h, w) back to (b, h, w, c) to align with training data\n", - "# final_layer_logits = torch.movedim(final_layer_logits, 1, -1) # move c from second to final dim\n", - "# b, h, w, c = final_layer_logits.shape\n", - "\n", - "\n", - "# # unpack c=classes*days dimension into classes, days as separate dimensions\n", - "# final_layer_logits = final_layer_logits.reshape((b, h, w, self.n_output_classes, self.n_forecast_days))\n", - "\n", - "# # output = F.softmax(final_layer_logits, dim=-2) # apply over n_output_classes dimension\n", - "# output = F.sigmoid(final_layer_logits) # Single output class.\n", - "# # output = final_layer_logits\n", - "\n", - "# # print(f\"Final layer shape: {output.shape}\")\n", - "# # print(f\"self.n_output_classes: {self.n_output_classes}\")\n", - "\n", - "# return output # shape (b, h, w, c, t)\n" - ] - }, - { - "cell_type": "code", - "execution_count": 23, - "metadata": {}, - "outputs": [], - "source": [ - "# model = UNet(\n", - "# input_channels=train_dataset._ds._config[\"num_channels\"],\n", - "# filter_size=3,\n", - "# n_filters_factor=1,\n", - "# n_forecast_days=train_dataset._ds._config[\"n_forecast_days\"]\n", - "# )\n", - "\n", - "# # Print the model architecture\n", - "# print(model)" - ] - }, - { - "cell_type": "code", - "execution_count": 24, - "metadata": {}, - "outputs": [], - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.nn.functional as F\n", - "\n", - "class Interpolate(nn.Module):\n", - " def __init__(self, scale_factor, mode):\n", - " super().__init__()\n", - " self.interp = F.interpolate\n", - " self.scale_factor = scale_factor\n", - " self.mode = mode\n", - "\n", - " def forward(self, x):\n", - " x = self.interp(x, scale_factor=self.scale_factor, mode=self.mode)\n", - " return x\n", - "\n", - "class UNet(nn.Module):\n", - " def __init__(self,\n", - " input_channels,\n", - " filter_size=3,\n", - " n_filters_factor=1,\n", - " n_forecast_days=7,\n", - " n_output_classes=1,\n", - " **kwargs\n", - " ):\n", - " super(UNet, self).__init__()\n", - "\n", - " self.input_channels = input_channels\n", - " self.filter_size = filter_size\n", - " self.n_filters_factor = n_filters_factor\n", - " self.n_forecast_days = n_forecast_days\n", - " self.n_output_classes = n_output_classes\n", - "\n", - " # Encoder\n", - " self.conv1 = self.conv_block(input_channels, int(64 * n_filters_factor))\n", - " self.conv2 = self.conv_block(int(64 * n_filters_factor), int(128 * n_filters_factor))\n", - " self.conv3 = self.conv_block(int(128 * n_filters_factor), int(256 * n_filters_factor))\n", - " self.conv4 = self.conv_block(int(256 * n_filters_factor), int(256 * n_filters_factor))\n", - "\n", - " # Bottleneck\n", - " self.conv5 = self.bottleneck_block(int(256 * n_filters_factor), int(512 * n_filters_factor))\n", - "\n", - " # Decoder\n", - " self.up6 = self.upconv_block(int(512 * n_filters_factor), int(256 * n_filters_factor))\n", - " self.up7 = self.upconv_block(int(256 * n_filters_factor), int(256 * n_filters_factor))\n", - " self.up8 = self.upconv_block(int(256 * n_filters_factor), int(128 * n_filters_factor))\n", - " self.up9 = self.upconv_block(int(128 * n_filters_factor), int(64 * n_filters_factor))\n", - "\n", - " self.up6b = self.conv_block(int(512 * n_filters_factor), int(256 * n_filters_factor))\n", - " self.up7b = self.conv_block(int(512 * n_filters_factor), int(256 * n_filters_factor))\n", - " self.up8b = self.conv_block(int(256 * n_filters_factor), int(128 * n_filters_factor))\n", - " self.up9b = self.conv_block(int(128 * n_filters_factor), int(64 * n_filters_factor), final=True)\n", - "\n", - "\n", - " # Final layer\n", - " self.final_layer = nn.Conv2d(int(64 * n_filters_factor), n_forecast_days, kernel_size=1, padding=\"same\")\n", - "\n", - " def forward(self, x):\n", - " # transpose from shape (b, h, w, c) to (b, c, h, w) for pytorch conv2d layers\n", - " x = torch.movedim(x, -1, 1) # move c from last to second dim\n", - "\n", - " # Encoder\n", - " bn1 = self.conv1(x)\n", - " conv1 = F.max_pool2d(bn1, kernel_size=2)\n", - " bn2 = self.conv2(conv1)\n", - " conv2 = F.max_pool2d(bn2, kernel_size=2)\n", - " bn3 = self.conv3(conv2)\n", - " conv3 = F.max_pool2d(bn3, kernel_size=2)\n", - " bn4 = self.conv4(conv3)\n", - " conv4 = F.max_pool2d(bn4, kernel_size=2)\n", - "\n", - " # conv3 = self.conv3(F.max_pool2d(conv2, kernel_size=2))\n", - " # conv4 = self.conv4(F.max_pool2d(conv3, kernel_size=2))\n", - " \n", - " # Bottleneck\n", - " bn5 = self.conv5(conv4)\n", - "\n", - " # Decoder\n", - " # up6 = self.up6(conv5) + conv4\n", - " # up7 = self.up7(up6) + conv3\n", - " # up8 = self.up8(up7) + conv2\n", - " # up9 = self.up9(up8) + conv1\n", - "\n", - " # # Final layer\n", - " # output = self.final_layer(up9)\n", - "\n", - " # print(\"Old shape: \", conv4.shape)\n", - " # print(\"New shape: \", self.up6(bn5).shape)\n", - "\n", - " up6 = self.up6b(torch.cat([bn4, self.up6(bn5)], dim=1))\n", - " up7 = self.up7b(torch.cat([bn3, self.up7(up6)], dim=1))\n", - " up8 = self.up8b(torch.cat([bn2, self.up8(up7)], dim=1))\n", - " up9 = self.up9b(torch.cat([bn1, self.up9(up8)], dim=1))\n", - "\n", - " # up6 = self.up6(conv5)\n", - " # up7 = self.up7(up6, conv4)\n", - " # up8 = self.up8(up7, conv3)\n", - " # up9 = self.up9(up8, conv2)\n", - "\n", - " # Final layer\n", - " # output = self.final_layer(up9)\n", - " output = self.final_layer(up9)\n", - "\n", - "\n", - " # up6 = torch.cat([conv5, self.up6(conv5)], dim=1)\n", - " # up7 = torch.cat([conv4, self.up7(up6)], dim=1)\n", - " # up8 = torch.cat([conv3, self.up8(up7)], dim=1)\n", - " # up9 = torch.cat([conv2, self.up9(up8)], dim=1)\n", - "\n", - " # # up6 = self.up6(conv5)\n", - " # # up7 = self.up7(up6, conv4)\n", - " # # up8 = self.up8(up7, conv3)\n", - " # # up9 = self.up9(up8, conv2)\n", - "\n", - " # # Final layer\n", - " # # output = self.final_layer(up9)\n", - " # output = torch.cat([conv1, self.final_layer(up9)], dim=1)\n", - "\n", - " # transpose from shape (b, c, h, w) back to (b, h, w, c) to align with training data\n", - " output = torch.movedim(output, 1, -1) # move c from second to final dim\n", - "\n", - " b, h, w, c = output.shape\n", - "\n", - " # unpack c=classes*months dimension into classes, months as separate dimensions\n", - " output = output.reshape((b, h, w, self.n_output_classes, self.n_forecast_days))\n", - "\n", - " return output\n", - "\n", - " def conv_block(self, in_channels, out_channels, kernel_size=3, final=False):\n", - " if not final:\n", - " return nn.Sequential(\n", - " nn.Conv2d(in_channels, out_channels, kernel_size=self.filter_size, padding=\"same\"),\n", - " nn.ReLU(inplace=True),\n", - " nn.Conv2d(out_channels, out_channels, kernel_size=self.filter_size, padding=\"same\"),\n", - " nn.ReLU(inplace=True),\n", - " nn.BatchNorm2d(num_features=out_channels),\n", - " # nn.MaxPool2d(kernel_size=(2, 2))\n", - " )\n", - " else:\n", - " return nn.Sequential(\n", - " nn.Conv2d(in_channels, out_channels, kernel_size=self.filter_size, padding=\"same\"),\n", - " nn.ReLU(inplace=True),\n", - " nn.Conv2d(out_channels, out_channels, kernel_size=self.filter_size, padding=\"same\"),\n", - " nn.ReLU(inplace=True),\n", - " nn.Conv2d(out_channels, out_channels, kernel_size=self.filter_size, padding=\"same\"),\n", - " nn.ReLU(inplace=True),\n", - " )\n", - "\n", - "\n", - " def bottleneck_block(self, in_channels, out_channels, kernel_size=3):\n", - " return nn.Sequential(\n", - " nn.Conv2d(in_channels, out_channels, kernel_size=self.filter_size, padding=\"same\"),\n", - " nn.ReLU(inplace=True),\n", - " nn.Conv2d(out_channels, out_channels, kernel_size=self.filter_size, padding=\"same\"),\n", - " nn.ReLU(inplace=True),\n", - " nn.BatchNorm2d(num_features=out_channels),\n", - " )\n", - "\n", - " def upconv_block(self, in_channels, out_channels, kernel_size=2):\n", - " return nn.Sequential(\n", - " # nn.ConvTranspose2d(in_channels, out_channels, kernel_size=self.filter_size, stride=2),\n", - " # nn.functional.interpolate(scale_factor=2, mode='nearest'),\n", - " Interpolate(scale_factor=2, mode='nearest'),\n", - " nn.Conv2d(in_channels, out_channels, kernel_size=2, padding=\"same\"),\n", - " nn.ReLU(inplace=True)\n", - " )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "New - Based on IceNet2" - ] - }, - { - "cell_type": "code", - "execution_count": 25, - "metadata": {}, - "outputs": [], - "source": [ - "# import torch\n", - "# import torch.nn as nn\n", - "# import torch.nn.functional as F\n", - "\n", - "# class UNet(nn.Module):\n", - "# \"\"\"\n", - "# An implementation of a UNet for pixelwise classification.\n", - "# \"\"\"\n", - " \n", - "# def __init__(self,\n", - "# input_channels, \n", - "# filter_size=3, \n", - "# n_filters_factor=1, \n", - "# n_forecast_days=7,\n", - "# n_output_classes=1,\n", - "# **kwargs):\n", - "# super(UNet, self).__init__()\n", - "\n", - "# self.input_channels = input_channels\n", - "# self.filter_size = filter_size\n", - "# self.n_filters_factor = n_filters_factor\n", - "# self.n_forecast_days = n_forecast_days\n", - "# self.n_output_classes = n_output_classes\n", - "\n", - "# self.conv1a = nn.Conv2d(in_channels=input_channels, \n", - "# out_channels=int(64*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv1b = nn.Conv2d(in_channels=int(64*n_filters_factor),\n", - "# out_channels=int(64*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn1 = nn.BatchNorm2d(num_features=int(64*n_filters_factor))\n", - "\n", - "# self.conv2a = nn.Conv2d(in_channels=int(64*n_filters_factor),\n", - "# out_channels=int(128*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv2b = nn.Conv2d(in_channels=int(128*n_filters_factor),\n", - "# out_channels=int(128*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn2 = nn.BatchNorm2d(num_features=int(128*n_filters_factor))\n", - "\n", - "# self.conv3a = nn.Conv2d(in_channels=int(128*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv3b = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn3 = nn.BatchNorm2d(num_features=int(256*n_filters_factor))\n", - "\n", - "# self.conv4a = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv4b = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn4 = nn.BatchNorm2d(num_features=int(256*n_filters_factor))\n", - "\n", - "# self.conv5a = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv5b = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(512*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn5 = nn.BatchNorm2d(num_features=int(512*n_filters_factor))\n", - "\n", - "# self.conv6a = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=2,\n", - "# padding=\"same\")\n", - "# self.conv6b = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv6c = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn6 = nn.BatchNorm2d(num_features=int(256*n_filters_factor))\n", - "\n", - "# self.conv7a = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=2,\n", - "# padding=\"same\")\n", - "# self.conv7b = nn.Conv2d(in_channels=int(512*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv7c = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(256*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn7 = nn.BatchNorm2d(num_features=int(256*n_filters_factor))\n", - "\n", - "# self.conv8a = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(128*n_filters_factor),\n", - "# kernel_size=2,\n", - "# padding=\"same\")\n", - "# self.conv8b = nn.Conv2d(in_channels=int(256*n_filters_factor),\n", - "# out_channels=int(128*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv8c = nn.Conv2d(in_channels=int(128*n_filters_factor),\n", - "# out_channels=int(128*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.bn8 = nn.BatchNorm2d(num_features=int(128*n_filters_factor))\n", - "\n", - "# self.conv9a = nn.Conv2d(in_channels=int(128*n_filters_factor),\n", - "# out_channels=int(64*n_filters_factor),\n", - "# kernel_size=2,\n", - "# padding=\"same\")\n", - "# self.conv9b = nn.Conv2d(in_channels=int(128*n_filters_factor),\n", - "# out_channels=int(64*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv9c = nn.Conv2d(in_channels=int(64*n_filters_factor),\n", - "# out_channels=int(64*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\")\n", - "# self.conv9d = nn.Conv2d(in_channels=int(64*n_filters_factor),\n", - "# out_channels=int(64*n_filters_factor),\n", - "# kernel_size=filter_size,\n", - "# padding=\"same\") # no batch norm on last layer\n", - "\n", - "# self.final_conv = nn.Conv2d(in_channels=int(64*n_filters_factor),\n", - "# out_channels=n_output_classes*n_forecast_days,\n", - "# kernel_size=1,\n", - "# padding=\"same\")\n", - " \n", - "# def forward(self, x):\n", - "\n", - "# # transpose from shape (b, h, w, c) to (b, c, h, w) for pytorch conv2d layers\n", - "# x = torch.movedim(x, -1, 1) # move c from last to second dim\n", - "\n", - "# # run through network\n", - "# conv1 = self.conv1a(x) # input to 64\n", - "# conv1 = F.relu(conv1)\n", - "# conv1 = self.conv1b(conv1) # 64 to 64\n", - "# conv1 = F.relu(conv1)\n", - "# bn1 = self.bn1(conv1)\n", - "# pool1 = F.max_pool2d(bn1, kernel_size=(2, 2))\n", - "\n", - "# conv2 = self.conv2a(pool1) # 64 to 128\n", - "# conv2 = F.relu(conv2)\n", - "# conv2 = self.conv2b(conv2) # 128 to 128\n", - "# conv2 = F.relu(conv2)\n", - "# bn2 = self.bn2(conv2)\n", - "# pool2 = F.max_pool2d(bn2, kernel_size=(2, 2))\n", - "\n", - "# conv3 = self.conv3a(pool2) # 128 to 256\n", - "# conv3 = F.relu(conv3)\n", - "# conv3 = self.conv3b(conv3) # 256 to 256\n", - "# conv3 = F.relu(conv3)\n", - "# bn3 = self.bn3(conv3)\n", - "# pool3 = F.max_pool2d(bn3, kernel_size=(2, 2))\n", - "\n", - "# conv4 = self.conv4a(pool3) # 256 to 256\n", - "# conv4 = F.relu(conv4)\n", - "# conv4 = self.conv4b(conv4) # 256 to 256\n", - "# conv4 = F.relu(conv4)\n", - "# bn4 = self.bn4(conv4)\n", - "# pool4 = F.max_pool2d(bn4, kernel_size=(2, 2))\n", - "\n", - "# conv5 = self.conv5a(pool4) # 256 to 512\n", - "# conv5 = F.relu(conv5)\n", - "# conv5 = self.conv5b(conv5) # 512 to 512\n", - "# conv5 = F.relu(conv5)\n", - "# bn5 = self.bn5(conv5)\n", - "\n", - "# up6 = F.interpolate(bn5, scale_factor=2, mode=\"nearest\")\n", - "# up6 = self.conv6a(up6) # 512 to 256\n", - "# up6 = F.relu(up6)\n", - "# merge6 = torch.cat([bn4, up6], dim=1) # 256 and 526 to 512 along c dimension\n", - "# conv6 = self.conv6b(merge6) # 512 to 256\n", - "# conv6 = F.relu(conv6)\n", - "# conv6 = self.conv6c(conv6) # 256 to 256\n", - "# conv6 = F.relu(conv6)\n", - "# bn6 = self.bn6(conv6)\n", - "\n", - "# up7 = F.interpolate(bn6, scale_factor=2, mode=\"nearest\")\n", - "# up7 = self.conv7a(up7) # 512 to 256\n", - "# up7 = F.relu(up7)\n", - "# merge7 = torch.cat([bn3, up7], dim=1) # 256 and 256 to 512 along c dimension\n", - "# conv7 = self.conv7b(merge7) # 512 to 256\n", - "# conv7 = F.relu(conv7)\n", - "# conv7 = self.conv7c(conv7) # 256 to 256\n", - "# conv7 = F.relu(conv7)\n", - "# bn7 = self.bn7(conv7)\n", - "\n", - "# up8 = F.interpolate(bn7, scale_factor=2, mode=\"nearest\")\n", - "# up8 = self.conv8a(up8) # 256 to 128\n", - "# up8 = F.relu(up8)\n", - "# merge8 = torch.cat([bn2, up8], dim=1) # 128 and 128 to 256 along c dimension\n", - "# conv8 = self.conv8b(merge8) # 256 to 128\n", - "# conv8 = F.relu(conv8)\n", - "# conv8 = self.conv8c(conv8) # 128 to 128\n", - "# conv8 = F.relu(conv8)\n", - "# bn8 = self.bn8(conv8)\n", - "\n", - "# up9 = F.interpolate(bn8, scale_factor=2, mode=\"nearest\")\n", - "# up9 = self.conv9a(up9) # 128 to 64\n", - "# up9 = F.relu(up9)\n", - "# merge9 = torch.cat([bn1, up9], dim=1) # 64 and 64 to 128 along c dimension\n", - "# conv9 = self.conv9b(merge9) # 128 to 64\n", - "# conv9 = F.relu(conv9)\n", - "# conv9 = self.conv9c(conv9) # 64 to 64\n", - "# conv9 = F.relu(conv9)\n", - "# conv9 = self.conv9d(conv9) # 64 to 64\n", - "# conv9 = F.relu(conv9) # no batch norm on last layer\n", - " \n", - "# final_layer_logits = self.final_conv(conv9)\n", - "\n", - "# # transpose from shape (b, c, h, w) back to (b, h, w, c) to align with training data\n", - "# final_layer_logits = torch.movedim(final_layer_logits, 1, -1) # move c from second to final dim\n", - "# b, h, w, c = final_layer_logits.shape\n", - "\n", - "# # unpack c=classes*months dimension into classes, months as separate dimensions\n", - "# final_layer_logits = final_layer_logits.reshape((b, h, w, self.n_output_classes, self.n_forecast_days))\n", - "\n", - "# return final_layer_logits\n", - "\n", - "# # # output = F.softmax(final_layer_logits, dim=-2) # apply over n_output_classes dimension\n", - "# # output = F.sigmoid(final_layer_logits)\n", - "\n", - "# # return output # shape (b, h, w, c, t)" - ] - }, - { - "cell_type": "code", - "execution_count": 26, - "metadata": {}, - "outputs": [], - "source": [ - "# import torch\n", - "# import torch.nn as nn\n", - "# import torch.nn.functional as F\n", - "\n", - "# # class UNetBatchNorm(nn.Module):\n", - "# class UNet(nn.Module):\n", - "# def __init__(self, input_channels, filter_size=3, n_filters_factor=1, n_forecast_days=6):\n", - "# super(UNet, self).__init__()\n", - "# self.input_channels = input_channels\n", - "# self.filter_size = filter_size\n", - "# self.n_filters_factor = n_filters_factor\n", - "# self.n_output_classes = 1\n", - "# self.n_forecast_days = n_forecast_days\n", - "\n", - "# # Encoder\n", - "# self.conv1 = self.conv_block(input_channels, int(64 * n_filters_factor))\n", - "# self.conv2 = self.conv_block(int(64 * n_filters_factor), int(128 * n_filters_factor))\n", - "# self.conv3 = self.conv_block(int(128 * n_filters_factor), int(256 * n_filters_factor))\n", - "# self.conv4 = self.conv_block(int(256 * n_filters_factor), int(256 * n_filters_factor))\n", - "# self.conv5 = self.conv_block(int(256 * n_filters_factor), int(512 * n_filters_factor))\n", - "\n", - "# # Decoder\n", - "# self.up6 = self.upconv_block(int(512 * n_filters_factor), int(256 * n_filters_factor))\n", - "# self.up7 = self.upconv_block(int(256 * n_filters_factor), int(256 * n_filters_factor))\n", - "# self.up8 = self.upconv_block(int(256 * n_filters_factor), int(128 * n_filters_factor))\n", - "# self.up9 = self.upconv_block(int(128 * n_filters_factor), int(64 * n_filters_factor))\n", - "\n", - "# # Final layer\n", - "# self.final_layer = nn.Conv2d(int(64 * n_filters_factor), n_forecast_days, kernel_size=1)\n", - "\n", - "# def conv_block(self, in_channels, out_channels, kernel_size=3):\n", - "# return nn.Sequential(\n", - "# nn.Conv2d(in_channels, out_channels, kernel_size, padding=\"same\"),\n", - "# nn.ReLU(inplace=True),\n", - "# nn.Conv2d(out_channels, out_channels, kernel_size, padding=\"same\"),\n", - "# nn.ReLU(inplace=True),\n", - "# nn.BatchNorm2d(out_channels)\n", - "# )\n", - "\n", - "# def upconv_block(self, in_channels, out_channels, kernel_size=2):\n", - "# return nn.Sequential(\n", - "# nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride=2),\n", - "# nn.ReLU(inplace=True)\n", - "# )\n", - "\n", - "# def forward(self, x):\n", - "# n_filters_factor = self.n_filters_factor\n", - "\n", - "# # transpose from shape (b, h, w, c) to (b, c, h, w) for pytorch conv2d layers\n", - "# x = torch.movedim(x, -1, 1) # move c from last to second dim\n", - "\n", - "# # Encoder\n", - "# conv1 = self.conv1(x)\n", - "# pool1 = F.max_pool2d(conv1, 2)\n", - "\n", - "# conv2 = self.conv2(pool1)\n", - "# pool2 = F.max_pool2d(conv2, 2)\n", - "\n", - "# conv3 = self.conv3(pool2)\n", - "# pool3 = F.max_pool2d(conv3, 2)\n", - "\n", - "# conv4 = self.conv4(pool3)\n", - "# pool4 = F.max_pool2d(conv4, 2)\n", - "\n", - "# conv5 = self.conv5(pool4)\n", - "\n", - "# # Decoder\n", - "# up6 = self.up6(conv5)\n", - "# print(\"Input shape:\", up6.shape)\n", - "# merge6 = torch.cat([conv4, up6], dim=1)\n", - "# print(\"Output shape:\", merge6.shape)\n", - "# conv6 = self.conv_block(int(512 * n_filters_factor), int(256 * n_filters_factor))(merge6)\n", - "\n", - "# up7 = self.up7(conv6)\n", - "# merge7 = torch.cat([conv3, up7], dim=1)\n", - "# conv7 = self.conv_block(int(256 * n_filters_factor), int(256 * n_filters_factor))(merge7)\n", - "\n", - "# up8 = self.up8(conv7)\n", - "# merge8 = torch.cat([conv2, up8], dim=1)\n", - "# conv8 = self.conv_block(int(256 * n_filters_factor), int(128 * n_filters_factor))(merge8)\n", - "\n", - "# up9 = self.up9(conv8)\n", - "# merge9 = torch.cat([conv1, up9], dim=1)\n", - "# conv9 = self.conv_block(int(128 * n_filters_factor), int(64 * n_filters_factor))(merge9)\n", - "\n", - "# # Final layer\n", - "# output = self.final_layer(conv9)\n", - "\n", - "# # transpose from shape (b, c, h, w) back to (b, h, w, c) to align with training data\n", - "# output = torch.movedim(output, 1, -1) # move c from second to final dim\n", - "\n", - "# return output\n", - "\n", - "# # # Instantiate the model\n", - "# # input_channels = train_dataset._ds._config[\"num_channels\"] # Adjust based on your input data\n", - "# # n_forecast_days = 7\n", - "# # n_filters_factor = 1\n", - "# # filter_size = 3\n", - "# # model = UNet(input_channels, filter_size, n_filters_factor, n_forecast_days)\n", - "\n", - "# # # Print the model architecture\n", - "# # print(model)" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "metadata": {}, - "outputs": [], - "source": [ - "from torchmetrics import Metric\n", - "\n", - "class IceNetAccuracy(Metric):\n", - " \"\"\"Binary accuracy metric for use at multiple leadtimes.\n", - "\n", - " Reference: https://lightning.ai/docs/torchmetrics/stable/pages/implement.html\n", - " \"\"\" \n", - "\n", - " # Set class properties\n", - " is_differentiable: bool = False\n", - " higher_is_better: bool = True\n", - " full_state_update: bool = True\n", - "\n", - " def __init__(self, leadtimes_to_evaluate: list):\n", - " \"\"\"Custom loss/metric for binary accuracy in classifying SIC>15% for multiple leadtimes.\n", - "\n", - " Args:\n", - " leadtimes_to_evaluate: A list of leadtimes to consider\n", - " e.g., [0, 1, 2, 3, 4, 5] to consider first six days in accuracy computation or\n", - " e.g., [0] to only look at the first day's accuracy\n", - " e.g., [5] to only look at the sixth day's accuracy\n", - " \"\"\"\n", - " super().__init__()\n", - " self.leadtimes_to_evaluate = leadtimes_to_evaluate\n", - " self.add_state(\"weighted_score\", default=torch.tensor(0.), dist_reduce_fx=\"sum\")\n", - " self.add_state(\"possible_score\", default=torch.tensor(0.), dist_reduce_fx=\"sum\")\n", - "\n", - " def update(self, preds: torch.Tensor, target: torch.Tensor, sample_weight: torch.Tensor):\n", - " # preds and target are shape (b, h, w, t)\n", - " # sum marginal and full ice for binary eval\n", - " # print(f\"preds shape: {preds.shape}\")\n", - " # print(f\"target shape: {target.shape}\")\n", - " preds = (preds > 0.15).long() # torch.Size([2, 432, 432, 7])\n", - " target = (target > 0.15).long() # torch.Size([2, 432, 432, 7])\n", - " # sample_weight = sample_weight.squeeze(dim=-1) # torch.Size([2, 432, 432, 7, 1]) to torch.Size([2, 432, 432, 7])\n", - " # print(f\"preds shape: {preds.shape}\")\n", - " # print(f\"target shape: {target.shape}\")\n", - " # print(f\"sample_weight shape: {sample_weight.squeeze(dim=-1).shape}\")\n", - " base_score = preds[:, :, :, self.leadtimes_to_evaluate] == target[:, :, :, self.leadtimes_to_evaluate]\n", - " self.weighted_score += torch.sum(base_score * sample_weight[:, :, :, self.leadtimes_to_evaluate])\n", - " self.possible_score += torch.sum(sample_weight[:, :, :, self.leadtimes_to_evaluate])\n", - "\n", - " def compute(self):\n", - " return self.weighted_score.float() / self.possible_score * 100.0\n", - "\n", - "\n", - "class SIEError(Metric):\n", - " \"\"\"\n", - " Sea Ice Extent error metric (in km^2) for use at multiple leadtimes.\n", - " \"\"\" \n", - "\n", - " # Set class properties\n", - " is_differentiable: bool = False\n", - " higher_is_better: bool = False\n", - " full_state_update: bool = True\n", - "\n", - " def __init__(self, leadtimes_to_evaluate: list):\n", - " \"\"\"Construct an SIE error metric (in km^2) for use at multiple leadtimes.\n", - " leadtimes_to_evaluate: A list of leadtimes to consider\n", - " e.g., [0, 1, 2, 3, 4, 5] to consider six days in computation or\n", - " e.g., [0] to only look at the first day\n", - " e.g., [5] to only look at the sixth day\n", - " \"\"\"\n", - " super().__init__()\n", - " self.leadtimes_to_evaluate = leadtimes_to_evaluate\n", - " self.add_state(\"pred_sie\", default=torch.tensor(0.), dist_reduce_fx=\"sum\")\n", - " self.add_state(\"true_sie\", default=torch.tensor(0.), dist_reduce_fx=\"sum\")\n", - "\n", - " def update(self, preds: torch.Tensor, target: torch.Tensor, sample_weight: torch.Tensor):\n", - " # preds and target are shape (b, h, w, t)\n", - " preds = (preds > 0.15).long()\n", - " target = (target > 0.15).long()\n", - " self.pred_sie += preds[:, :, :, self.leadtimes_to_evaluate].sum()\n", - " self.true_sie += target[:, :, :, self.leadtimes_to_evaluate].sum()\n", - "\n", - " def compute(self):\n", - " return (self.pred_sie - self.true_sie) * 25**2 # each pixel is 25x25 km" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Loss function" - ] - }, - { - "cell_type": "code", - "execution_count": 28, - "metadata": {}, - "outputs": [], - "source": [ - "# def loss_func(output, target, sample_weight):\n", - "# \"\"\"BCEWithLogitsLoss\"\"\"\n", - "# # criterion = nn.BCEWithLogitsLoss(reduction='none')\n", - "# # loss = criterion((output.movedim(-2, 1)), (target.movedim(-1, 1)))\n", - "# # loss = torch.mean(loss * sample_weight.movedim(-1, 1))\n", - "\n", - "# # Convert continuous target values to binary labels for BCELoss calculation\n", - "# targets = torch.round(target)\n", - "\n", - "# criterion = nn.BCEWithLogitsLoss(reduction='none')\n", - "# loss = criterion(\n", - "# (output.movedim(-2, 1)), \n", - "# (targets.movedim(-1, 1))\n", - "# )\n", - "# loss = torch.mean(loss*sample_weight.movedim(-1, 1))\n", - "\n", - "# return loss\n", - "\n", - "# def loss_func(output, target, sample_weight):\n", - "# \"\"\"L1 Loss\"\"\"\n", - "# y_hat = torch.sigmoid(output)\n", - " \n", - "# # criterion = nn.L1Loss(reduction=\"none\")\n", - "# # loss = criterion(\n", - "# # (100*y_hat.movedim(-2, 1)), \n", - "# # (100*target.movedim(-1, 1))\n", - "# # )\n", - "# # loss = torch.mean(loss*sample_weight.movedim(-1, 1))\n", - "\n", - "# loss = torch.mean(\n", - "# (\n", - "# 100*( torch.abs( y_hat.movedim(-2, 1) - target.movedim(-1, 1) ) )\n", - "# )*sample_weight.movedim(-1, 1)\n", - "# )\n", - "\n", - "# return loss\n", - "\n", - "def loss_func(output, target, sample_weight):\n", - " \"\"\"L2 Loss\"\"\"\n", - " y_hat = torch.sigmoid(output)\n", - " # criterion = nn.MSELoss(reduction=\"none\")\n", - " # loss = criterion(\n", - " # (100*y_hat.movedim(-2, 1)), \n", - " # (100*target.movedim(-1, 1))\n", - " # )\n", - " # loss = torch.mean(loss*sample_weight.movedim(-1, 1))\n", - "\n", - " # plot_image(y_hat.numpy(force=True), title=\"output\")\n", - " # plot_image(target.numpy(force=True), title=\"target\")\n", - " # plot_image(sample_weight.cpu(), title=\"mask\")\n", - " # loss_calc = ((\n", - " # ( ( y_hat.movedim(-2, 1) - target.movedim(-1, 1) )*100 )**2\n", - " # )*sample_weight.movedim(-1, 1)).movedim(1, -1)\n", - " # plot_image(loss_calc.numpy(force=True), title=\"losscalc\")\n", - " # # return\n", - "\n", - " loss = torch.mean(\n", - " (\n", - " ( ( y_hat.movedim(-2, 1) - target.movedim(-1, 1) )*100 )**2\n", - " )*sample_weight.movedim(-1, 1)\n", - " )\n", - "\n", - " return loss" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "A _LightningModule_ wrapper for UNet model." - ] - }, - { - "cell_type": "code", - "execution_count": 29, - "metadata": {}, - "outputs": [], - "source": [ - "import lightning.pytorch as pl\n", - "from lightning.pytorch.utilities.types import TRAIN_DATALOADERS\n", - "from torchmetrics import MetricCollection\n", - "\n", - "class LitUNet(pl.LightningModule):\n", - " \"\"\"\n", - " A LightningModule wrapping the UNet implementation of IceNet.\n", - " \"\"\"\n", - " def __init__(self,\n", - " model: nn.Module,\n", - " criterion: callable,\n", - " learning_rate: float):\n", - " \"\"\"\n", - " Construct a UNet LightningModule.\n", - " Note that we keep hyperparameters separate from dataloaders to prevent data leakage at test time.\n", - " :param model: PyTorch model\n", - " :param criterion: PyTorch loss function for training instantiated with reduction=\"none\"\n", - " :param learning_rate: Float learning rate for our optimiser\n", - " \"\"\"\n", - " super().__init__()\n", - " self.model = model\n", - " self.criterion = criterion\n", - " self.learning_rate = learning_rate\n", - " self.n_output_classes = model.n_output_classes # this should be a property of the network\n", - "\n", - " metrics = {\n", - " \"val_accuracy\": IceNetAccuracy(leadtimes_to_evaluate=list(range(self.model.n_forecast_days))),\n", - " # \"val_sieerror\": SIEError(leadtimes_to_evaluate=list(range(self.model.n_forecast_days)))\n", - " }\n", - " for i in range(self.model.n_forecast_days):\n", - " metrics[f\"val_accuracy_{i}\"] = IceNetAccuracy(leadtimes_to_evaluate=[i])\n", - " # metrics[f\"val_sieerror_{i}\"] = SIEError(leadtimes_to_evaluate=[i])\n", - " self.metrics = MetricCollection(metrics)\n", - "\n", - " test_metrics = {\n", - " \"test_accuracy\": IceNetAccuracy(leadtimes_to_evaluate=list(range(self.model.n_forecast_days))),\n", - " # \"test_sieerror\": SIEError(leadtimes_to_evaluate=list(range(self.model.n_forecast_days)))\n", - " }\n", - " for i in range(self.model.n_forecast_days):\n", - " test_metrics[f\"test_accuracy_{i}\"] = IceNetAccuracy(leadtimes_to_evaluate=[i])\n", - " # test_metrics[f\"test_sieerror_{i}\"] = SIEError(leadtimes_to_evaluate=[i])\n", - " self.test_metrics = MetricCollection(test_metrics)\n", - "\n", - " # Save input parameters to __init__ (hyperparams) when checkpointing.\n", - " # self.save_hyperparameters(ignore=[\"model\", \"criterion\"])\n", - " self.save_hyperparameters()\n", - "\n", - " def forward(self, x):\n", - " \"\"\"\n", - " Implement forward function.\n", - " :param x: Inputs to model.\n", - " :return: Outputs of model.\n", - " \"\"\"\n", - " return self.model(x)\n", - "\n", - " def training_step(self, batch):\n", - " \"\"\"\n", - " Perform a pass through a batch of training data.\n", - " Apply pixel-weighted loss by manually reducing.\n", - " See e.g. https://discuss.pytorch.org/t/unet-pixel-wise-weighted-loss-function/46689/5.\n", - " :param batch: Batch of input, output, weight triplets\n", - " :param batch_idx: Index of batch\n", - " :return: Loss from this batch of data for use in backprop\n", - " \"\"\"\n", - " x, y, sample_weight = batch\n", - " outputs = self.model(x)\n", - " # y_hat = torch.sigmoid(outputs)\n", - "\n", - " # For cross-entropy loss\n", - " # loss = self.criterion(y_hat.movedim(-2, 1)*100, y.movedim(-1, 1)*100)\n", - " # loss = torch.mean(loss * sample_weight.movedim(-2, 1))\n", - "\n", - " # Use weighted mean squared error as loss function, matching IceNet 2.\n", - " # Mean squared error of SIC (%) (float)\n", - " # loss = torch.mean(\n", - " # (\n", - " # ( y_hat.movedim(-2, 1)*100 - y.movedim(-1, 1)*100 )**2.\n", - " # ) * sample_weight.movedim(-2, 1)\n", - " # )\n", - "\n", - " # criterion = nn.BCEWithLogitsLoss(reduction='none')\n", - " # loss = criterion((outputs.movedim(-2, 1)), (y.movedim(-1, 1)))\n", - " # loss = torch.mean(loss * sample_weight.movedim(-1, 1))\n", - "\n", - " loss = loss_func(outputs, y, sample_weight)\n", - "\n", - " self.log(\"train_loss\", loss, on_step=True, on_epoch=True, prog_bar=True, sync_dist=True)\n", - " return {\"loss\": loss}\n", - "\n", - " def validation_step(self, batch):\n", - " # x: (b, h, w, channels), y: (b, h, w, n_forecast_days, classes), sample_weight: (b, h, w, n_forecast_days, classes)\n", - " x, y, sample_weight = batch\n", - " # y_hat: (b, h, w, classes, n_forecast_days)\n", - " outputs = self.model(x)\n", - " y_hat = torch.sigmoid(outputs)\n", - " # print(f\"x, y, sample_weight shapes: {x.shape}, {y.shape}, {sample_weight.shape}\")\n", - " # print(f\"y_hat shape: {y_hat.shape}\")\n", - "\n", - " # For cross-entropy loss\n", - " # loss = self.criterion(y_hat.movedim(-2, 1)*100, y.movedim(-1, 1)*100)\n", - " # loss = torch.mean(loss * sample_weight.movedim(-2, 1))\n", - " # Use weighted mean squared error as loss function, matching IceNet 2.\n", - " # Mean squared error of SIC (%) (float)\n", - " # loss = torch.mean(\n", - " # (\n", - " # ( y_hat.movedim(-2, 1)*100 - y.movedim(-1, 1)*100 )**2.\n", - " # ) * sample_weight.movedim(-2, 1)\n", - " # )\n", - "\n", - " # criterion = nn.BCEWithLogitsLoss(reduction='none')\n", - " # loss = criterion((outputs.movedim(-2, 1)), (y.movedim(-1, 1)))\n", - " # loss = torch.mean(loss * sample_weight.movedim(-1, 1))\n", - "\n", - " loss = loss_func(outputs, y, sample_weight)\n", - "\n", - " self.log(\"val_loss\", loss, on_step=False, on_epoch=True, prog_bar=True, sync_dist=True) # epoch-level loss\n", - " # y_hat_pred = y_hat.argmax(dim=-2).long() # argmax over c where shape is (b, h, w, c, t)\n", - " # self.metrics.update(y_hat_pred, y.argmax(dim=-1).long(), sample_weight.squeeze(dim=-1)) # shape (b, h, w, t)\n", - "\n", - " self.metrics.update(y_hat.squeeze(dim=-2), y.squeeze(dim=-1), sample_weight.squeeze(dim=-1))\n", - "\n", - " return {\"val_loss\", loss}\n", - "\n", - " def on_validation_epoch_end(self):\n", - " self.log_dict(self.metrics.compute(), on_step=False, on_epoch=True, prog_bar=True, sync_dist=True) # epoch-level metrics\n", - " self.metrics.reset()\n", - "\n", - " def test_step(self, batch):\n", - " x, y, sample_weight = batch\n", - " outputs = self.model(x)\n", - " y_hat = torch.sigmoid(outputs)\n", - " # print(f\"x, y, sample_weight shapes: {x.shape}, {y.shape}, {sample_weight.shape}\")\n", - " # print(f\"y_hat shape: {y_hat.shape}\")\n", - " # Use weighted mean squared error as loss function, matching IceNet 2.\n", - " # Mean squared error of SIC (%) (float)\n", - " # loss = self.criterion(y_hat.movedim(-2, 1)*100, y.movedim(-1, 1)*100)\n", - " # loss = torch.mean(loss * sample_weight.movedim(-2, 1))\n", - " # loss = torch.mean(\n", - " # (\n", - " # ( y_hat.movedim(-2, 1)*100 - y.movedim(-1, 1)*100 )**2.\n", - " # ) * sample_weight.movedim(-2, 1)\n", - " # )\n", - "\n", - " # criterion = nn.BCEWithLogitsLoss(reduction='none')\n", - " # loss = criterion((outputs.movedim(-2, 1)), (y.movedim(-1, 1)))\n", - " # loss = torch.mean(loss * sample_weight.movedim(-1, 1))\n", - "\n", - " loss = loss_func(outputs, y, sample_weight)\n", - "\n", - " self.log(\"test_loss\", loss, on_step=False, on_epoch=True, prog_bar=True, sync_dist=True) # epoch-level loss\n", - " # y_hat_pred = y_hat.argmax(dim=-2) # argmax over c where shape is (b, h, w, c, t)\n", - " # self.test_metrics.update(y_hat_pred, y.argmax(dim=-1).long(), sample_weight.squeeze(dim=-1)) # shape (b, h, w, t)\n", - "\n", - " self.test_metrics.update(y_hat.squeeze(dim=-2), y.squeeze(dim=-1), sample_weight.squeeze(dim=-1))\n", - " \n", - " return loss\n", - "\n", - " def on_test_epoch_end(self):\n", - " self.log_dict(self.test_metrics.compute(), on_step=False, on_epoch=True, sync_dist=True) # epoch-level metrics\n", - " self.test_metrics.reset()\n", - "\n", - "\n", - " def predict_step(self, batch):\n", - " \"\"\"\n", - " :param batch: Batch of input, output, weight triplets\n", - " :param batch_idx: Index of batch\n", - " :return: Predictions for given input.\n", - " \"\"\"\n", - " x, y, sample_weight = batch\n", - " y_hat = torch.sigmoid(self.model(x))\n", - "\n", - " return y_hat\n", - "\n", - " def configure_optimizers(self):\n", - " optimizer = torch.optim.Adam(self.parameters(), lr=self.learning_rate)\n", - " return {\n", - " \"optimizer\": optimizer\n", - " }\n", - "\n", - " # def train_dataloader(self) -> TRAIN_DATALOADERS:\n", - " # return super().train_dataloader()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Function for training UNet model using PyTorch Lightning." - ] - }, - { - "cell_type": "code", - "execution_count": 30, - "metadata": {}, - "outputs": [], - "source": [ - "from lightning.pytorch.callbacks import ModelCheckpoint\n", - "\n", - "def train_icenet(configuration_path,\n", - " learning_rate,\n", - " max_epochs,\n", - " batch_size,\n", - " n_workers,\n", - " filter_size,\n", - " n_filters_factor,\n", - " seed):\n", - " \"\"\"\n", - " Train IceNet using the arguments specified in the `args` namespace.\n", - " :param args: Namespace of configuration parameters\n", - " \"\"\"\n", - " # init\n", - " pl.seed_everything(seed)\n", - " \n", - " # configure datasets and dataloaders\n", - " train_dataset = IceNetDataSetPyTorch(configuration_path, mode=\"train\")\n", - " val_dataset = IceNetDataSetPyTorch(configuration_path, mode=\"val\")\n", - " train_dataloader = DataLoader(train_dataset, batch_size=batch_size, num_workers=n_workers,\n", - " persistent_workers=True, shuffle=False)\n", - " val_dataloader = DataLoader(val_dataset, batch_size=batch_size, num_workers=n_workers,\n", - " persistent_workers=True, shuffle=False)\n", - "\n", - " # print(\"Input train shapes: \")\n", - " # for batch in train_dataloader:\n", - " # [print(batch[i].shape, end='') for i in range(3)]\n", - " # print()\n", - "\n", - " # print(\"Input val shapes: \")\n", - " # for batch in val_dataloader:\n", - " # [print(batch[i].shape, end='') for i in range(3)]\n", - " # print()\n", - "\n", - " # construct unet\n", - " model = UNet(\n", - " input_channels=train_dataset._ds._config[\"num_channels\"],\n", - " filter_size=filter_size,\n", - " n_filters_factor=n_filters_factor,\n", - " n_forecast_days=train_dataset._ds._config[\"n_forecast_days\"]\n", - " )\n", - " \n", - " # criterion = nn.CrossEntropyLoss(reduction=\"none\")\n", - " criterion = nn.MSELoss(reduction=\"none\")\n", - " # from torchvision.ops.focal_loss import sigmoid_focal_loss\n", - " # criterion = sigmoid_focal_loss\n", - " \n", - " # configure PyTorch Lightning module\n", - " lit_module = LitUNet(\n", - " model=model,\n", - " criterion=criterion,\n", - " learning_rate=learning_rate\n", - " )\n", - "\n", - " # set up trainer configuration\n", - " trainer = pl.Trainer(\n", - " accelerator=\"auto\",\n", - " devices=1,\n", - " log_every_n_steps=5,\n", - " max_epochs=max_epochs,\n", - " num_sanity_val_steps=1,\n", - " fast_dev_run=False, # Runs single batch through train and validation\n", - " # when running trainer.test()\n", - " # Note: Cannot use with automatic best checkpointing\n", - " )\n", - " checkpoint_callback = ModelCheckpoint(monitor=\"val_accuracy\", mode=\"max\")\n", - " trainer.callbacks.append(checkpoint_callback)\n", - "\n", - " # train model\n", - " print(f\"Training {len(train_dataset)} examples / {len(train_dataloader)} batches (batch size {batch_size}).\")\n", - " print(f\"Validating {len(val_dataset)} examples / {len(val_dataloader)} batches (batch size {batch_size}).\")\n", - " trainer.fit(lit_module, train_dataloader, val_dataloader)\n", - "\n", - " return model, trainer, checkpoint_callback" - ] - }, - { - "cell_type": "code", - "execution_count": 31, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO: Seed set to 45\n", - "INFO:lightning.fabric.utilities.seed:Seed set to 45\n", - "INFO:root:Loading configuration dataset_config.pytorch_notebook.json\n", - "WARNING:root:Running in configuration only mode, tfrecords were not generated for this dataset\n", - "INFO:root:Loading configuration /data/hpcdata/users/bryald/git/icenet/notebook-pipeline/loader.notebook_api_data.json\n", - "INFO:root:Loading configuration dataset_config.pytorch_notebook.json\n", - "WARNING:root:Running in configuration only mode, tfrecords were not generated for this dataset\n", - "INFO:root:Loading configuration /data/hpcdata/users/bryald/git/icenet/notebook-pipeline/loader.notebook_api_data.json\n", - "/data/hpcdata/users/bryald/miniconda3/envs/pytorch/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:198: Attribute 'model' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['model'])`.\n", - "/data/hpcdata/users/bryald/miniconda3/envs/pytorch/lib/python3.11/site-packages/lightning/pytorch/utilities/parsing.py:198: Attribute 'criterion' is an instance of `nn.Module` and is already saved during checkpointing. It is recommended to ignore them using `self.save_hyperparameters(ignore=['criterion'])`.\n", - "/data/hpcdata/users/bryald/miniconda3/envs/pytorch/lib/python3.11/site-packages/lightning/fabric/plugins/environments/slurm.py:191: The `srun` command is available on your system but is not used. HINT: If your intention is to run Lightning on SLURM, prepend your python command with `srun` like so: srun python /data/hpcdata/users/bryald/miniconda3/envs/pytorch/l ...\n", - "INFO: GPU available: True (cuda), used: True\n", - "INFO:lightning.pytorch.utilities.rank_zero:GPU available: True (cuda), used: True\n", - "INFO: TPU available: False, using: 0 TPU cores\n", - "INFO:lightning.pytorch.utilities.rank_zero:TPU available: False, using: 0 TPU cores\n", - "INFO: IPU available: False, using: 0 IPUs\n", - "INFO:lightning.pytorch.utilities.rank_zero:IPU available: False, using: 0 IPUs\n", - "INFO: HPU available: False, using: 0 HPUs\n", - "INFO:lightning.pytorch.utilities.rank_zero:HPU available: False, using: 0 HPUs\n", - "INFO: You are using a CUDA device ('NVIDIA A2') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", - "INFO:lightning.pytorch.utilities.rank_zero:You are using a CUDA device ('NVIDIA A2') that has Tensor Cores. To properly utilize them, you should set `torch.set_float32_matmul_precision('medium' | 'high')` which will trade-off precision for performance. For more details, read https://pytorch.org/docs/stable/generated/torch.set_float32_matmul_precision.html#torch.set_float32_matmul_precision\n", - "INFO: LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Training 91 examples / 23 batches (batch size 4).\n", - "Validating 21 examples / 6 batches (batch size 4).\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:lightning.pytorch.accelerators.cuda:LOCAL_RANK: 0 - CUDA_VISIBLE_DEVICES: [0]\n", - "INFO: \n", - " | Name | Type | Params\n", - "--------------------------------------------------\n", - "0 | model | UNet | 11.0 M\n", - "1 | criterion | MSELoss | 0 \n", - "2 | metrics | MetricCollection | 0 \n", - "3 | test_metrics | MetricCollection | 0 \n", - "--------------------------------------------------\n", - "11.0 M Trainable params\n", - "0 Non-trainable params\n", - "11.0 M Total params\n", - "43.817 Total estimated model params size (MB)\n", - "INFO:lightning.pytorch.callbacks.model_summary:\n", - " | Name | Type | Params\n", - "--------------------------------------------------\n", - "0 | model | UNet | 11.0 M\n", - "1 | criterion | MSELoss | 0 \n", - "2 | metrics | MetricCollection | 0 \n", - "3 | test_metrics | MetricCollection | 0 \n", - "--------------------------------------------------\n", - "11.0 M Trainable params\n", - "0 Non-trainable params\n", - "11.0 M Total params\n", - "43.817 Total estimated model params size (MB)\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Sanity Checking DataLoader 0: 0%| | 0/1 [00:00" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "fig = plt.figure(figsize=(18, 10))\n", - "\n", - "plt.imshow(prediction[0, :, :, 0, 0])\n", - "plt.xticks([])\n", - "plt.yticks([])\n", - "plt.colorbar(shrink=0.6)\n", - "\n", - "plt.suptitle(\"UNet Mean Forecast\")\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "code", - "execution_count": 39, - "metadata": {}, - "outputs": [ - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "import matplotlib.pyplot as plt\n", - "\n", - "fig, ax = plt.subplots(7, 7, figsize=(18, 10))\n", - "ax = ax.ravel()\n", - "\n", - "idx = 0\n", - "for workers, prediction in enumerate(predictions):\n", - " for batch in range(prediction.shape[0]):\n", - " # print(idx, worker, batch, prediction.shape, prediction[0, :, :, :, 0].shape)\n", - " for day in range(prediction.shape[-1]): # Loop through no. of forecast days (currently 7)\n", - " im = ax[idx].imshow(prediction[batch, :, :, 0, day], extent=[0, 1, 0, 1])\n", - " ax[idx].axis(\"off\")\n", - " plt.colorbar(im, ax=ax[idx], shrink=0.6)\n", - " idx += 1\n", - "\n", - "\n", - "plt.suptitle(\"UNet Mean Forecast\")\n", - "plt.subplots_adjust(wspace=0, hspace=0)\n", - "plt.margins(0)\n", - "plt.tight_layout()\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Create prediction output directory" - ] - }, - { - "cell_type": "code", - "execution_count": 40, - "metadata": {}, - "outputs": [], - "source": [ - "dataset = \"pytorch_notebook\"\n", - "network_name = \"api_dataset\"\n", - "output_name = \"example_pytorch_forecast\"\n", - "output_folder = os.path.join(\".\", \"results\", \"predict\", output_name,\n", - " \"{}.{}\".format(network_name, seed))\n", - "os.makedirs(output_folder, exist_ok=output_folder)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Convert and output predictions to numpy files" - ] - }, - { - "cell_type": "code", - "execution_count": 41, - "metadata": {}, - "outputs": [], - "source": [ - "batch = 0\n", - "batch_size = prediction.shape[0]\n", - "\n", - "idx = 0\n", - "for workers, prediction in enumerate(predictions):\n", - " for batch in range(prediction.shape[0]):\n", - " date = pd.Timestamp(test_dataset.dates[idx].replace('_', '-'))\n", - " output_path = os.path.join(output_folder, date.strftime(\"%Y_%m_%d.npy\"))\n", - " forecast = prediction[batch, :, :, :, :].movedim(-2, 0)\n", - " forecast_np = forecast.detach().cpu().numpy()\n", - " np.save(output_path, forecast_np)\n", - " idx += 1" - ] - }, - { - "cell_type": "code", - "execution_count": 42, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-12-30 00:24:36.013187: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-30 00:24:36.013257: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-30 00:24:36.014324: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "[30-12-23 00:24:39 :INFO ] - Loading configuration ./dataset_config.api_dataset.json\n", - "[30-12-23 00:24:39 :INFO ] - Training dataset path: ./network_datasets/api_dataset/south/train\n", - "[30-12-23 00:24:39 :INFO ] - Validation dataset path: ./network_datasets/api_dataset/south/val\n", - "[30-12-23 00:24:39 :INFO ] - Test dataset path: ./network_datasets/api_dataset/south/test\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/process/predict.py:58: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " cube = iris.load_cube(path, 'sea_ice_area_fraction')\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/process/predict.py:58: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " cube = iris.load_cube(path, 'sea_ice_area_fraction')\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/process/predict.py:58: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " cube = iris.load_cube(path, 'sea_ice_area_fraction')\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/process/predict.py:58: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " cube = iris.load_cube(path, 'sea_ice_area_fraction')\n", - "[30-12-23 00:24:40 :INFO ] - Post-processing 2020-04-01\n", - "[30-12-23 00:24:40 :INFO ] - Post-processing 2020-04-02\n", - "[30-12-23 00:24:40 :INFO ] - Dataset arr shape: (2, 432, 432, 7, 2)\n", - "[30-12-23 00:24:40 :INFO ] - Applying active grid cell masks\n", - "[30-12-23 00:24:40 :INFO ] - Land masking the forecast output\n", - "[30-12-23 00:24:40 :INFO ] - Applying zeros to land mask\n", - "[30-12-23 00:24:40 :INFO ] - Saving to results/predict/example_pytorch_forecast.nc\n" - ] - } - ], - "source": [ - "!icenet_output -o results/predict example_pytorch_forecast api_dataset testdates.csv -m" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Plotting the forecast" - ] - }, - { - "cell_type": "code", - "execution_count": 43, - "metadata": {}, - "outputs": [], - "source": [ - "import xarray as xr\n", - "import datetime as dt\n", - "from IPython.display import HTML" - ] - }, - { - "cell_type": "code", - "execution_count": 44, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xarray.Dataset {\n", - "dimensions:\n", - "\ttime = 2 ;\n", - "\tyc = 432 ;\n", - "\txc = 432 ;\n", - "\tleadtime = 7 ;\n", - "\n", - "variables:\n", - "\tint32 Lambert_Azimuthal_Grid() ;\n", - "\t\tLambert_Azimuthal_Grid:grid_mapping_name = lambert_azimuthal_equal_area ;\n", - "\t\tLambert_Azimuthal_Grid:longitude_of_projection_origin = 0.0 ;\n", - "\t\tLambert_Azimuthal_Grid:latitude_of_projection_origin = -90.0 ;\n", - "\t\tLambert_Azimuthal_Grid:false_easting = 0.0 ;\n", - "\t\tLambert_Azimuthal_Grid:false_northing = 0.0 ;\n", - "\t\tLambert_Azimuthal_Grid:semi_major_axis = 6378137.0 ;\n", - "\t\tLambert_Azimuthal_Grid:inverse_flattening = 298.257223563 ;\n", - "\t\tLambert_Azimuthal_Grid:proj4_string = +proj=laea +lon_0=0 +datum=WGS84 +ellps=WGS84 +lat_0=-90.0 ;\n", - "\tfloat32 sic_mean(time, yc, xc, leadtime) ;\n", - "\t\tsic_mean:long_name = mean sea ice area fraction across ensemble runs of icenet model ;\n", - "\t\tsic_mean:standard_name = sea_ice_area_fraction ;\n", - "\t\tsic_mean:short_name = sic ;\n", - "\t\tsic_mean:valid_min = 0 ;\n", - "\t\tsic_mean:valid_max = 1 ;\n", - "\t\tsic_mean:ancillary_variables = sic_stddev ;\n", - "\t\tsic_mean:grid_mapping = Lambert_Azimuthal_Grid ;\n", - "\t\tsic_mean:units = 1 ;\n", - "\tfloat32 sic_stddev(time, yc, xc, leadtime) ;\n", - "\t\tsic_stddev:long_name = total uncertainty (one standard deviation) of concentration of sea ice ;\n", - "\t\tsic_stddev:standard_name = sea_ice_area_fraction standard_error ;\n", - "\t\tsic_stddev:valid_min = 0 ;\n", - "\t\tsic_stddev:valid_max = 1 ;\n", - "\t\tsic_stddev:grid_mapping = Lambert_Azimuthal_Grid ;\n", - "\t\tsic_stddev:units = 1 ;\n", - "\tint64 ensemble_members(time) ;\n", - "\t\tensemble_members:long_name = number of ensemble members used to create this prediction ;\n", - "\t\tensemble_members:short_name = ensemble_members ;\n", - "\tdatetime64[ns] time(time) ;\n", - "\t\ttime:long_name = reference time of product ;\n", - "\t\ttime:standard_name = time ;\n", - "\t\ttime:axis = T ;\n", - "\tint64 leadtime(leadtime) ;\n", - "\t\tleadtime:long_name = leadtime of forecast in relation to reference time ;\n", - "\t\tleadtime:short_name = leadtime ;\n", - "\tdatetime64[ns] forecast_date(time, leadtime) ;\n", - "\tfloat64 xc(xc) ;\n", - "\t\txc:long_name = x coordinate of projection (eastings) ;\n", - "\t\txc:standard_name = projection_x_coordinate ;\n", - "\t\txc:units = 1000 meter ;\n", - "\t\txc:axis = X ;\n", - "\tfloat64 yc(yc) ;\n", - "\t\tyc:long_name = y coordinate of projection (northings) ;\n", - "\t\tyc:standard_name = projection_y_coordinate ;\n", - "\t\tyc:units = 1000 meter ;\n", - "\t\tyc:axis = Y ;\n", - "\tfloat32 lat(yc, xc) ;\n", - "\t\tlat:long_name = latitude coordinate ;\n", - "\t\tlat:standard_name = latitude ;\n", - "\t\tlat:units = arc_degree ;\n", - "\tfloat32 lon(yc, xc) ;\n", - "\t\tlon:long_name = longitude coordinate ;\n", - "\t\tlon:standard_name = longitude ;\n", - "\t\tlon:units = arc_degree ;\n", - "\n", - "// global attributes:\n", - "\t:Conventions = CF-1.6 ACDD-1.3 ;\n", - "\t:comments = ;\n", - "\t:creator_email = jambyr@bas.ac.uk ;\n", - "\t:creator_institution = British Antarctic Survey ;\n", - "\t:creator_name = James Byrne ;\n", - "\t:creator_url = www.bas.ac.uk ;\n", - "\t:date_created = 2023-12-30 ;\n", - "\t:geospatial_bounds_crs = EPSG:6932 ;\n", - "\t:geospatial_lat_min = -90.0 ;\n", - "\t:geospatial_lat_max = -16.62393 ;\n", - "\t:geospatial_lon_min = -180.0 ;\n", - "\t:geospatial_lon_max = 180.0 ;\n", - "\t:geospatial_vertical_min = 0.0 ;\n", - "\t:geospatial_vertical_max = 0.0 ;\n", - "\t:history = 2023-12-30 00:24:40.616824 - creation ;\n", - "\t:id = IceNet 0.2.7a1 ;\n", - "\t:institution = British Antarctic Survey ;\n", - "\t:keywords = 'Earth Science > Cryosphere > Sea Ice > Sea Ice Concentration\n", - " Earth Science > Oceans > Sea Ice > Sea Ice Concentration\n", - " Earth Science > Climate Indicators > Cryospheric Indicators > Sea Ice\n", - " Geographic Region > Southern Hemisphere ;\n", - "\t:keywords_vocabulary = GCMD Science Keywords ;\n", - "\t:license = Open Government Licece (OGL) V3 ;\n", - "\t:naming_authority = uk.ac.bas ;\n", - "\t:platform = BAS HPC ;\n", - "\t:product_version = 0.2.7a1 ;\n", - "\t:project = IceNet ;\n", - "\t:publisher_email = ;\n", - "\t:publisher_institution = British Antarctic Survey ;\n", - "\t:publisher_url = ;\n", - "\t:source = \n", - " IceNet model generation at v0.2.7a1\n", - " ;\n", - "\t:spatial_resolution = 25.0 km grid spacing ;\n", - "\t:standard_name_vocabulary = CF Standard Name Table v27 ;\n", - "\t:summary = \n", - " This is an output of sea ice concentration predictions from the\n", - " IceNet run in an ensemble, with postprocessing to determine\n", - " the mean and standard deviation across the runs.\n", - " ;\n", - "\t:time_coverage_start = 2020-04-02T00:00:00 ;\n", - "\t:time_coverage_end = 2020-04-09T00:00:00 ;\n", - "\t:time_coverage_duration = P1D ;\n", - "\t:time_coverage_resolution = P1D ;\n", - "\t:title = Sea Ice Concentration Prediction ;\n", - "}" - ] - } - ], - "source": [ - "from icenet.plotting.video import xarray_to_video as xvid\n", - "from icenet.data.sic.mask import Masks\n", - "\n", - "ds = xr.open_dataset(\"results/predict/example_pytorch_forecast.nc\")\n", - "land_mask = Masks(south=True, north=False).get_land_mask()\n", - "ds.info()" - ] - }, - { - "cell_type": "code", - "execution_count": 45, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2020-04-01T00:00:00.000000000\n" - ] - } - ], - "source": [ - "forecast_date = ds.time.values[0]\n", - "print(forecast_date)" - ] - }, - { - "cell_type": "code", - "execution_count": 46, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:root:Inspecting data\n", - "INFO:root:Initialising plot\n", - "INFO:root:Animating\n", - "INFO:root:Not saving plot, will return animation\n", - "INFO:matplotlib.animation:Animation.save using \n" - ] - }, - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 46, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fc = ds.sic_mean.isel(time=0).drop_vars(\"time\").rename(dict(leadtime=\"time\"))\n", - "fc['time'] = [pd.to_datetime(forecast_date) \\\n", - " + dt.timedelta(days=int(e)) for e in fc.time.values]\n", - "\n", - "anim = xvid(fc, 15, figsize=4, mask=land_mask)\n", - "HTML(anim.to_jshtml())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Check min/max of predicted SIC fraction" - ] - }, - { - "cell_type": "code", - "execution_count": 47, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "(1, 432, 432)\n", - "First forecast day min: 0.0077, max: 0.8985\n" - ] - } - ], - "source": [ - "print( forecast_np[:, :, :, 0].shape )\n", - "fmin, fmax = np.min(forecast_np[:, :, :, 0]), np.max(forecast_np[:, :, :, 0])\n", - "print( f\"First forecast day min: {fmin:.4f}, max: {fmax:.4f}\" )" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Load original input dataset" - ] - }, - { - "cell_type": "code", - "execution_count": 48, - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 48, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "# Load original input dataset (domain not normalised)\n", - "xr.plot.contourf(xr.open_dataset(\"data/osisaf/south/siconca/2020.nc\").isel(time=91).ice_conc, levels=50)\n", - "\n", - "# Load processed - normalised dataset\n", - "# xr.plot.contourf(xr.open_dataset(\"processed/notebook_data/osisaf/south/siconca/siconca_abs.nc\").isel(time=91).ice_conc, levels=50)" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Version\n", - "- IceNet Codebase: v0.2.7_dev" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pytorch", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -} diff --git a/6_tensorflow_normal_run.ipynb b/6_tensorflow_normal_run.ipynb deleted file mode 100644 index 67e0653..0000000 --- a/6_tensorflow_normal_run.ipynb +++ /dev/null @@ -1,20918 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 1, - "metadata": {}, - "outputs": [], - "source": [ - "import numpy as np\n", - "import pandas as pd\n", - "import xarray as xr\n", - "import datetime as dt\n", - "from IPython.display import HTML\n", - "\n", - "# We also set the logging level so that we get some feedback from the API\n", - "import logging\n", - "logging.basicConfig(level=logging.INFO)" - ] - }, - { - "cell_type": "code", - "execution_count": 2, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Running in /data/hpcdata/users/bryald/git/icenet/notebook-pipeline\n" - ] - } - ], - "source": [ - "# Quick hack to put us in the icenet-pipeline folder,\n", - "# assuming it was created as per 01.cli_demonstration.ipynb\n", - "import os\n", - "if os.path.exists(\"6_tensorflow_normal_run.ipynb\"):\n", - " os.chdir(\"../notebook-pipeline\")\n", - "print(\"Running in {}\".format(os.getcwd()))\n", - "\n", - "%matplotlib inline" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Download required datasets" - ] - }, - { - "cell_type": "code", - "execution_count": 3, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[31-12-23 20:24:25 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200001021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_01.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200002021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_02.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200003021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_03.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200004021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_04.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200005021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_05.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200006021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_06.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200007021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_07.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200008021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_08.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200009021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_09.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200010021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_10.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200011021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_11.npy\n", - "[31-12-23 20:24:26 :INFO ] - siconca ice_conc_sh_ease2-250_cdr-v2p0_200012021200.nc already exists\n", - "[31-12-23 20:24:26 :INFO ] - Saving ./data/masks/south/masks/active_grid_cell_mask_12.npy\n" - ] - } - ], - "source": [ - "# Download masks\n", - "!icenet_data_masks south" - ] - }, - { - "cell_type": "code", - "execution_count": 4, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[31-12-23 20:24:28 :INFO ] - ERA5 Data Downloading\n", - "[31-12-23 20:24:28 :WARNING ] - !!! Deletions of temp files are switched off: be careful with this, you need to manage your files manually\n", - "[31-12-23 20:24:28 :INFO ] - Building request(s), downloading and daily averaging from ERA5 API\n", - "[31-12-23 20:24:28 :INFO ] - Processing single download for uas @ None with 121 dates\n", - "[31-12-23 20:24:28 :INFO ] - Processing single download for vas @ None with 121 dates\n", - "[31-12-23 20:24:28 :INFO ] - Processing single download for tas @ None with 121 dates\n", - "[31-12-23 20:24:28 :INFO ] - Processing single download for zg @ 500 with 121 dates\n", - "[31-12-23 20:24:28 :INFO ] - Processing single download for zg @ 250 with 121 dates\n", - "[31-12-23 20:24:29 :INFO ] - No requested dates remain, likely already present\n", - "[31-12-23 20:24:29 :INFO ] - No requested dates remain, likely already present\n", - "[31-12-23 20:24:29 :INFO ] - No requested dates remain, likely already present\n", - "[31-12-23 20:24:29 :INFO ] - No requested dates remain, likely already present\n", - "[31-12-23 20:24:29 :INFO ] - No requested dates remain, likely already present\n", - "[31-12-23 20:24:29 :INFO ] - 0 daily files downloaded\n", - "[31-12-23 20:24:29 :INFO ] - No regrid batches to processing, moving on...\n", - "[31-12-23 20:24:29 :INFO ] - Rotating wind data prior to merging\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/data/interfaces/downloader.py:361: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " iris.load_cube(sic_day_path, 'sea_ice_area_fraction')\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/data/interfaces/downloader.py:361: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " iris.load_cube(sic_day_path, 'sea_ice_area_fraction')\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/data/interfaces/downloader.py:361: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " iris.load_cube(sic_day_path, 'sea_ice_area_fraction')\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/data/interfaces/downloader.py:361: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " iris.load_cube(sic_day_path, 'sea_ice_area_fraction')\n", - "[31-12-23 20:24:29 :INFO ] - Rotating wind data in ./data/era5/south/uas ./data/era5/south/vas\n", - "[31-12-23 20:24:29 :INFO ] - 0 files for uas\n", - "[31-12-23 20:24:29 :INFO ] - 0 files for vas\n" - ] - } - ], - "source": [ - "# Download climate data - ERA5 reanalysis data\n", - "!icenet_data_era5 south -d --vars uas,vas,tas,zg --levels ',,,500|250' 2020-1-1 2020-4-30" - ] - }, - { - "cell_type": "code", - "execution_count": 5, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "[31-12-23 20:24:30 :INFO ] - OSASIF-SIC Data Downloading\n", - "[31-12-23 20:24:30 :INFO ] - Downloading SIC datafiles to .temp intermediates...\n", - "[31-12-23 20:24:31 :INFO ] - Excluding 121 dates already existing from 121 dates requested.\n", - "[31-12-23 20:24:39 :INFO ] - Existing file needs concatenating: ./data/osisaf/south/siconca/2020.nc -> ./data/osisaf/south/siconca/old.2020.nc\n", - "[31-12-23 20:24:40 :INFO ] - Saving ./data/osisaf/south/siconca/2020.nc\n", - "[31-12-23 20:24:41 :INFO ] - Opening for interpolation: ['./data/osisaf/south/siconca/2020.nc']\n", - "[31-12-23 20:24:41 :INFO ] - Processing 0 missing dates\n" - ] - } - ], - "source": [ - "# Download sea ice concentration (%) from OSI-SAF\n", - "!icenet_data_sic south -d 2020-1-1 2020-4-30" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Process above data downloads - normalising to use as inputs for UNet\n", - "\n", - "This creates loader.{name}.json.\n", - "\n", - "Also creates train, val, test splits based on CLI arguments within the loader json file." - ] - }, - { - "cell_type": "code", - "execution_count": 6, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-12-31 20:24:43.308849: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:24:43.308961: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:24:43.312233: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "[31-12-23 20:24:46 :INFO ] - Got 91 dates for train\n", - "[31-12-23 20:24:46 :INFO ] - Got 21 dates for val\n", - "[31-12-23 20:24:46 :INFO ] - Got 2 dates for test\n", - "[31-12-23 20:24:46 :INFO ] - Processing 91 dates for train category\n", - "[31-12-23 20:24:46 :INFO ] - Including lag of 1 days\n", - "[31-12-23 20:24:46 :INFO ] - Including lead of 93 days\n", - "[31-12-23 20:24:46 :INFO ] - No data found for 2019-12-31, outside data boundary perhaps?\n", - "[31-12-23 20:24:46 :INFO ] - Processing 21 dates for val category\n", - "[31-12-23 20:24:46 :INFO ] - Including lag of 1 days\n", - "[31-12-23 20:24:46 :INFO ] - Including lead of 93 days\n", - "[31-12-23 20:24:46 :INFO ] - Processing 2 dates for test category\n", - "[31-12-23 20:24:46 :INFO ] - Including lag of 1 days\n", - "[31-12-23 20:24:46 :INFO ] - Including lead of 93 days\n", - "[31-12-23 20:24:46 :INFO ] - Got 1 files for tas\n", - "[31-12-23 20:24:46 :INFO ] - Got 1 files for uas\n", - "[31-12-23 20:24:46 :INFO ] - Got 1 files for vas\n", - "[31-12-23 20:24:46 :INFO ] - Got 1 files for zg250\n", - "[31-12-23 20:24:46 :INFO ] - Got 1 files for zg500\n", - "[31-12-23 20:24:46 :INFO ] - Opening files for uas\n", - "[31-12-23 20:24:46 :INFO ] - Filtered to 121 units long based on configuration requirements\n", - "[31-12-23 20:24:47 :INFO ] - Normalising uas\n", - "[31-12-23 20:24:47 :INFO ] - Opening files for vas\n", - "[31-12-23 20:24:47 :INFO ] - Filtered to 121 units long based on configuration requirements\n", - "[31-12-23 20:24:47 :INFO ] - Normalising vas\n", - "[31-12-23 20:24:48 :INFO ] - Opening files for tas\n", - "[31-12-23 20:24:48 :INFO ] - Filtered to 121 units long based on configuration requirements\n", - "[31-12-23 20:24:48 :INFO ] - Reusing climatology ./processed/notebook_tf_data/era5/south/params/climatology.tas\n", - "[31-12-23 20:24:48 :WARNING ] - We don't have a full climatology (1,2,3) compared with data (1,2,3,4)\n", - "[31-12-23 20:24:48 :INFO ] - Normalising tas\n", - "[31-12-23 20:24:48 :INFO ] - Opening files for zg500\n", - "[31-12-23 20:24:48 :INFO ] - Filtered to 121 units long based on configuration requirements\n", - "[31-12-23 20:24:48 :INFO ] - Reusing climatology ./processed/notebook_tf_data/era5/south/params/climatology.zg500\n", - "[31-12-23 20:24:48 :WARNING ] - We don't have a full climatology (1,2,3) compared with data (1,2,3,4)\n", - "[31-12-23 20:24:48 :INFO ] - Normalising zg500\n", - "[31-12-23 20:24:48 :INFO ] - Opening files for zg250\n", - "[31-12-23 20:24:48 :INFO ] - Filtered to 121 units long based on configuration requirements\n", - "[31-12-23 20:24:48 :INFO ] - Reusing climatology ./processed/notebook_tf_data/era5/south/params/climatology.zg250\n", - "[31-12-23 20:24:48 :WARNING ] - We don't have a full climatology (1,2,3) compared with data (1,2,3,4)\n", - "[31-12-23 20:24:48 :INFO ] - Normalising zg250\n", - "[31-12-23 20:24:49 :INFO ] - Loading configuration ./loader.notebook_tf_data.json\n", - "[31-12-23 20:24:49 :INFO ] - Writing configuration to ./loader.notebook_tf_data.json\n", - "2023-12-31 20:24:51.009891: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:24:51.009963: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:24:51.011149: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "[31-12-23 20:24:52 :INFO ] - Got 91 dates for train\n", - "[31-12-23 20:24:52 :INFO ] - Got 20 dates for val\n", - "[31-12-23 20:24:52 :INFO ] - Got 2 dates for test\n", - "[31-12-23 20:24:52 :INFO ] - Processing 91 dates for train category\n", - "[31-12-23 20:24:52 :INFO ] - Including lag of 1 days\n", - "[31-12-23 20:24:52 :INFO ] - Including lead of 93 days\n", - "[31-12-23 20:24:52 :INFO ] - No data found for 2019-12-31, outside data boundary perhaps?\n", - "[31-12-23 20:24:52 :INFO ] - Processing 20 dates for val category\n", - "[31-12-23 20:24:52 :INFO ] - Including lag of 1 days\n", - "[31-12-23 20:24:52 :INFO ] - Including lead of 93 days\n", - "[31-12-23 20:24:52 :INFO ] - Processing 2 dates for test category\n", - "[31-12-23 20:24:52 :INFO ] - Including lag of 1 days\n", - "[31-12-23 20:24:52 :INFO ] - Including lead of 93 days\n", - "[31-12-23 20:24:52 :INFO ] - Got 1 files for siconca\n", - "[31-12-23 20:24:52 :INFO ] - Opening files for siconca\n", - "[31-12-23 20:24:53 :INFO ] - Filtered to 121 units long based on configuration requirements\n", - "[31-12-23 20:24:53 :INFO ] - No normalisation for siconca\n", - "[31-12-23 20:24:54 :INFO ] - Loading configuration ./loader.notebook_tf_data.json\n", - "[31-12-23 20:24:54 :INFO ] - Writing configuration to ./loader.notebook_tf_data.json\n", - "2023-12-31 20:24:56.108180: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:24:56.108233: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:24:56.109278: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "[31-12-23 20:24:58 :INFO ] - Loading configuration ./loader.notebook_tf_data.json\n", - "[31-12-23 20:24:58 :INFO ] - Writing configuration to ./loader.notebook_tf_data.json\n" - ] - } - ], - "source": [ - "# Process ERA5\n", - "!icenet_process_era5 notebook_tf_data south \\\n", - " -ns 2020-1-1 -ne 2020-3-31 -vs 2020-4-3 -ve 2020-4-23 -ts 2020-4-1 -te 2020-4-2 \\\n", - " -l 1 --abs uas,vas --anom tas,zg500,zg250\n", - "\n", - "# Process SIC\n", - "!icenet_process_sic notebook_tf_data south \\\n", - " -ns 2020-1-1 -ne 2020-3-31 -vs 2020-4-1 -ve 2020-4-20 -ts 2020-4-1 -te 2020-4-2 \\\n", - " -l 1 --abs siconca\n", - "\n", - "!icenet_process_metadata notebook_tf_data south" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "Creates `dataset_config.{name}.json`, and cached tfrecords dataset for training.\n", - "\n", - "If running in config-only model, will create json file, but not cached dataset (i.e., for just prediction)" - ] - }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-12-31 20:24:59.608475: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:24:59.608527: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:24:59.609476: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "[31-12-23 20:25:01 :INFO ] - Got 0 dates for train\n", - "[31-12-23 20:25:01 :INFO ] - Got 0 dates for val\n", - "[31-12-23 20:25:01 :INFO ] - Got 0 dates for test\n", - "[31-12-23 20:25:01 :INFO ] - Loading configuration loader.notebook_tf_data.json\n", - "[31-12-23 20:25:02 :INFO ] - Dashboard at localhost:8888\n", - "[31-12-23 20:25:02 :INFO ] - Using dask client \n", - "[31-12-23 20:25:02 :INFO ] - 91 train dates to process, generating cache data.\n", - "2023-12-31 20:25:03.000140: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:25:03.000199: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:25:03.001188: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "2023-12-31 20:25:03.014793: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:25:03.014856: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:25:03.015754: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "2023-12-31 20:25:03.034417: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:25:03.034417: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:25:03.034471: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:25:03.034504: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:25:03.035564: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "2023-12-31 20:25:03.035564: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "[31-12-23 20:25:17 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000000.tfrecord\n", - "[31-12-23 20:25:17 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000001.tfrecord\n", - "[31-12-23 20:25:17 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000002.tfrecord\n", - "[31-12-23 20:25:17 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000003.tfrecord\n", - "[31-12-23 20:25:17 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000004.tfrecord\n", - "[31-12-23 20:25:17 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000005.tfrecord\n", - "[31-12-23 20:25:17 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000006.tfrecord\n", - "[31-12-23 20:25:17 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000007.tfrecord\n", - "[31-12-23 20:25:29 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000008.tfrecord\n", - "[31-12-23 20:25:29 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000009.tfrecord\n", - "[31-12-23 20:25:29 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000010.tfrecord\n", - "[31-12-23 20:25:29 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000011.tfrecord\n", - "[31-12-23 20:25:29 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000012.tfrecord\n", - "[31-12-23 20:25:29 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000013.tfrecord\n", - "[31-12-23 20:25:29 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000014.tfrecord\n", - "[31-12-23 20:25:29 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000015.tfrecord\n", - "[31-12-23 20:25:41 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000016.tfrecord\n", - "[31-12-23 20:25:41 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000017.tfrecord\n", - "[31-12-23 20:25:41 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000018.tfrecord\n", - "[31-12-23 20:25:41 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000019.tfrecord\n", - "[31-12-23 20:25:41 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000020.tfrecord\n", - "[31-12-23 20:25:41 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000021.tfrecord\n", - "[31-12-23 20:25:41 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000022.tfrecord\n", - "[31-12-23 20:25:41 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000023.tfrecord\n", - "[31-12-23 20:25:54 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000024.tfrecord\n", - "[31-12-23 20:25:54 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000025.tfrecord\n", - "[31-12-23 20:25:54 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000026.tfrecord\n", - "[31-12-23 20:25:54 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000027.tfrecord\n", - "[31-12-23 20:25:54 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000028.tfrecord\n", - "[31-12-23 20:25:54 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000029.tfrecord\n", - "[31-12-23 20:25:54 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000030.tfrecord\n", - "[31-12-23 20:25:54 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000031.tfrecord\n", - "[31-12-23 20:26:05 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000032.tfrecord\n", - "[31-12-23 20:26:05 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000033.tfrecord\n", - "[31-12-23 20:26:05 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000034.tfrecord\n", - "[31-12-23 20:26:05 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000035.tfrecord\n", - "[31-12-23 20:26:05 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000036.tfrecord\n", - "[31-12-23 20:26:05 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000037.tfrecord\n", - "[31-12-23 20:26:05 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000038.tfrecord\n", - "[31-12-23 20:26:05 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000039.tfrecord\n", - "[31-12-23 20:26:14 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000040.tfrecord\n", - "[31-12-23 20:26:14 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000041.tfrecord\n", - "[31-12-23 20:26:14 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000042.tfrecord\n", - "[31-12-23 20:26:14 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000043.tfrecord\n", - "[31-12-23 20:26:14 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000044.tfrecord\n", - "[31-12-23 20:26:14 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/train/00000045.tfrecord\n", - "[31-12-23 20:26:14 :INFO ] - 23 val dates to process, generating cache data.\n", - "[31-12-23 20:26:27 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000000.tfrecord\n", - "[31-12-23 20:26:27 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000001.tfrecord\n", - "[31-12-23 20:26:27 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000002.tfrecord\n", - "[31-12-23 20:26:27 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000003.tfrecord\n", - "[31-12-23 20:26:27 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000004.tfrecord\n", - "[31-12-23 20:26:27 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000005.tfrecord\n", - "[31-12-23 20:26:27 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000006.tfrecord\n", - "[31-12-23 20:26:27 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000007.tfrecord\n", - "[31-12-23 20:26:34 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000008.tfrecord\n", - "[31-12-23 20:26:34 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000009.tfrecord\n", - "[31-12-23 20:26:34 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000010.tfrecord\n", - "[31-12-23 20:26:34 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/val/00000011.tfrecord\n", - "[31-12-23 20:26:34 :INFO ] - 2 test dates to process, generating cache data.\n", - "[31-12-23 20:26:38 :INFO ] - Finished output ./network_datasets/notebook_tf_data/south/test/00000000.tfrecord\n", - "[31-12-23 20:26:38 :INFO ] - Average sample generation time: 4.481075739038402\n", - "[31-12-23 20:26:38 :INFO ] - Writing configuration to ./dataset_config.notebook_tf_data.json\n" - ] - } - ], - "source": [ - "!icenet_dataset_create -l 1 -fd 7 -ob 2 -w 4 notebook_tf_data south" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## IceNet UNet model\n", - "\n", - "Running tensorflow UNet model as normal." - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-12-31 20:26:42.163574: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:26:42.163623: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:26:42.164691: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "[31-12-23 20:26:47 :WARNING ] - Setting seed for best attempt at determinism, value 42\n", - "[31-12-23 20:26:47 :INFO ] - Loading configuration dataset_config.notebook_tf_data.json\n", - "[31-12-23 20:26:47 :INFO ] - Training dataset path: ./network_datasets/notebook_tf_data/south/train\n", - "[31-12-23 20:26:47 :INFO ] - Validation dataset path: ./network_datasets/notebook_tf_data/south/val\n", - "[31-12-23 20:26:47 :INFO ] - Test dataset path: ./network_datasets/notebook_tf_data/south/test\n", - "[31-12-23 20:26:47 :WARNING ] - WandB is not available, we will never use it\n", - "[31-12-23 20:26:47 :INFO ] - Adding tensorboard callback\n", - "Model: \"model\"\n", - "__________________________________________________________________________________________________\n", - " Layer (type) Output Shape Param # Connected to \n", - "==================================================================================================\n", - " input_1 (InputLayer) [(None, 432, 432, 9)] 0 [] \n", - " \n", - " conv2d (Conv2D) (None, 432, 432, 19) 1558 ['input_1[0][0]'] \n", - " \n", - " conv2d_1 (Conv2D) (None, 432, 432, 19) 3268 ['conv2d[0][0]'] \n", - " \n", - " batch_normalization (Batch (None, 432, 432, 19) 76 ['conv2d_1[0][0]'] \n", - " Normalization) \n", - " \n", - " max_pooling2d (MaxPooling2 (None, 216, 216, 19) 0 ['batch_normalization[0][0]'] \n", - " D) \n", - " \n", - " conv2d_2 (Conv2D) (None, 216, 216, 38) 6536 ['max_pooling2d[0][0]'] \n", - " \n", - " conv2d_3 (Conv2D) (None, 216, 216, 38) 13034 ['conv2d_2[0][0]'] \n", - " \n", - " batch_normalization_1 (Bat (None, 216, 216, 38) 152 ['conv2d_3[0][0]'] \n", - " chNormalization) \n", - " \n", - " max_pooling2d_1 (MaxPoolin (None, 108, 108, 38) 0 ['batch_normalization_1[0][0]'\n", - " g2D) ] \n", - " \n", - " conv2d_4 (Conv2D) (None, 108, 108, 76) 26068 ['max_pooling2d_1[0][0]'] \n", - " \n", - " conv2d_5 (Conv2D) (None, 108, 108, 76) 52060 ['conv2d_4[0][0]'] \n", - " \n", - " batch_normalization_2 (Bat (None, 108, 108, 76) 304 ['conv2d_5[0][0]'] \n", - " chNormalization) \n", - " \n", - " max_pooling2d_2 (MaxPoolin (None, 54, 54, 76) 0 ['batch_normalization_2[0][0]'\n", - " g2D) ] \n", - " \n", - " conv2d_6 (Conv2D) (None, 54, 54, 76) 52060 ['max_pooling2d_2[0][0]'] \n", - " \n", - " conv2d_7 (Conv2D) (None, 54, 54, 76) 52060 ['conv2d_6[0][0]'] \n", - " \n", - " batch_normalization_3 (Bat (None, 54, 54, 76) 304 ['conv2d_7[0][0]'] \n", - " chNormalization) \n", - " \n", - " max_pooling2d_3 (MaxPoolin (None, 27, 27, 76) 0 ['batch_normalization_3[0][0]'\n", - " g2D) ] \n", - " \n", - " conv2d_8 (Conv2D) (None, 27, 27, 152) 104120 ['max_pooling2d_3[0][0]'] \n", - " \n", - " conv2d_9 (Conv2D) (None, 27, 27, 152) 208088 ['conv2d_8[0][0]'] \n", - " \n", - " batch_normalization_4 (Bat (None, 27, 27, 152) 608 ['conv2d_9[0][0]'] \n", - " chNormalization) \n", - " \n", - " up_sampling2d (UpSampling2 (None, 54, 54, 152) 0 ['batch_normalization_4[0][0]'\n", - " D) ] \n", - " \n", - " conv2d_10 (Conv2D) (None, 54, 54, 76) 46284 ['up_sampling2d[0][0]'] \n", - " \n", - " concatenate (Concatenate) (None, 54, 54, 152) 0 ['batch_normalization_3[0][0]'\n", - " , 'conv2d_10[0][0]'] \n", - " \n", - " conv2d_11 (Conv2D) (None, 54, 54, 76) 104044 ['concatenate[0][0]'] \n", - " \n", - " conv2d_12 (Conv2D) (None, 54, 54, 76) 52060 ['conv2d_11[0][0]'] \n", - " \n", - " batch_normalization_5 (Bat (None, 54, 54, 76) 304 ['conv2d_12[0][0]'] \n", - " chNormalization) \n", - " \n", - " up_sampling2d_1 (UpSamplin (None, 108, 108, 76) 0 ['batch_normalization_5[0][0]'\n", - " g2D) ] \n", - " \n", - " conv2d_13 (Conv2D) (None, 108, 108, 76) 23180 ['up_sampling2d_1[0][0]'] \n", - " \n", - " concatenate_1 (Concatenate (None, 108, 108, 152) 0 ['batch_normalization_2[0][0]'\n", - " ) , 'conv2d_13[0][0]'] \n", - " \n", - " conv2d_14 (Conv2D) (None, 108, 108, 76) 104044 ['concatenate_1[0][0]'] \n", - " \n", - " conv2d_15 (Conv2D) (None, 108, 108, 76) 52060 ['conv2d_14[0][0]'] \n", - " \n", - " batch_normalization_6 (Bat (None, 108, 108, 76) 304 ['conv2d_15[0][0]'] \n", - " chNormalization) \n", - " \n", - " up_sampling2d_2 (UpSamplin (None, 216, 216, 76) 0 ['batch_normalization_6[0][0]'\n", - " g2D) ] \n", - " \n", - " conv2d_16 (Conv2D) (None, 216, 216, 38) 11590 ['up_sampling2d_2[0][0]'] \n", - " \n", - " concatenate_2 (Concatenate (None, 216, 216, 76) 0 ['batch_normalization_1[0][0]'\n", - " ) , 'conv2d_16[0][0]'] \n", - " \n", - " conv2d_17 (Conv2D) (None, 216, 216, 38) 26030 ['concatenate_2[0][0]'] \n", - " \n", - " conv2d_18 (Conv2D) (None, 216, 216, 38) 13034 ['conv2d_17[0][0]'] \n", - " \n", - " batch_normalization_7 (Bat (None, 216, 216, 38) 152 ['conv2d_18[0][0]'] \n", - " chNormalization) \n", - " \n", - " up_sampling2d_3 (UpSamplin (None, 432, 432, 38) 0 ['batch_normalization_7[0][0]'\n", - " g2D) ] \n", - " \n", - " conv2d_19 (Conv2D) (None, 432, 432, 19) 2907 ['up_sampling2d_3[0][0]'] \n", - " \n", - " concatenate_3 (Concatenate (None, 432, 432, 38) 0 ['conv2d_1[0][0]', \n", - " ) 'conv2d_19[0][0]'] \n", - " \n", - " conv2d_20 (Conv2D) (None, 432, 432, 19) 6517 ['concatenate_3[0][0]'] \n", - " \n", - " conv2d_21 (Conv2D) (None, 432, 432, 19) 3268 ['conv2d_20[0][0]'] \n", - " \n", - " conv2d_22 (Conv2D) (None, 432, 432, 19) 3268 ['conv2d_21[0][0]'] \n", - " \n", - " conv2d_23 (Conv2D) (None, 432, 432, 7) 140 ['conv2d_22[0][0]'] \n", - " \n", - "==================================================================================================\n", - "Total params: 969482 (3.70 MB)\n", - "Trainable params: 968380 (3.69 MB)\n", - "Non-trainable params: 1102 (4.30 KB)\n", - "__________________________________________________________________________________________________\n", - "[31-12-23 20:26:48 :INFO ] - Datasets: 46 train, 12 val and 1 test filenames\n", - "[31-12-23 20:26:48 :INFO ] - Reducing datasets to 1.0 of total files\n", - "[31-12-23 20:26:48 :INFO ] - Reduced: 46 train, 12 val and 1 test filenames\n", - "[31-12-23 20:26:49 :INFO ] - \n", - "Setting learning rate to: 9.999999747378752e-05\n", - "\n", - "Epoch 1/10\n", - "WARNING: All log messages before absl::InitializeLog() is called are written to STDERR\n", - "I0000 00:00:1704054417.983441 38901 device_compiler.h:186] Compiled cluster using XLA! This line is logged at most once for the lifetime of the process.\n", - "\n", - "Epoch 1: val_rmse improved from inf to 43.05126, saving model to ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "/data/hpcdata/users/bryald/miniconda3/envs/pytorch/lib/python3.11/site-packages/keras/src/engine/training.py:3103: UserWarning: You are saving your model as an HDF5 file via `model.save()`. This file format is considered legacy. We recommend using instead the native Keras format, e.g. `model.save('my_model.keras')`.\n", - " saving_api.save_model(\n", - "23/23 - 56s - loss: 343.9255 - binacc: 25.7934 - mae: 39.2011 - rmse: 43.4948 - mse: 2284.5085 - val_loss: 336.9477 - val_binacc: 36.9813 - val_mae: 40.3724 - val_rmse: 43.0513 - val_mse: 2037.0499 - lr: 1.0000e-04 - 56s/epoch - 2s/step\n", - "[31-12-23 20:27:45 :INFO ] - \n", - "Setting learning rate to: 9.999999747378752e-05\n", - "\n", - "Epoch 2/10\n", - "\n", - "Epoch 2: val_rmse improved from 43.05126 to 40.64370, saving model to ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "23/23 - 7s - loss: 256.8361 - binacc: 37.4513 - mae: 32.5517 - rmse: 37.5866 - mse: 1888.7924 - val_loss: 300.3152 - val_binacc: 36.9813 - val_mae: 38.6907 - val_rmse: 40.6437 - val_mse: 1913.4229 - lr: 1.0000e-04 - 7s/epoch - 303ms/step\n", - "[31-12-23 20:27:52 :INFO ] - \n", - "Setting learning rate to: 9.999999747378752e-05\n", - "\n", - "Epoch 3/10\n", - "\n", - "Epoch 3: val_rmse improved from 40.64370 to 38.05367, saving model to ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "23/23 - 7s - loss: 154.3864 - binacc: 54.3259 - mae: 23.8672 - rmse: 29.1413 - mse: 1519.2355 - val_loss: 263.2594 - val_binacc: 38.0947 - val_mae: 35.5122 - val_rmse: 38.0537 - val_mse: 1695.7881 - lr: 1.0000e-04 - 7s/epoch - 304ms/step\n", - "[31-12-23 20:27:59 :INFO ] - \n", - "Setting learning rate to: 9.999999747378752e-05\n", - "\n", - "Epoch 4/10\n", - "\n", - "Epoch 4: val_rmse improved from 38.05367 to 37.05745, saving model to ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "23/23 - 7s - loss: 53.3989 - binacc: 82.8000 - mae: 11.7304 - rmse: 17.1384 - mse: 1217.8383 - val_loss: 249.6559 - val_binacc: 40.9881 - val_mae: 33.8406 - val_rmse: 37.0574 - val_mse: 1534.1256 - lr: 1.0000e-04 - 7s/epoch - 308ms/step\n", - "[31-12-23 20:28:06 :INFO ] - \n", - "Setting learning rate to: 9.999999747378752e-05\n", - "\n", - "Epoch 5/10\n", - "\n", - "Epoch 5: val_rmse improved from 37.05745 to 35.79379, saving model to ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "23/23 - 7s - loss: 33.9674 - binacc: 94.9292 - mae: 7.3163 - rmse: 13.6690 - mse: 1167.5585 - val_loss: 232.9197 - val_binacc: 40.5778 - val_mae: 32.6644 - val_rmse: 35.7938 - val_mse: 1461.6030 - lr: 1.0000e-04 - 7s/epoch - 306ms/step\n", - "[31-12-23 20:28:13 :INFO ] - \n", - "Setting learning rate to: 9.999999747378752e-05\n", - "\n", - "Epoch 6/10\n", - "\n", - "Epoch 6: val_rmse improved from 35.79379 to 33.65832, saving model to ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "23/23 - 7s - loss: 27.6051 - binacc: 95.6763 - mae: 6.2371 - rmse: 12.3225 - mse: 1156.0563 - val_loss: 205.9566 - val_binacc: 42.4682 - val_mae: 30.7192 - val_rmse: 33.6583 - val_mse: 1368.7559 - lr: 1.0000e-04 - 7s/epoch - 305ms/step\n", - "[31-12-23 20:28:20 :INFO ] - \n", - "Setting learning rate to: 9.999999747378752e-05\n", - "\n", - "Epoch 7/10\n", - "\n", - "Epoch 7: val_rmse improved from 33.65832 to 28.84873, saving model to ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "23/23 - 7s - loss: 22.3518 - binacc: 96.0258 - mae: 5.5203 - rmse: 11.0882 - mse: 1177.7894 - val_loss: 151.3018 - val_binacc: 49.3492 - val_mae: 25.8698 - val_rmse: 28.8487 - val_mse: 1084.3677 - lr: 1.0000e-04 - 7s/epoch - 308ms/step\n", - "[31-12-23 20:28:27 :INFO ] - \n", - "Setting learning rate to: 9.999999747378752e-05\n", - "\n", - "Epoch 8/10\n", - "\n", - "Epoch 8: val_rmse improved from 28.84873 to 23.89613, saving model to ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "23/23 - 7s - loss: 18.0997 - binacc: 96.1845 - mae: 4.9427 - rmse: 9.9779 - mse: 1180.0663 - val_loss: 103.8116 - val_binacc: 62.1863 - val_mae: 20.4092 - val_rmse: 23.8961 - val_mse: 745.0102 - lr: 1.0000e-04 - 7s/epoch - 306ms/step\n", - "[31-12-23 20:28:34 :INFO ] - \n", - "Setting learning rate to: 9.999999747378752e-05\n", - "\n", - "Epoch 9/10\n", - "\n", - "Epoch 9: val_rmse improved from 23.89613 to 18.21984, saving model to ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "23/23 - 7s - loss: 15.3763 - binacc: 96.3971 - mae: 4.5406 - rmse: 9.1967 - mse: 1175.2972 - val_loss: 60.3504 - val_binacc: 80.4414 - val_mae: 14.4911 - val_rmse: 18.2198 - val_mse: 495.2992 - lr: 1.0000e-04 - 7s/epoch - 308ms/step\n", - "[31-12-23 20:28:42 :INFO ] - \n", - "Setting learning rate to: 9.999999747378752e-05\n", - "\n", - "Epoch 10/10\n", - "\n", - "Epoch 10: val_rmse improved from 18.21984 to 15.62367, saving model to ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "23/23 - 7s - loss: 14.0378 - binacc: 96.4605 - mae: 4.3094 - rmse: 8.7873 - mse: 1176.0642 - val_loss: 44.3769 - val_binacc: 87.5845 - val_mae: 11.9019 - val_rmse: 15.6237 - val_mse: 402.5215 - lr: 1.0000e-04 - 7s/epoch - 304ms/step\n", - "[31-12-23 20:28:49 :INFO ] - Saving network to: ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5\n", - "[31-12-23 20:28:52 :INFO ] - Running evaluation against test set\n", - "WARNING:tensorflow:Unable to restore custom metric. Please ensure that the layer implements `get_config` and `from_config` when saving. In addition, please use the `custom_objects` arg when calling `load_model()`.\n", - "[31-12-23 20:28:52 :WARNING ] - Unable to restore custom metric. Please ensure that the layer implements `get_config` and `from_config` when saving. In addition, please use the `custom_objects` arg when calling `load_model()`.\n", - "WARNING:tensorflow:Unable to restore custom metric. Please ensure that the layer implements `get_config` and `from_config` when saving. In addition, please use the `custom_objects` arg when calling `load_model()`.\n", - "[31-12-23 20:28:52 :WARNING ] - Unable to restore custom metric. Please ensure that the layer implements `get_config` and `from_config` when saving. In addition, please use the `custom_objects` arg when calling `load_model()`.\n", - "WARNING:tensorflow:Unable to restore custom metric. Please ensure that the layer implements `get_config` and `from_config` when saving. In addition, please use the `custom_objects` arg when calling `load_model()`.\n", - "[31-12-23 20:28:52 :WARNING ] - Unable to restore custom metric. Please ensure that the layer implements `get_config` and `from_config` when saving. In addition, please use the `custom_objects` arg when calling `load_model()`.\n", - "WARNING:tensorflow:Unable to restore custom metric. Please ensure that the layer implements `get_config` and `from_config` when saving. In addition, please use the `custom_objects` arg when calling `load_model()`.\n", - "[31-12-23 20:28:52 :WARNING ] - Unable to restore custom metric. Please ensure that the layer implements `get_config` and `from_config` when saving. In addition, please use the `custom_objects` arg when calling `load_model()`.\n", - "[31-12-23 20:28:53 :INFO ] - Datasets: 46 train, 12 val and 1 test filenames\n", - "[31-12-23 20:28:53 :INFO ] - Reducing datasets to 1.0 of total files\n", - "[31-12-23 20:28:53 :INFO ] - Reduced: 46 train, 12 val and 1 test filenames\n", - "[31-12-23 20:28:53 :INFO ] - Using test set for validation\n", - "[31-12-23 20:28:53 :INFO ] - Metric creation for lead time of 7 days\n", - "[31-12-23 20:28:53 :INFO ] - Evaluating... \n", - "[31-12-23 20:28:57 :INFO ] - Done in 3.4s\n" - ] - } - ], - "source": [ - "!icenet_train notebook_tf_data notebook_tf_testrun 42 -b 4 --epochs 10 --multiprocessing --max-queue-size 4 --workers 4 --n-filters-factor 0.3 --no-wandb" - ] - }, - { - "cell_type": "code", - "execution_count": 9, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2020-04-01\n", - "2020-04-02\n" - ] - } - ], - "source": [ - "!./loader_test_dates.sh notebook_tf_data | tee testdates.csv" - ] - }, - { - "cell_type": "code", - "execution_count": 10, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-12-31 20:28:59.964270: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:28:59.964322: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:28:59.965395: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "[31-12-23 20:29:03 :INFO ] - Loading configuration ./dataset_config.notebook_tf_data.json\n", - "[31-12-23 20:29:03 :INFO ] - Training dataset path: ./network_datasets/notebook_tf_data/south/train\n", - "[31-12-23 20:29:03 :INFO ] - Validation dataset path: ./network_datasets/notebook_tf_data/south/val\n", - "[31-12-23 20:29:03 :INFO ] - Test dataset path: ./network_datasets/notebook_tf_data/south/test\n", - "[31-12-23 20:29:03 :INFO ] - Loading configuration /data/hpcdata/users/bryald/git/icenet/notebook-pipeline/loader.notebook_tf_data.json\n", - "[31-12-23 20:29:03 :INFO ] - Loading model from ./results/networks/notebook_tf_testrun/notebook_tf_testrun.network_notebook_tf_data.42.h5...\n", - "[31-12-23 20:29:04 :INFO ] - Datasets: 46 train, 12 val and 1 test filenames\n", - "[31-12-23 20:29:04 :INFO ] - Processing test batch 1, item 0 (date 2020-04-01)\n", - "[31-12-23 20:29:04 :INFO ] - Running prediction 2020-04-01\n", - "[31-12-23 20:29:09 :WARNING ] - ./results/predict/example_south_tf_forecast/notebook_tf_testrun.42 output already exists\n", - "[31-12-23 20:29:09 :INFO ] - Saving 2020-04-01 - forecast output (1, 432, 432, 7)\n", - "[31-12-23 20:29:09 :INFO ] - Processing test batch 1, item 1 (date 2020-04-02)\n", - "[31-12-23 20:29:09 :INFO ] - Running prediction 2020-04-02\n", - "[31-12-23 20:29:09 :WARNING ] - ./results/predict/example_south_tf_forecast/notebook_tf_testrun.42 output already exists\n", - "[31-12-23 20:29:09 :INFO ] - Saving 2020-04-02 - forecast output (1, 432, 432, 7)\n" - ] - } - ], - "source": [ - "!icenet_predict -n 0.3 -t \\\n", - " notebook_tf_data notebook_tf_testrun example_south_tf_forecast 42 testdates.csv" - ] - }, - { - "cell_type": "code", - "execution_count": 11, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2023-12-31 20:29:11.878115: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:29:11.878166: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:29:11.879218: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n", - "[31-12-23 20:29:13 :INFO ] - Loading configuration ./dataset_config.notebook_tf_data.json\n", - "[31-12-23 20:29:13 :INFO ] - Training dataset path: ./network_datasets/notebook_tf_data/south/train\n", - "[31-12-23 20:29:13 :INFO ] - Validation dataset path: ./network_datasets/notebook_tf_data/south/val\n", - "[31-12-23 20:29:13 :INFO ] - Test dataset path: ./network_datasets/notebook_tf_data/south/test\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/process/predict.py:58: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " cube = iris.load_cube(path, 'sea_ice_area_fraction')\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/process/predict.py:58: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " cube = iris.load_cube(path, 'sea_ice_area_fraction')\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/process/predict.py:58: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " cube = iris.load_cube(path, 'sea_ice_area_fraction')\n", - "/data/hpcdata/users/bryald/git/icenet/icenet/icenet/process/predict.py:58: FutureWarning: Ignoring a datum in netCDF load for consistency with existing behaviour. In a future version of Iris, this datum will be applied. To apply the datum when loading, use the iris.FUTURE.datum_support flag.\n", - " cube = iris.load_cube(path, 'sea_ice_area_fraction')\n", - "[31-12-23 20:29:14 :INFO ] - Post-processing 2020-04-01\n", - "[31-12-23 20:29:14 :INFO ] - Post-processing 2020-04-02\n", - "[31-12-23 20:29:14 :INFO ] - Dataset arr shape: (2, 432, 432, 7, 2)\n", - "[31-12-23 20:29:14 :INFO ] - Saving to results/predict/example_south_tf_forecast.nc\n" - ] - } - ], - "source": [ - "# Create netCDF files from npy prediction outputs.\n", - "!icenet_output -o results/predict example_south_tf_forecast notebook_tf_data testdates.csv" - ] - }, - { - "cell_type": "code", - "execution_count": 12, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "2023-12-31 20:29:16.433108: E external/local_xla/xla/stream_executor/cuda/cuda_dnn.cc:9261] Unable to register cuDNN factory: Attempting to register factory for plugin cuDNN when one has already been registered\n", - "2023-12-31 20:29:16.433148: E external/local_xla/xla/stream_executor/cuda/cuda_fft.cc:607] Unable to register cuFFT factory: Attempting to register factory for plugin cuFFT when one has already been registered\n", - "2023-12-31 20:29:16.434205: E external/local_xla/xla/stream_executor/cuda/cuda_blas.cc:1515] Unable to register cuBLAS factory: Attempting to register factory for plugin cuBLAS when one has already been registered\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "xarray.Dataset {\n", - "dimensions:\n", - "\ttime = 2 ;\n", - "\tyc = 432 ;\n", - "\txc = 432 ;\n", - "\tleadtime = 7 ;\n", - "\n", - "variables:\n", - "\tint32 Lambert_Azimuthal_Grid() ;\n", - "\t\tLambert_Azimuthal_Grid:grid_mapping_name = lambert_azimuthal_equal_area ;\n", - "\t\tLambert_Azimuthal_Grid:longitude_of_projection_origin = 0.0 ;\n", - "\t\tLambert_Azimuthal_Grid:latitude_of_projection_origin = -90.0 ;\n", - "\t\tLambert_Azimuthal_Grid:false_easting = 0.0 ;\n", - "\t\tLambert_Azimuthal_Grid:false_northing = 0.0 ;\n", - "\t\tLambert_Azimuthal_Grid:semi_major_axis = 6378137.0 ;\n", - "\t\tLambert_Azimuthal_Grid:inverse_flattening = 298.257223563 ;\n", - "\t\tLambert_Azimuthal_Grid:proj4_string = +proj=laea +lon_0=0 +datum=WGS84 +ellps=WGS84 +lat_0=-90.0 ;\n", - "\tfloat32 sic_mean(time, yc, xc, leadtime) ;\n", - "\t\tsic_mean:long_name = mean sea ice area fraction across ensemble runs of icenet model ;\n", - "\t\tsic_mean:standard_name = sea_ice_area_fraction ;\n", - "\t\tsic_mean:short_name = sic ;\n", - "\t\tsic_mean:valid_min = 0 ;\n", - "\t\tsic_mean:valid_max = 1 ;\n", - "\t\tsic_mean:ancillary_variables = sic_stddev ;\n", - "\t\tsic_mean:grid_mapping = Lambert_Azimuthal_Grid ;\n", - "\t\tsic_mean:units = 1 ;\n", - "\tfloat32 sic_stddev(time, yc, xc, leadtime) ;\n", - "\t\tsic_stddev:long_name = total uncertainty (one standard deviation) of concentration of sea ice ;\n", - "\t\tsic_stddev:standard_name = sea_ice_area_fraction standard_error ;\n", - "\t\tsic_stddev:valid_min = 0 ;\n", - "\t\tsic_stddev:valid_max = 1 ;\n", - "\t\tsic_stddev:grid_mapping = Lambert_Azimuthal_Grid ;\n", - "\t\tsic_stddev:units = 1 ;\n", - "\tint64 ensemble_members(time) ;\n", - "\t\tensemble_members:long_name = number of ensemble members used to create this prediction ;\n", - "\t\tensemble_members:short_name = ensemble_members ;\n", - "\tdatetime64[ns] time(time) ;\n", - "\t\ttime:long_name = reference time of product ;\n", - "\t\ttime:standard_name = time ;\n", - "\t\ttime:axis = T ;\n", - "\tint64 leadtime(leadtime) ;\n", - "\t\tleadtime:long_name = leadtime of forecast in relation to reference time ;\n", - "\t\tleadtime:short_name = leadtime ;\n", - "\tdatetime64[ns] forecast_date(time, leadtime) ;\n", - "\tfloat64 xc(xc) ;\n", - "\t\txc:long_name = x coordinate of projection (eastings) ;\n", - "\t\txc:standard_name = projection_x_coordinate ;\n", - "\t\txc:units = 1000 meter ;\n", - "\t\txc:axis = X ;\n", - "\tfloat64 yc(yc) ;\n", - "\t\tyc:long_name = y coordinate of projection (northings) ;\n", - "\t\tyc:standard_name = projection_y_coordinate ;\n", - "\t\tyc:units = 1000 meter ;\n", - "\t\tyc:axis = Y ;\n", - "\tfloat32 lat(yc, xc) ;\n", - "\t\tlat:long_name = latitude coordinate ;\n", - "\t\tlat:standard_name = latitude ;\n", - "\t\tlat:units = arc_degree ;\n", - "\tfloat32 lon(yc, xc) ;\n", - "\t\tlon:long_name = longitude coordinate ;\n", - "\t\tlon:standard_name = longitude ;\n", - "\t\tlon:units = arc_degree ;\n", - "\n", - "// global attributes:\n", - "\t:Conventions = CF-1.6 ACDD-1.3 ;\n", - "\t:comments = ;\n", - "\t:creator_email = jambyr@bas.ac.uk ;\n", - "\t:creator_institution = British Antarctic Survey ;\n", - "\t:creator_name = James Byrne ;\n", - "\t:creator_url = www.bas.ac.uk ;\n", - "\t:date_created = 2023-12-31 ;\n", - "\t:geospatial_bounds_crs = EPSG:6932 ;\n", - "\t:geospatial_lat_min = -90.0 ;\n", - "\t:geospatial_lat_max = -16.62393 ;\n", - "\t:geospatial_lon_min = -180.0 ;\n", - "\t:geospatial_lon_max = 180.0 ;\n", - "\t:geospatial_vertical_min = 0.0 ;\n", - "\t:geospatial_vertical_max = 0.0 ;\n", - "\t:history = 2023-12-31 20:29:14.876693 - creation ;\n", - "\t:id = IceNet 0.2.7a1 ;\n", - "\t:institution = British Antarctic Survey ;\n", - "\t:keywords = 'Earth Science > Cryosphere > Sea Ice > Sea Ice Concentration\n", - " Earth Science > Oceans > Sea Ice > Sea Ice Concentration\n", - " Earth Science > Climate Indicators > Cryospheric Indicators > Sea Ice\n", - " Geographic Region > Southern Hemisphere ;\n", - "\t:keywords_vocabulary = GCMD Science Keywords ;\n", - "\t:license = Open Government Licece (OGL) V3 ;\n", - "\t:naming_authority = uk.ac.bas ;\n", - "\t:platform = BAS HPC ;\n", - "\t:product_version = 0.2.7a1 ;\n", - "\t:project = IceNet ;\n", - "\t:publisher_email = ;\n", - "\t:publisher_institution = British Antarctic Survey ;\n", - "\t:publisher_url = ;\n", - "\t:source = \n", - " IceNet model generation at v0.2.7a1\n", - " ;\n", - "\t:spatial_resolution = 25.0 km grid spacing ;\n", - "\t:standard_name_vocabulary = CF Standard Name Table v27 ;\n", - "\t:summary = \n", - " This is an output of sea ice concentration predictions from the\n", - " IceNet run in an ensemble, with postprocessing to determine\n", - " the mean and standard deviation across the runs.\n", - " ;\n", - "\t:time_coverage_start = 2020-04-02T00:00:00 ;\n", - "\t:time_coverage_end = 2020-04-09T00:00:00 ;\n", - "\t:time_coverage_duration = P1D ;\n", - "\t:time_coverage_resolution = P1D ;\n", - "\t:title = Sea Ice Concentration Prediction ;\n", - "}" - ] - } - ], - "source": [ - "from icenet.plotting.video import xarray_to_video as xvid\n", - "from icenet.data.sic.mask import Masks\n", - "\n", - "ds = xr.open_dataset(\"results/predict/example_south_tf_forecast.nc\")\n", - "land_mask = Masks(south=True, north=False).get_land_mask()\n", - "ds.info()" - ] - }, - { - "cell_type": "code", - "execution_count": 13, - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "2020-04-01T00:00:00.000000000\n" - ] - } - ], - "source": [ - "forecast_date = ds.time.values[0]\n", - "print(forecast_date)" - ] - }, - { - "cell_type": "code", - "execution_count": 14, - "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "INFO:root:Inspecting data\n", - "INFO:root:Initialising plot\n", - "INFO:root:Animating\n", - "INFO:root:Not saving plot, will return animation\n", - "INFO:matplotlib.animation:Animation.save using \n" - ] - }, - { - "data": { - "text/html": [ - "\n", - "\n", - "\n", - "\n", - "\n", - "\n", - "
\n", - " \n", - "
\n", - " \n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - " \n", - " \n", - " \n", - " \n", - " \n", - " \n", - "
\n", - "
\n", - "
\n", - "\n", - "\n", - "\n" - ], - "text/plain": [ - "" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - } - ], - "source": [ - "fc = ds.sic_mean.isel(time=0).drop_vars(\"time\").rename(dict(leadtime=\"time\"))\n", - "fc['time'] = [pd.to_datetime(forecast_date) \\\n", - " + dt.timedelta(days=int(e)) for e in fc.time.values]\n", - "\n", - "anim = xvid(fc, 15, figsize=4, mask=land_mask)\n", - "HTML(anim.to_jshtml())" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Version\n", - "- IceNet Codebase: v0.2.7_dev" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "pytorch", - "language": "python", - "name": "python3" - }, - "language_info": { - "codemirror_mode": { - "name": "ipython", - "version": 3 - }, - "file_extension": ".py", - "mimetype": "text/x-python", - "name": "python", - "nbconvert_exporter": "python", - "pygments_lexer": "ipython3", - "version": "3.11.6" - } - }, - "nbformat": 4, - "nbformat_minor": 2 -}