From 6252eb1061388305e49a12c38cea4716b4a182d7 Mon Sep 17 00:00:00 2001 From: Vanonym <60972074+brayevalerien@users.noreply.github.com> Date: Fri, 29 Dec 2023 23:50:00 +0100 Subject: [PATCH 1/2] Improved MNIST notebook Better code organisation, wrote clearer comments, added docstrings and improved plots. --- .gitignore | 3 + BFN_MNIST.ipynb | 1131 ++++++++++++++++++++++------------------------- 2 files changed, 542 insertions(+), 592 deletions(-) create mode 100644 .gitignore diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e4da0f4 --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +data/* +models/* +.vscode/* \ No newline at end of file diff --git a/BFN_MNIST.ipynb b/BFN_MNIST.ipynb index a98b712..99ed9e2 100644 --- a/BFN_MNIST.ipynb +++ b/BFN_MNIST.ipynb @@ -1,12 +1,24 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Bayesian Flow Networks for discretized MNIST\n", + "In this notebook, we demonstrate how [Bayesian Flow Networks](https://arxiv.org/abs/2308.07037) (BFN) can be used to generate samples similar to data from discretized MNIST." + ] + }, { "cell_type": "markdown", "metadata": { "id": "SwKevyAcYt_c" }, "source": [ - "### BFNs for discretized MNIST" + "## Library imports\n", + "This notebook uses Pytorch EMA module. If it is not installed yet on your machine, run the following command:\n", + "```bash\n", + "pip install torch-ema\n", + "```" ] }, { @@ -17,141 +29,197 @@ }, "outputs": [], "source": [ - "import torch\n", + "import os\n", + "import random\n", + "from math import inf\n", + "\n", + "import matplotlib.pyplot as plt\n", "import numpy as np\n", + "import torch\n", "import torch.nn as nn\n", "import torch.nn.functional as F\n", + "import torch_ema\n", + "import torchvision\n", + "import torchvision.transforms as transforms\n", + "from torch.nn.functional import relu\n", + "from torch.optim import AdamW\n", "from torchsummary import summary\n", - "\n", - "import matplotlib.pyplot as plt\n", - "%matplotlib inline" + "from tqdm.auto import tqdm" ] }, { "cell_type": "markdown", - "metadata": { - "id": "npU1rgZtKGjg" - }, + "metadata": {}, "source": [ - "### Import the data" + "# Preliminary code\n", + "In this section we define useful variables and functions that we will need later in the notebook." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The following cell defines global variables that are used in this notebook. You can change their values to configure the notebook to your preferences.
\n", + "Here is a synthetic description of each of these variables:\n", + "- `DATAPATH`: path to the folder where the various datasets are stored.\n", + "- `SEED`: seed used to initialize all random number generators. If set to `None`, the results are non reproducible.\n", + "- `DEVICE`: device on which the computations will happen (`\"cpu\"` or `\"cuda\"`). Set automatically based on GPU availability, change to a specific device manually if you are facing issues.\n", + "- `SAVE_MODEL`: weither to save to trained models or not. If set to `True` and a model has already been saved, training process will be skipped and the saved model will be used instead.\n", + "- `MODELS_PATH`: path to the folder where the models are stored." ] }, { "cell_type": "code", "execution_count": 2, "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "qbxwlmBP-nnq", - "outputId": "6d60784a-d8ee-4812-dad5-717bf69d4da9" + "tags": [ + "parameters" + ] }, + "outputs": [], + "source": [ + "DATAPATH = \"./data/\"\n", + "SEED = 42\n", + "DEVICE = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", + "SAVE_MODEL = True\n", + "MODELS_PATH = \"./models/\"" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/MNIST/raw/train-images-idx3-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 9912422/9912422 [00:00<00:00, 213401384.04it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ./data/MNIST/raw/train-images-idx3-ubyte.gz to ./data/MNIST/raw\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/MNIST/raw/train-labels-idx1-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 28881/28881 [00:00<00:00, 115808502.70it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ./data/MNIST/raw/train-labels-idx1-ubyte.gz to ./data/MNIST/raw\n", - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw/t10k-images-idx3-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 1648877/1648877 [00:00<00:00, 59411301.70it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ./data/MNIST/raw/t10k-images-idx3-ubyte.gz to ./data/MNIST/raw\n", - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4542/4542 [00:00<00:00, 5078786.66it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ./data/MNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/MNIST/raw\n", - "\n" + "Using device: cuda\n" ] } ], "source": [ - "import torchvision\n", - "import torchvision.transforms as transforms\n", + "print(f\"Using device: {DEVICE}\")" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "%matplotlib inline\n", + "\n", + "\"\"\"\n", + "Publication ready pyplot theme\n", + "Source: https://github.com/matplotlib/matplotlib/issues/19028\n", + "\"\"\"\n", + "\n", + "plot_settings = {'ytick.labelsize': 16,\n", + " 'xtick.labelsize': 16,\n", + " 'font.size': 22,\n", + " 'figure.figsize': (10, 5),\n", + " 'axes.titlesize': 22,\n", + " 'axes.labelsize': 18,\n", + " 'lines.linewidth': 2,\n", + " 'lines.markersize': 3,\n", + " 'legend.fontsize': 11,\n", + " 'mathtext.fontset': 'stix',\n", + " 'font.family': 'STIXGeneral'}\n", + "plt.style.use(plot_settings)" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "if SEED:\n", + " random.seed(SEED)\n", + " np.random.seed(SEED)\n", + " torch.manual_seed(SEED)\n", + " torch.use_deterministic_algorithms(True)" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "def get_sample(dataloader: torch.utils.data.DataLoader) -> tuple[torch.Tensor, int]:\n", + " \"\"\"\n", + " Returns a random sample from a data loader\n", + "\n", + " Args:\n", + " dataloader (torch.utils.data.DataLoader): data loader storing the images.\n", + "\n", + " Returns:\n", + " tuple[torch.Tensor, int]: (image, label)\n", + " \"\"\"\n", + " for sample in dataloader:\n", + " return sample[0], sample[1][0].numpy()\n", + " raise IndexError(\"Could not sample an empty data loader.\")\n", + " \n", + "def show_samples(dataloader: torch.utils.data.DataLoader, n: int, title: str=None) -> None:\n", + " \"\"\"\n", + " Displays some random samples from a data loader.\n", + "\n", + " Args:\n", + " dataloader (torch.utils.data.DataLoader): data loader storing the images.\n", + " n (int): number of samples to display.\n", + " \"\"\"\n", + " fig, ax = plt.subplots(1, n, figsize=(3*n, 3))\n", + " for i in range(n):\n", + " img, label = get_sample(dataloader)\n", + " ax[i].imshow(img[0][0], cmap='Greys_r', interpolation='nearest')\n", + " ax[i].set_title(label)\n", + " ax[i].axis(\"off\")\n", + " title = title if title else f\"{n} random samples\"\n", + " fig.suptitle(title, position=(0.5, 1.1))\n", + " \n", + "def moving_average(data: list[float], window_size: int=20) -> list[float]:\n", + " \"\"\"\n", + " Computes the moving average of a list of values.\n", + "\n", + " Args:\n", + " data (list[float]): list of values.\n", + " window_size (int, optional): length of the window over which the values will be averaged out. Defaults to 20.\n", "\n", + " Returns:\n", + " list[float]: list of averaged values.\n", + " \"\"\"\n", + " moving_avg = []\n", + " for i in range(len(data) - window_size + 1):\n", + " window = data[i : i + window_size]\n", + " avg = sum(window) / window_size\n", + " moving_avg.append(avg)\n", + " return moving_avg" + ] + }, + { + "cell_type": "markdown", + "metadata": { + "id": "npU1rgZtKGjg" + }, + "source": [ + "## Data import\n", + "In this section we define the code that imports and discretizes the MNIST dataset to build training and testing data loaders (respectively `train_loader` and `test_loader`)." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "qbxwlmBP-nnq", + "outputId": "6d60784a-d8ee-4812-dad5-717bf69d4da9" + }, + "outputs": [], + "source": [ "# Define the data transformation\n", "transform = transforms.Compose([\n", " transforms.ToTensor(), # Convert images to tensors\n", @@ -160,8 +228,8 @@ "])\n", "\n", "# Download and load the MNIST dataset\n", - "train_dataset = torchvision.datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", - "test_dataset = torchvision.datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", + "train_dataset = torchvision.datasets.MNIST(root=DATAPATH, train=True, transform=transform, download=True)\n", + "test_dataset = torchvision.datasets.MNIST(root=DATAPATH, train=False, transform=transform, download=True)\n", "\n", "# Create data loaders\n", "batch_size = 64\n", @@ -171,7 +239,7 @@ }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 8, "metadata": { "colab": { "base_uri": "https://localhost:8080/" @@ -179,103 +247,7 @@ "id": "9xmO9_xOUD2H", "outputId": "b248f205-4260-436c-9f52-e8e0476348e5" }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz to ./data/DynamicallyBinarizedMNIST/raw/train-images-idx3-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 9912422/9912422 [00:00<00:00, 90723574.95it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ./data/DynamicallyBinarizedMNIST/raw/train-images-idx3-ubyte.gz to ./data/DynamicallyBinarizedMNIST/raw\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz to ./data/DynamicallyBinarizedMNIST/raw/train-labels-idx1-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 28881/28881 [00:00<00:00, 93324879.68it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ./data/DynamicallyBinarizedMNIST/raw/train-labels-idx1-ubyte.gz to ./data/DynamicallyBinarizedMNIST/raw\n", - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz to ./data/DynamicallyBinarizedMNIST/raw/t10k-images-idx3-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n", - "100%|██████████| 1648877/1648877 [00:03<00:00, 534919.42it/s]\n" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ./data/DynamicallyBinarizedMNIST/raw/t10k-images-idx3-ubyte.gz to ./data/DynamicallyBinarizedMNIST/raw\n", - "\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz\n", - "Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz to ./data/DynamicallyBinarizedMNIST/raw/t10k-labels-idx1-ubyte.gz\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "100%|██████████| 4542/4542 [00:00<00:00, 6707932.66it/s]" - ] - }, - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Extracting ./data/DynamicallyBinarizedMNIST/raw/t10k-labels-idx1-ubyte.gz to ./data/DynamicallyBinarizedMNIST/raw\n", - "\n" - ] - }, - { - "name": "stderr", - "output_type": "stream", - "text": [ - "\n" - ] - } - ], + "outputs": [], "source": [ "class DynamicallyBinarizedMNIST(torchvision.datasets.MNIST):\n", " def __init__(self, root, train=True, transform=None, target_transform=None, download=False):\n", @@ -284,32 +256,31 @@ "\n", " def __getitem__(self, index):\n", " img, target = self.data[index], int(self.targets[index])\n", - "\n", " if self.transform is not None:\n", " img = self.transform(img)\n", - "\n", " return img, target\n", "\n", - "def collate_dynamic_binarize(batch):\n", - " # Collate function that samples a binarization probability for each batch\n", + "def collate_dynamic_binarize(batch: list[tuple[torch.Tensor, int]]) -> tuple[torch.Tensor, torch.Tensor]:\n", + " \"\"\"\n", + " Collate function that samples a binarization probability for each batch.\n", + "\n", + " Args:\n", + " batch (list[tuple[torch.Tensor, int]]): list of samples to collate.\n", + "\n", + " Returns:\n", + " tuple[torch.Tensor, torch.Tensor]: resulting batch.\n", + " \"\"\"\n", " images, targets = zip(*batch)\n", " binarization_probs = torch.rand(len(images))\n", - "\n", " binarized_images = []\n", " for img, prob in zip(images, binarization_probs):\n", " binarized_img = (img > prob).float()\n", " binarized_images.append(binarized_img)\n", - "\n", " return torch.stack(binarized_images)[:, None, ...].to(torch.int64), torch.tensor(targets)\n", "\n", - "# Define transformations\n", - "transform = transforms.Compose([\n", - " transforms.ToTensor()\n", - "])\n", - "\n", "# Create the dynamically binarized MNIST dataset\n", - "train_dataset = DynamicallyBinarizedMNIST(root='./data', train=True, download=True) #transform=transform\n", - "test_dataset = DynamicallyBinarizedMNIST(root='./data', train=False, download=True) #transform=transform\n", + "train_dataset = DynamicallyBinarizedMNIST(root=DATAPATH, train=True, download=True) # transform=transform\n", + "test_dataset = DynamicallyBinarizedMNIST(root=DATAPATH, train=False, download=True) # transform=transform\n", "\n", "# Create data loaders with the collate function\n", "batch_size = 512\n", @@ -319,7 +290,7 @@ }, { "cell_type": "code", - "execution_count": 4, + "execution_count": 9, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -333,14 +304,15 @@ "name": "stdout", "output_type": "stream", "text": [ - "118\n" + "Number of data points in the training dataset: 118\n", + "Number of data points in the training dataset: 20\n" ] }, { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -348,14 +320,9 @@ } ], "source": [ - "# Show example\n", - "print(len(train_loader))\n", - "for i in train_loader:\n", - " x, y = i\n", - " plt.imshow(x[0][0], cmap='Greys_r', interpolation='nearest')\n", - " plt.axis('off')\n", - " plt.title(y[0].numpy())\n", - " break" + "print(f\"Number of data points in the training dataset: {len(train_loader)}\")\n", + "print(f\"Number of data points in the training dataset: {len(test_loader)}\")\n", + "show_samples(train_loader, 5, \"Random samples from training dataset\")" ] }, { @@ -364,8 +331,9 @@ "id": "lX5cjvb-KNal" }, "source": [ - "### The model\n", + "## Model definition\n", "\n", + "### Intermediary model\n", "We start by defining the convolutional model. For this project we use a simplified version of the [U-Net](https://papers.labml.ai/paper/2e48c3ffdc8311eba3db37f65e372566) architecture, with the following structure:\n", "\n", "![Diagramma senza titolo.drawio.png](data:image/png;base64,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)" @@ -373,26 +341,24 @@ }, { "cell_type": "code", - "execution_count": 6, + "execution_count": 10, "metadata": { "id": "nOsOsDkjSI0k" }, "outputs": [], "source": [ - "from torch.nn.functional import relu\n", - "\n", "C = 128\n", "\n", "class UNet(nn.Module):\n", - " def __init__(self, in_ch, out_ch, dropout=0.3):\n", + " def __init__(self, in_channels: int, out_channels: int, dropout: float=0.3):\n", " super().__init__()\n", "\n", - " self.in_ch = in_ch\n", - " self.out_ch = out_ch\n", + " self.in_channels = in_channels\n", + " self.out_channels = out_channels\n", "\n", " # Encoder\n", " # input: 28x28xIN\n", - " self.e11 = nn.Conv2d(in_ch, C//2, kernel_size=3, padding=1) # output: 28x28xC//2\n", + " self.e11 = nn.Conv2d(in_channels, C//2, kernel_size=3, padding=1) # output: 28x28xC//2\n", " self.dpe11 = nn.Dropout(p=dropout)\n", " self.e12 = nn.Conv2d(C//2, C//2, kernel_size=3, padding=1) # output: 28x28xC//2\n", " self.dpe12 = nn.Dropout(p=dropout)\n", @@ -433,11 +399,19 @@ "\n", " # Output layer\n", " # input: 28x28xC//2\n", - " self.outconv = nn.Conv2d(C//2, out_ch, kernel_size=1) # output: 28x28xOUT\n", + " self.outconv = nn.Conv2d(C//2, out_channels, kernel_size=1) # output: 28x28xOUT\n", "\n", - " def forward(self, x):\n", + " def forward(self, x: torch.Tensor) -> torch.Tensor:\n", + " \"\"\"\n", + " Performs a forward pass on the model.\n", "\n", - " # Encoder\n", + " Args:\n", + " x (torch.Tensor): input data.\n", + "\n", + " Returns:\n", + " torch.Tensor: output data.\n", + " \"\"\"\n", + " # Encode the input data\n", " xe11 = self.dpe11(relu(self.e11(x)))\n", " xe12 = self.dpe12(relu(self.e12(xe11)))\n", " xe13 = relu(self.e13(xe12))\n", @@ -452,7 +426,7 @@ " xe32 = self.dpe32(relu(self.e32(xe31)))\n", " xe33 = relu(self.e33(xe32))\n", "\n", - " # Decoder\n", + " # Decode the computed encoding\n", " xu11 = self.upconv1(xe33)\n", " xu12 = torch.cat([xu11, xe23], dim=1)\n", " xd11 = self.dpd11(relu(self.d11(xu12)))\n", @@ -467,126 +441,19 @@ "\n", " # Output layer\n", " out = self.outconv(xd23)\n", - "\n", " return out" ] }, - { - "cell_type": "code", - "execution_count": 7, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "gCB4QiMvj7bk", - "outputId": "c3b9ed73-02eb-4ba2-f1ed-e9f10c9116c4" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Collecting torch-ema\n", - " Downloading torch_ema-0.3-py3-none-any.whl (5.5 kB)\n", - "Requirement already satisfied: torch in /usr/local/lib/python3.10/dist-packages (from torch-ema) (2.0.1+cu118)\n", - "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch->torch-ema) (3.12.2)\n", - "Requirement already satisfied: typing-extensions in /usr/local/lib/python3.10/dist-packages (from torch->torch-ema) (4.7.1)\n", - "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch->torch-ema) (1.12)\n", - "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch->torch-ema) (3.1)\n", - "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch->torch-ema) (3.1.2)\n", - "Requirement already satisfied: triton==2.0.0 in /usr/local/lib/python3.10/dist-packages (from torch->torch-ema) (2.0.0)\n", - "Requirement already satisfied: cmake in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch->torch-ema) (3.27.2)\n", - "Requirement already satisfied: lit in /usr/local/lib/python3.10/dist-packages (from triton==2.0.0->torch->torch-ema) (16.0.6)\n", - "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch->torch-ema) (2.1.3)\n", - "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch->torch-ema) (1.3.0)\n", - "Installing collected packages: torch-ema\n", - "Successfully installed torch-ema-0.3\n" - ] - } - ], - "source": [ - "!pip install torch-ema" - ] - }, - { - "cell_type": "code", - "execution_count": 8, - "metadata": { - "colab": { - "base_uri": "https://localhost:8080/" - }, - "id": "6aEbH2gzCv2q", - "outputId": "c3f7cc9f-73a4-429e-f3a9-c71c63bc6feb" - }, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "----------------------------------------------------------------\n", - " Layer (type) Output Shape Param #\n", - "================================================================\n", - " Conv2d-1 [-1, 64, 28, 28] 1,216\n", - " Dropout-2 [-1, 64, 28, 28] 0\n", - " Conv2d-3 [-1, 64, 28, 28] 36,928\n", - " Dropout-4 [-1, 64, 28, 28] 0\n", - " Conv2d-5 [-1, 64, 28, 28] 36,928\n", - " MaxPool2d-6 [-1, 64, 14, 14] 0\n", - " Conv2d-7 [-1, 128, 14, 14] 73,856\n", - " Dropout-8 [-1, 128, 14, 14] 0\n", - " Conv2d-9 [-1, 128, 14, 14] 147,584\n", - " Dropout-10 [-1, 128, 14, 14] 0\n", - " Conv2d-11 [-1, 128, 14, 14] 147,584\n", - " MaxPool2d-12 [-1, 128, 7, 7] 0\n", - " Conv2d-13 [-1, 256, 7, 7] 295,168\n", - " Dropout-14 [-1, 256, 7, 7] 0\n", - " Conv2d-15 [-1, 256, 7, 7] 590,080\n", - " Dropout-16 [-1, 256, 7, 7] 0\n", - " Conv2d-17 [-1, 256, 7, 7] 590,080\n", - " ConvTranspose2d-18 [-1, 128, 14, 14] 131,200\n", - " Conv2d-19 [-1, 128, 14, 14] 295,040\n", - " Dropout-20 [-1, 128, 14, 14] 0\n", - " Conv2d-21 [-1, 128, 14, 14] 147,584\n", - " Dropout-22 [-1, 128, 14, 14] 0\n", - " Conv2d-23 [-1, 128, 14, 14] 147,584\n", - " ConvTranspose2d-24 [-1, 64, 28, 28] 32,832\n", - " Conv2d-25 [-1, 64, 28, 28] 73,792\n", - " Dropout-26 [-1, 64, 28, 28] 0\n", - " Conv2d-27 [-1, 64, 28, 28] 36,928\n", - " Dropout-28 [-1, 64, 28, 28] 0\n", - " Conv2d-29 [-1, 64, 28, 28] 36,928\n", - " Conv2d-30 [-1, 1, 28, 28] 65\n", - "================================================================\n", - "Total params: 2,821,377\n", - "Trainable params: 2,821,377\n", - "Non-trainable params: 0\n", - "----------------------------------------------------------------\n", - "Input size (MB): 0.01\n", - "Forward/backward pass size (MB): 6.94\n", - "Params size (MB): 10.76\n", - "Estimated Total Size (MB): 17.71\n", - "----------------------------------------------------------------\n" - ] - } - ], - "source": [ - "import torch_ema\n", - "\n", - "test = UNet(2, 1)\n", - "\n", - "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n", - "test.to(device)\n", - "\n", - "summary(test, input_size=(2, 28, 28))" - ] - }, { "cell_type": "markdown", "metadata": { "id": "AaFQQteFQCaO" }, "source": [ - "Then we define the BFN model, adapted for 2D data." + "## Bayesian Flow Network\n", + "Then we define the BFN model, adapted for 2D data.\n", + "\n", + "### Model definition" ] }, { @@ -598,31 +465,48 @@ "outputs": [], "source": [ "class BayesianFlowNetwork2D(nn.Module):\n", - " def __init__(self, net, D, K, beta=3.0):\n", + " def __init__(self, network, D, K, beta=3.0):\n", " super(BayesianFlowNetwork2D, self).__init__()\n", " self.beta = beta\n", " self.D = D\n", " self.K = K\n", + " self.network = network\n", "\n", - " self.net = net\n", + " def forward(self, theta: torch.Tensor, t: torch.Tensor, ema: torch_ema.ExponentialMovingAverage) -> torch.Tensor:\n", + " \"\"\"\n", + " Performs a forward pass.\n", "\n", - " def forward(self, theta, t, ema):\n", - " theta = (theta * 2) - 1 # scaled in [-1, 1]\n", + " Args:\n", + " theta (torch.Tensor)\n", + " t (torch.Tensor): time factor\n", + " ema (torch_ema.ExponentialMovingAverage): EMA used in the model.\n", "\n", + " Returns:\n", + " torch.Tensor\n", + " \"\"\"\n", + " theta = (theta * 2) - 1 # scaled in [-1, 1]\n", " theta = torch.transpose(theta, 1, 3)\n", " if ema is not None:\n", " with ema.average_parameters():\n", - " output = self.net(theta + t[:, None, None, None]) # (B, D, D, K)\n", + " output = self.network(theta + t[:, None, None, None]) # (B, D, D, K)\n", " else:\n", - " output = self.net(theta + t[:, None, None, None]) # (B, D, D, K)\n", - "\n", + " output = self.network(theta + t[:, None, None, None]) # (B, D, D, K)\n", " return torch.transpose(output, 1, 3)\n", "\n", - " def discrete_output_distribution(self, theta, t, ema=None):\n", + " def discrete_output_distribution(self, theta: torch.Tensor, t: torch.Tensor, ema: torch_ema.ExponentialMovingAverage=None) -> torch.Tensor:\n", + " \"\"\"\n", + " Computes the discrete output distribution of the model.\n", + "\n", + " Args:\n", + " theta (torch.Tensor)\n", + " t (torch.Tensor): time factor\n", + " ema (torch_ema.ExponentialMovingAverage, optional): EMA used in the model. Defaults to None.\n", "\n", + " Returns:\n", + " torch.Tensor\n", + " \"\"\"\n", " # Forward pass\n", " output = self.forward(theta, t, ema=ema)\n", - "\n", " # Compute the output probabilities accordingly\n", " if self.K == 2:\n", " p0_1 = torch.sigmoid(output) # (B, D, D, 1)\n", @@ -632,30 +516,32 @@ " p0 = torch.nn.functional.softmax(output, dim=-1)\n", " return p0\n", "\n", - " def process(self, x, t=None, training=True):\n", + " def process(self, x: torch.Tensor, time: float=None, training: bool=True) -> torch.Tensor | tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]:\n", + " \"\"\"\n", + " Performs a step of the process.\n", "\n", - " # Step 1: Sample t from U(0, 1)\n", - " if t is None:\n", - " t = torch.rand((x.size(0),), device=x.device, dtype=torch.float32)\n", - " else:\n", - " t = torch.tensor(t, device=x.device, dtype=torch.float32)[None]\n", + " Args:\n", + " x (torch.Tensor): input data.\n", + " time (float, optional): time factor in the process. In [0, 1]. Defaults to None.\n", + " training (bool, optional): weither it is during training phase or not. Defaults to True.\n", "\n", + " Returns:\n", + " torch.Tensor | tuple[torch.Tensor, torch.Tensor, torch.Tensor, torch.Tensor]: if training, only returns the current loss. Otherwise, returns the loss, the generated images, the categorical images and the time factor\n", + " \"\"\"\n", + " # Step 1: Sample t from U(0, 1) if not provided\n", + " t = torch.tensor(time, device=x.device, dtype=torch.float32)[None] if time else torch.rand((x.size(0),), device=x.device, dtype=torch.float32)\n", " # Step 2: Calculate Beta\n", " beta = self.beta * (t ** 2) # (B,)\n", - "\n", " # Step 3: Sample y from N(beta * (K * one_hot(X))\n", " one_hot_x = F.one_hot(x.permute(0, 2, 3, 1).to(torch.int64), num_classes=self.K).float().squeeze() # (B, D, D, K)\n", " mean = beta[:, None, None, None] * (self.K * one_hot_x - 1)\n", " std = (beta * self.K)[:, None, None, None].sqrt()\n", " eps = torch.randn_like(mean)\n", " y = mean + std * eps\n", - "\n", " # Step 4: Compute the Theta\n", " theta = F.softmax(y, dim=-1)\n", - "\n", " # Step 5: Calculate the output distribution\n", " p_0 = self.discrete_output_distribution(theta, t) # (B, D, D, K)\n", - "\n", " e_x = one_hot_x\n", " e_hat = p_0 # (B, D, D, K)\n", " L_infinity = self.K * self.beta * t[:, None, None, None] * ((e_x - e_hat) ** 2)\n", @@ -666,35 +552,27 @@ " return L_infinity.mean(), y, k, t\n", "\n", " @torch.inference_mode()\n", - " def sample(self, batch_size=128, nb_steps=10, ema=None, device='cpu'):\n", + " def sample(self, batch_size: int=128, nb_steps: int=10, ema: torch_ema.ExponentialMovingAverage=None, device: str='cpu') -> torch.Tensor:\n", " self.eval()\n", - "\n", " # get prior\n", " theta = torch.ones((batch_size, self.D, self.D, self.K), device=device) / self.K\n", - "\n", + " t = torch.zeros((theta.shape[0]), device=theta.device, dtype=theta.dtype)\n", " for i in tqdm(range(1, nb_steps+1)):\n", " t = (i-1) / nb_steps\n", " t = t * torch.ones((theta.shape[0]), device=theta.device, dtype=theta.dtype)\n", - "\n", " k_probs = self.discrete_output_distribution(theta, t, ema=ema) # (B, D, D, K)\n", " k = torch.distributions.Categorical(probs=k_probs).sample() # (B, D, D)\n", - "\n", " alpha = self.beta * (2 * i - 1) / (nb_steps ** 2)\n", - "\n", " e_k = F.one_hot(k, num_classes=self.K).float() # (B, D, D, K)\n", " mean = alpha * (self.K * e_k - 1)\n", " var = (alpha * self.K)\n", " std = torch.full_like(mean, fill_value=var).sqrt()\n", " eps = torch.randn_like(e_k)\n", - "\n", " y = mean + std * eps # (B, D, D, K)\n", - "\n", " theta_prime = torch.exp(y) * theta\n", " theta = theta_prime / theta_prime.sum(-1, keepdim=True)\n", - "\n", " k_probs_final = self.discrete_output_distribution(theta, torch.ones_like(t), ema=ema)\n", " k_final = torch.distributions.Categorical(probs=k_probs_final).sample()\n", - "\n", " return k_final" ] }, @@ -706,21 +584,54 @@ }, "outputs": [], "source": [ - "from torch.optim import AdamW\n", - "from tqdm.auto import tqdm\n", - "\n", - "bfn = BayesianFlowNetwork2D(UNet(2, 1, dropout=0.5), 28, 2)\n", - "ema = torch_ema.ExponentialMovingAverage(bfn.net.parameters(), decay=0.9999)\n", - "\n", - "bfn.cuda()\n", - "ema.to(device)\n", + "unet = UNet(2, 1, dropout=0.5)\n", + "bfn = BayesianFlowNetwork2D(network=unet, D=28, K=2).to(DEVICE)\n", + "ema = torch_ema.ExponentialMovingAverage(bfn.network.parameters(), decay=0.9999)\n", + "ema.to(DEVICE)\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Model training\n", + "The following cell exposes useful parameters for the training process.
\n", + "Here is a small breakdown of the role played by each of these parameters:\n", + "- `EPOCHS`: maximum number of epochs for the training process. Depending on the patience value, the training process might stop earlier.\n", + "- `EARLY_STOPPING`: weither to stop after a single epoch or not.\n", + "- `PATIENCE`: number of training steps after which the training process is stopped if the loss function has not been improved.\n", + "- `LEARNING_RATE`: learning rate used for optimizing the network.\n", "\n", - "optim = AdamW(bfn.parameters(), lr=2e-4, betas=(0.9, 0.98), weight_decay=0.01)" + "If you want a quicker training process, choose lower values. If you need better results, choose higher parameters." ] }, { "cell_type": "code", "execution_count": 13, + "metadata": { + "tags": [ + "parameters" + ] + }, + "outputs": [], + "source": [ + "EPOCHS = 100\n", + "EARLY_STOPPING = False\n", + "PATIENCE = 1e6\n", + "LEARNING_RATE = 3e-4" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can then train the BFN on the data we previously prepared." + ] + }, + { + "cell_type": "code", + "execution_count": 14, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -1831,11 +1742,76 @@ "id": "JO7C71Hv5few", "outputId": "d6c131ae-0c75-4160-b890-d37d881f3a11" }, + "outputs": [], + "source": [ + "optim = AdamW(bfn.parameters(), lr=LEARNING_RATE, betas=(0.9, 0.98), weight_decay=0.01)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "def train_model(model: BayesianFlowNetwork2D, optimizer: torch.optim.Optimizer) -> list[float]:\n", + " \"\"\"\n", + " Train a BFN model, given an optimizer.\n", + "\n", + " Args:\n", + " model (BayesianFlowNetwork2D)\n", + " optimizer (torch.optim.Optimizer)\n", + "\n", + " Returns:\n", + " list[float]: training losses.\n", + " \"\"\"\n", + " bfn_path = MODELS_PATH + \"mnist_bfn.pt\"\n", + " if SAVE_MODEL:\n", + " if os.path.exists(bfn_path):\n", + " checkpoint = torch.load(bfn_path)\n", + " model.load_state_dict(checkpoint['model_state_dict'])\n", + " print(f\"Trained model found, training process skipped. To train a new model, remove the file {bfn_path}.\")\n", + " return checkpoint[\"training_losses\"]\n", + " losses = []\n", + " best_loss = inf\n", + " k = 0\n", + " stop = EARLY_STOPPING\n", + " i = 0\n", + " for i in range(EPOCHS):\n", + " for X, _ in tqdm(train_loader, desc=f\"Epoch {i+1}/{EPOCHS}\"):\n", + " optimizer.zero_grad()\n", + " loss = model.process(X.to(DEVICE))\n", + " loss.backward()\n", + " optimizer.step()\n", + " ema.update()\n", + " losses.append(loss.item())\n", + " if loss.item() < best_loss:\n", + " best_loss = loss.item()\n", + " k = 0\n", + " else:\n", + " k += 1\n", + " if k == PATIENCE:\n", + " k = 0\n", + " stop = True\n", + " print(\"Patience value has been reached, ending training process.\")\n", + " break\n", + " if stop:\n", + " break\n", + " print(f\"Model trained in {i+1} epochs.\")\n", + " if SAVE_MODEL:\n", + " torch.save({\"model_state_dict\": model.state_dict(), \"training_losses\": losses}, bfn_path)\n", + " print(f\"Trained model saved at {bfn_path}\")\n", + " return losses" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, "outputs": [ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1392f10b1a6c4a958644fdbef8112157", + "model_id": "3e4add6242924074b38b515b27243b40", "version_major": 2, "version_minor": 0 }, @@ -1849,7 +1825,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "53ee4202f98c4fcfb7529c5074df6740", + "model_id": "e70d47de62364babbf11fa3aa3a9bd41", "version_major": 2, "version_minor": 0 }, @@ -1863,7 +1839,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "004073ebaabe43bda1a3078487fb39d0", + "model_id": "d112753cd050445785adea801617fafc", "version_major": 2, "version_minor": 0 }, @@ -1877,7 +1853,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "26f60e0aa3104ca1ab1a751ab8643939", + "model_id": "de813b4e256140ebac56bc81d763fc7d", "version_major": 2, "version_minor": 0 }, @@ -1891,7 +1867,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "87653df2e971422f9d657d6c89618b95", + "model_id": "583dfe5ddc7446ba99e2d0ae6b31f6ca", "version_major": 2, "version_minor": 0 }, @@ -1905,7 +1881,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "90c299a668424cedae99a7ddf6d3663e", + "model_id": "c001a4f365e84430abda0ce2912d612b", "version_major": 2, "version_minor": 0 }, @@ -1919,7 +1895,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f5105d9cf2f143fe83c1f2a0a0fcb3c1", + "model_id": "07864fc2527d4ad0a96897357da18983", "version_major": 2, "version_minor": 0 }, @@ -1933,7 +1909,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7c13727bfe364a909d617467e95b7b44", + "model_id": "74a8f1ab6ef142719364960a6859c8cc", "version_major": 2, "version_minor": 0 }, @@ -1947,7 +1923,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7bce30a555394853a6a20b6f1ea89ffb", + "model_id": "c864bfcc86f44c67bd955592e36e0d69", "version_major": 2, "version_minor": 0 }, @@ -1961,7 +1937,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "663afd3e9ca64f5c959fa785bcfe81ab", + "model_id": "62edcda3cf0f498fb356dcd5929e484f", "version_major": 2, "version_minor": 0 }, @@ -1975,7 +1951,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6f396ba6e1584776a9de772203983fb9", + "model_id": "c28c9a92c6c64ccf87dec7df6168dbb4", "version_major": 2, "version_minor": 0 }, @@ -1989,7 +1965,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "506ee79944c24c93b625ce34ea642844", + "model_id": "ab22e810ff1b4d4ba2552b25e6869474", "version_major": 2, "version_minor": 0 }, @@ -2003,7 +1979,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "5aedb7773f244fbea7ff006f45ffea83", + "model_id": "e1c6ce97910d4417bd80ed51384bc66a", "version_major": 2, "version_minor": 0 }, @@ -2017,7 +1993,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9d8fa91ef403445facc9c10cff0d7113", + "model_id": "68767fdc37284d39b3ce80fe12a7d43c", "version_major": 2, "version_minor": 0 }, @@ -2031,7 +2007,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "cac78dc7d98f4a048550e06c61732d56", + "model_id": "818b9caa67204ed8827fb67c15b7b99a", "version_major": 2, "version_minor": 0 }, @@ -2045,7 +2021,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "10c3cc50c9be4427948c966b27c019f5", + "model_id": "4c79658bbb68478ca789650714bec46c", "version_major": 2, "version_minor": 0 }, @@ -2059,7 +2035,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "85908c951a364fbe853d58664232ed82", + "model_id": "fd2dbaba7a244deb9a395b895775fc28", "version_major": 2, "version_minor": 0 }, @@ -2073,7 +2049,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f95032f67bd843eaae931b82bbc81643", + "model_id": "7d46b974713f45a58ef895d3f652de7d", "version_major": 2, "version_minor": 0 }, @@ -2087,7 +2063,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "376637c6490d47a7849ad38756ce2117", + "model_id": "591231b341624a27a24c6a652d64fe75", "version_major": 2, "version_minor": 0 }, @@ -2101,7 +2077,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "85ba1f494a8f462a96581ab8844e6498", + "model_id": "7478fbd734d04a8493e138cdaf9cea0e", "version_major": 2, "version_minor": 0 }, @@ -2115,7 +2091,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2f7787264d454752aeec79c7980a2fce", + "model_id": "c4a24435e15d4ceb880073b365d608eb", "version_major": 2, "version_minor": 0 }, @@ -2129,7 +2105,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bb6b8f77162842078d009057f2ae2134", + "model_id": "5a2ee90596d6471497b2fb8784934ecd", "version_major": 2, "version_minor": 0 }, @@ -2143,7 +2119,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ad60292f29864a47ad44fcbe06da205f", + "model_id": "0ec0644d631d4ebabd4794c6461f34e1", "version_major": 2, "version_minor": 0 }, @@ -2157,7 +2133,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f68414ffd0f04c0c9df71a61ea758633", + "model_id": "da88e73007cc4a34b33ecd27f918ddfd", "version_major": 2, "version_minor": 0 }, @@ -2171,7 +2147,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0b2799c04d8e4103b626fd6c1a3af5e7", + "model_id": "c08ab0264bbf4984bdae1194e2999a2b", "version_major": 2, "version_minor": 0 }, @@ -2185,7 +2161,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "81edbb24a67f4ae2b1f2148a62c3f279", + "model_id": "3e8cf2dba9c742aaaabe7b724bfa49e6", "version_major": 2, "version_minor": 0 }, @@ -2199,7 +2175,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ca0c6d58c5514192b52cea05c7b0108a", + "model_id": "e4f6c54baf094d5b8dfd1487a04b4d2a", "version_major": 2, "version_minor": 0 }, @@ -2213,7 +2189,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "273ac65ac4b04f4592194a33843383c5", + "model_id": "bbc9ff30bd234604b6ce02c5f94acc21", "version_major": 2, "version_minor": 0 }, @@ -2227,7 +2203,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a756e5b28638404cabfcdc5e007c2b4e", + "model_id": "0f1eebc8f7554ac9aad3e71c4f898f77", "version_major": 2, "version_minor": 0 }, @@ -2241,7 +2217,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ec28033a100547029d5429791d833f95", + "model_id": "549f6e4f77334e2c94f7d986625f4218", "version_major": 2, "version_minor": 0 }, @@ -2255,7 +2231,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e0582a45284b496ab6bcb43645fc0437", + "model_id": "310ea88defad4f0d8d3e9d52a41f1735", "version_major": 2, "version_minor": 0 }, @@ -2269,7 +2245,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "df27ac4bd348412f9aad13709dec50e6", + "model_id": "2ae0e1162c114e0c85cc48fe145eab03", "version_major": 2, "version_minor": 0 }, @@ -2283,7 +2259,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ec51c8b744c94316ba0fa9766c3df38b", + "model_id": "cd838ebe41fb4929a6ac102675db29e1", "version_major": 2, "version_minor": 0 }, @@ -2297,7 +2273,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9478e5a07f5b4f268ca2d74f601f2315", + "model_id": "1e4cafe7c0cc48dbbce9b1a446f4475b", "version_major": 2, "version_minor": 0 }, @@ -2311,7 +2287,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b22f70f0907b43d18b58c8ce9ff07475", + "model_id": "b015634c53a5478a96e5538ba202c0aa", "version_major": 2, "version_minor": 0 }, @@ -2325,7 +2301,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "3519c1c9e2df4533b22b976cba8819a8", + "model_id": "adc5b6cc7ad842e8a0678b43db769ea0", "version_major": 2, "version_minor": 0 }, @@ -2339,7 +2315,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7699d6259bee46c294eaa8e63da8b767", + "model_id": "09d925b457ba4dd5a61746ac7d409d4c", "version_major": 2, "version_minor": 0 }, @@ -2353,7 +2329,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7bbcef46032e4afcb752ee24e3d45c66", + "model_id": "b8380591583548b1bb7ddefffde156ae", "version_major": 2, "version_minor": 0 }, @@ -2367,7 +2343,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6d8ff656e6de4d83b5e7a464ca23e7de", + "model_id": "27fb2b486cf84395a012f1531f690a79", "version_major": 2, "version_minor": 0 }, @@ -2381,7 +2357,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c73ac5f9b2954589bc0b3e70deaf7c45", + "model_id": "028ff9d9e7574202b4671e2010e0d54f", "version_major": 2, "version_minor": 0 }, @@ -2395,7 +2371,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6beff8bb731f454cbd10a27e46894e93", + "model_id": "5916005c8edc4fb2aa4588c92a3f9ba5", "version_major": 2, "version_minor": 0 }, @@ -2409,7 +2385,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fe523e3b089b454393da43f7414c40cd", + "model_id": "868ffec67cde40c2a8ef3c402ec5ae3c", "version_major": 2, "version_minor": 0 }, @@ -2423,7 +2399,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a3603afe6feb4f87afc71c98b4342deb", + "model_id": "255b064764ef420381db097f96f631ef", "version_major": 2, "version_minor": 0 }, @@ -2437,7 +2413,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "927387c93cc647699465c148bc52dbb5", + "model_id": "56f89d452d2a45e5921aaf101e43fddb", "version_major": 2, "version_minor": 0 }, @@ -2451,7 +2427,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "25672ca18e884390b97bff31a985d21d", + "model_id": "f82f2b7d730b4a6e94e8b83b3644015a", "version_major": 2, "version_minor": 0 }, @@ -2465,7 +2441,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d840d980a7684648a95a3fa8ab583af5", + "model_id": "6135b5c3cb794265bae0b19eb0255837", "version_major": 2, "version_minor": 0 }, @@ -2479,7 +2455,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fea1b435dfd648a9a6cbbcb3831a29f5", + "model_id": "cb1f9ef4aa2b4c50b7cb90e25536b7c2", "version_major": 2, "version_minor": 0 }, @@ -2493,7 +2469,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "b9d30784f1304ae7bb9b694bbbb60d92", + "model_id": "0967a52179b74a7788f3e5eca312a10a", "version_major": 2, "version_minor": 0 }, @@ -2507,7 +2483,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dfe98eb40dd646a3b5308eb2dfc2cc64", + "model_id": "e16867e13eb24258ad53ba6ec46d2cce", "version_major": 2, "version_minor": 0 }, @@ -2521,7 +2497,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "556b689657744bda9ecdae09c77fa34e", + "model_id": "922b4ef00c564e108bf55eb4192f67ee", "version_major": 2, "version_minor": 0 }, @@ -2535,7 +2511,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "d68687e01c714d23938e4342053a599b", + "model_id": "882fad8cc3464d97adca302429ec3ec8", "version_major": 2, "version_minor": 0 }, @@ -2549,7 +2525,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bc8a87b1ec9c4a41b4c2809fe50d3875", + "model_id": "0e69969db55e48e38f3786388a9d6c6b", "version_major": 2, "version_minor": 0 }, @@ -2563,7 +2539,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "552c3880de98456c8aae3426882eaf21", + "model_id": "7d7940267e124084ac1ab3d401b9bc4b", "version_major": 2, "version_minor": 0 }, @@ -2577,7 +2553,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "62cf84d46cad4e6bb8fcaa97981cbc99", + "model_id": "409e04874e0b4d079ad2c23dfd808499", "version_major": 2, "version_minor": 0 }, @@ -2591,7 +2567,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "029700eb4be04cb98dd92636fd6fe499", + "model_id": "26bbb719a66b4b07ac5faf213029b5bf", "version_major": 2, "version_minor": 0 }, @@ -2605,7 +2581,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "940b8c25917c4174a874154047bde4a3", + "model_id": "d933f94673b7444a89c3d11b98cbff52", "version_major": 2, "version_minor": 0 }, @@ -2619,7 +2595,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "37e110358ea04f88bfb1804f4a40eb00", + "model_id": "f086e04ad91d4898ab2601374e7f2b9b", "version_major": 2, "version_minor": 0 }, @@ -2633,7 +2609,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e29412dcf86d43de845bc4a4f481c6e4", + "model_id": "88ac7fa15fe24701b0f9631aa2c718f1", "version_major": 2, "version_minor": 0 }, @@ -2647,7 +2623,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fb6ac207953d41f6a95a16852841f556", + "model_id": "e0f544e78d904c378ea89446edc2a977", "version_major": 2, "version_minor": 0 }, @@ -2661,7 +2637,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "ea1c2f38d4a942d2b12e94a3a8e996e8", + "model_id": "e04c4e20eec4428cab5856fb15b6786f", "version_major": 2, "version_minor": 0 }, @@ -2675,7 +2651,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "e41dbdce91f64f5c9b42ec676c73a9ef", + "model_id": "7a9b02fcfb8c49ef9f5ffdb0c16e2216", "version_major": 2, "version_minor": 0 }, @@ -2689,7 +2665,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2da5f6cbba4e4011a2fbeabf4bc1cc88", + "model_id": "155eaff629e241f7ab433d48c162e105", "version_major": 2, "version_minor": 0 }, @@ -2703,7 +2679,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c8f8687db75b44a9a2544b36516f61d8", + "model_id": "26611c8bc7974515b4cb6cce1c0a797e", "version_major": 2, "version_minor": 0 }, @@ -2717,7 +2693,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a0bc4fcf6f924115ada280726eed7d80", + "model_id": "7402491f4a754878ad9625c5df510d39", "version_major": 2, "version_minor": 0 }, @@ -2731,7 +2707,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "53bc8eecbdf747b794f8501f754aa242", + "model_id": "49145f4c8567479fb59c3f1d594a8d3f", "version_major": 2, "version_minor": 0 }, @@ -2745,7 +2721,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "643dca9c21de4938979807502786b66c", + "model_id": "1a616c5e49414cba9ec7c2a5ee17d990", "version_major": 2, "version_minor": 0 }, @@ -2759,7 +2735,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "de4b983b1dfd480eb311c88e47dbce98", + "model_id": "6989108dc0b043a1a554a5f5337a68c5", "version_major": 2, "version_minor": 0 }, @@ -2773,7 +2749,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "46eb043b6c55407b96ddb08eaedc7f68", + "model_id": "f0f58dfd9ab34b0e99f4e71b7bb824fe", "version_major": 2, "version_minor": 0 }, @@ -2787,7 +2763,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c6588a0067854750a065619b400f12dd", + "model_id": "43ea557aa0fd44d7832a5b20302d8386", "version_major": 2, "version_minor": 0 }, @@ -2801,7 +2777,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "fdefae499d564b0287480ddf49f94440", + "model_id": "d9db56b940714dfbbc888d9a76711c83", "version_major": 2, "version_minor": 0 }, @@ -2815,7 +2791,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0e055df3c1924cf2ad39a2b968a34ea3", + "model_id": "dca5e5fd152743d7859b981da74d9926", "version_major": 2, "version_minor": 0 }, @@ -2829,7 +2805,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "58b60939fabb45e7922d8cd042980b9f", + "model_id": "ee81712c442c4cdf958fab2aff0efddf", "version_major": 2, "version_minor": 0 }, @@ -2843,7 +2819,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2691210bddba4d87b70d070e45a66b00", + "model_id": "47b672bc10c14704afd197f0b4a983ca", "version_major": 2, "version_minor": 0 }, @@ -2857,7 +2833,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "6182c97e43c04996a51a6857cb781923", + "model_id": "67e948af05d84e69aa7b58c2259d394c", "version_major": 2, "version_minor": 0 }, @@ -2871,7 +2847,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "c5147b1fedd64667b22007529fe087cd", + "model_id": "89e1564d4d3b43b5b3abe164b31f39ef", "version_major": 2, "version_minor": 0 }, @@ -2885,7 +2861,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "165cb35e61a347d88cabac324572ba77", + "model_id": "bc6a964541294915958a94a08157b8a5", "version_major": 2, "version_minor": 0 }, @@ -2899,7 +2875,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8efa96c6281946519f0ed8a4a18d68d9", + "model_id": "d6c53e627b3d461896ec9474b12ca324", "version_major": 2, "version_minor": 0 }, @@ -2913,7 +2889,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "0c34879e4fce47f39618fe57548c33c4", + "model_id": "473c46c02b21426a997c8a6c5691b742", "version_major": 2, "version_minor": 0 }, @@ -2927,7 +2903,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "bdcc89baaa944d0b8f3818e0f429ac0e", + "model_id": "6b95ed7f608f405a897d7651c1777390", "version_major": 2, "version_minor": 0 }, @@ -2941,7 +2917,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "dbc31f172fb64df9a27e377e8f827868", + "model_id": "839d1563b2e344be958f30acf40b027d", "version_major": 2, "version_minor": 0 }, @@ -2955,7 +2931,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "540e024360f541f6b88da49a0f790dcd", + "model_id": "c3bca9fff3754643850ab7d5f2bce6b0", "version_major": 2, "version_minor": 0 }, @@ -2969,7 +2945,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "49890b690fa74e619681b228e86ff5df", + "model_id": "a8ed547a5c8e4b8f8050261507af11f1", "version_major": 2, "version_minor": 0 }, @@ -2983,7 +2959,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "f707e40562eb40da8d2c0655b0dd4778", + "model_id": "771067359ac84bee997751bae8ab99e6", "version_major": 2, "version_minor": 0 }, @@ -2997,7 +2973,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "9f76834a819445509844cb7119ade800", + "model_id": "b5b786c3438344b3bcea2cfa4d4d6872", "version_major": 2, "version_minor": 0 }, @@ -3011,7 +2987,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "25824ac1be4c43ff9c87e86763dc3623", + "model_id": "77d0db2dda7c4df2b1a49f500190d6d5", "version_major": 2, "version_minor": 0 }, @@ -3025,7 +3001,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "42380b3eeb674f01bd7c427eaf66c812", + "model_id": "34f38d25f5ff4b6f8d306f229178383b", "version_major": 2, "version_minor": 0 }, @@ -3039,7 +3015,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "7234eafb9ce94659934607a1b60d9d7d", + "model_id": "abd54f50ccf148509480e28300f7267d", "version_major": 2, "version_minor": 0 }, @@ -3053,7 +3029,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "35459e66d9224c03990e115924cc0c51", + "model_id": "c532eb1c836349a780f0667b838655cb", "version_major": 2, "version_minor": 0 }, @@ -3067,7 +3043,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "a4cae55dd13d4331a22e8bc51ec2c486", + "model_id": "ffedf2f39faa4f5994524a4d2bc0bc71", "version_major": 2, "version_minor": 0 }, @@ -3081,7 +3057,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "2c53112a039e40ba8a9a3f3e6c2a4f11", + "model_id": "17fe2f1461f146d9a3e27e866748c89c", "version_major": 2, "version_minor": 0 }, @@ -3095,7 +3071,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "69deb1900a6d41189605e81598e19cf6", + "model_id": "95e43ce6fb134740883eef6ad7ed12f9", "version_major": 2, "version_minor": 0 }, @@ -3109,7 +3085,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "76a0166a935844d99f1d72f6b3028fcb", + "model_id": "133a85ec53d34e29a2e2edce249e2cad", "version_major": 2, "version_minor": 0 }, @@ -3123,7 +3099,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "81cdc1f62cdf4e158ae0f5f57912a004", + "model_id": "7ed9f8338f3d41c19bbaec75f0c95262", "version_major": 2, "version_minor": 0 }, @@ -3137,7 +3113,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "8f98cffca6aa492d8709b56f2e2df4ad", + "model_id": "ec6fe7ef866549b6826ccb05af64dcbb", "version_major": 2, "version_minor": 0 }, @@ -3151,7 +3127,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "92ccd7c476e240a4a9ba809d3faed17e", + "model_id": "c645aef29fd241839669cf47861bb250", "version_major": 2, "version_minor": 0 }, @@ -3165,7 +3141,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "23cae125b80e46a69cf0dd3687522da1", + "model_id": "4b646e5d423e4ed890387631a337463b", "version_major": 2, "version_minor": 0 }, @@ -3179,7 +3155,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1d2fe7ea55874012ab780c6e6bca24b1", + "model_id": "a9e310ed4ca248c4a8420d2a13504804", "version_major": 2, "version_minor": 0 }, @@ -3193,7 +3169,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1d942f0ccbb744a68fe68fb71a89e54c", + "model_id": "3ebf73967a7543ce95a1f3ca935a5be3", "version_major": 2, "version_minor": 0 }, @@ -3207,7 +3183,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "240dca2fb5644b0f93b27e6c8a449c4d", + "model_id": "e970ba74d021476583147d7f6be7b6a9", "version_major": 2, "version_minor": 0 }, @@ -3221,7 +3197,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "24c9f10abefd4c76a23e6ad524065796", + "model_id": "9a342032c1a140e98625955f6638d965", "version_major": 2, "version_minor": 0 }, @@ -3233,20 +3209,35 @@ "output_type": "display_data" }, { - "data": { - "text/plain": [ - "[]" - ] - }, - "execution_count": 13, - "metadata": {}, - "output_type": "execute_result" - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Model trained in 100 epochs.\n", + "Trained model saved at ./models/mnist_bfn.pt\n" + ] + } + ], + "source": [ + "training_losses = train_model(bfn, optim)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once the model has been trained, we can visualize the loss function evolution during the training process." + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -3254,45 +3245,16 @@ } ], "source": [ - "losses = []\n", - "\n", - "epochs = 100\n", - "best_loss = 10000\n", - "k = 0\n", - "early_stopping = False\n", - "patience = 1e6\n", - "\n", - "for i in range(epochs):\n", - " for X, _ in tqdm(train_loader, desc=f\"Epoch {i+1}/{epochs}\"):\n", - " optim.zero_grad()\n", - "\n", - " loss = bfn.process(X.to(device))\n", - " loss.backward()\n", - "\n", - " optim.step()\n", - "\n", - " ema.update()\n", - "\n", - " losses.append(loss.item())\n", - "\n", - " if loss.item() < best_loss:\n", - " best_loss = loss.item()\n", - " k = 0\n", - " else:\n", - " k += 1\n", - " if k == patience:\n", - " k = 0\n", - " early_stopping = True\n", - " break\n", - " if early_stopping:\n", - " break\n", - "\n", - "plt.plot(losses)" + "plt.plot(training_losses)\n", + "plt.title(\"Training curve\")\n", + "plt.xlabel(\"Step\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.ylim(0, 0.1);" ] }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 18, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -3304,19 +3266,9 @@ "outputs": [ { "data": { + "image/png": "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", "text/plain": [ - "(0.0, 0.1)" - ] - }, - "execution_count": 14, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" + "
" ] }, "metadata": {}, @@ -3324,16 +3276,11 @@ } ], "source": [ - "def moving_average(data, window_size):\n", - " moving_avg = []\n", - " for i in range(len(data) - window_size + 1):\n", - " window = data[i : i + window_size]\n", - " avg = sum(window) / window_size\n", - " moving_avg.append(avg)\n", - " return moving_avg\n", - "\n", - "plt.plot(moving_average(losses, 20))\n", - "plt.ylim(0, 0.1)" + "plt.plot(moving_average(training_losses, 50))\n", + "plt.title(\"Smoothed training curve\")\n", + "plt.xlabel(\"Step\")\n", + "plt.ylabel(\"Loss\")\n", + "plt.ylim(0, 0.1);" ] }, { @@ -3349,7 +3296,7 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -3375,7 +3322,7 @@ { "data": { "application/vnd.jupyter.widget-view+json": { - "model_id": "1de06bd28c434d10847990c1efd0efd9", + "model_id": "9e716f36b661411ba6117e190dfd0ede", "version_major": 2, "version_minor": 0 }, @@ -3388,12 +3335,12 @@ } ], "source": [ - "x_hat = bfn.sample(device='cuda', nb_steps=1000, batch_size=16, ema=ema)" + "x_hat = bfn.sample(device=DEVICE.type, nb_steps=1000, batch_size=16, ema=ema)" ] }, { "cell_type": "code", - "execution_count": 23, + "execution_count": 20, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -3405,7 +3352,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAysAAAMrCAYAAABJVw1cAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8pXeV/AAAACXBIWXMAAA9hAAAPYQGoP6dpAAAYgklEQVR4nO3d0W7bSKJFUfPC///LvE+NyXSGlEyL5C7WWq+TzsgOS/JGAcfLuq7rFwAAQMz/3f0CAAAA/hexAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQ9P3uH1yW5czXAWmvfneq88HMnA/Y5nzAtnd+N72bFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEliBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQNL33S8AAOhZ1/Xul/D19fX1tSzL3S8BuJGbFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJKsgYVUllf2WGUBAGpKP0P5Wemz3KwAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAk08UA8GClSdctpl55kq0z5zk/xs0KAACQJFYAAIAksQIAACSJFQAAIEmsAAAASWIFAABIMl18sREmJPfsvX6TfJypcnY85xQ5H8zg6ufc89zgZgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAksQIAACSZLgYuVZlYhdGUzo5JV57ijGf5yFl1pra5WQEAAJLECgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEmmi09QmpeEuzz1HOx9XaYn+a3SufE88xSe5bG5WQEAAJLECgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEmmi4HDSjOrMJLK2THpCtS5WQEAAJLECgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEmmi3+hMj0JZ/KcwzGVs2OeGPr23i9mP8NuVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEiyBvZCZc0F2La3lOIMM4PZ14KA53KzAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAkkwXA5e6emLVrDG/5TmBse2d4cpnhPnxbW5WAACAJLECAAAkiRUAACBJrAAAAEliBQAASBIrAABAkuli4NHMzjIS86VwLZ8RfW5WAACAJLECAAAkiRUAACBJrAAAAEliBQAASBIrAABAkuniF/ZmJM3dwc/tnZujs63OIr816zM0+tdt6pmReF6PcbMCAAAkiRUAACBJrAAAAEliBQAASBIrAABAklgBAACSTBcPwqQrd7lyvtvzypmufr6OvG8fnfae9eycMYVOV+kMeL6u42YFAABIEisAAECSWAEAAJLECgAAkCRWAACAJLECAAAkmS4GDivNSMIdTHsDnMvNCgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEliBQAASDJd/ABXzlnuzXTCn658VpwB2PbUswjMwc0KAACQJFYAAIAksQIAACSJFQAAIEmsAAAASdbAXqisDFVeBwD/Met7s9UvzjTC87X3Gktn9QncrAAAAEliBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCTTxSEjTPXBXa4+H6YnucMZz92TP1ucU95R+dUQHONmBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJJkuBoAIM6p/M08Mc3OzAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAkkwXAzCFoxO45oTPZ54Y2OJmBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJJkufjhzkAC/430UxmZ+fGxuVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJLp4gcwq8lTXD0v6ewA9Gy9N5sgnpObFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkGS6+AXTpgAA9/Mz2ZzcrAAAAEliBQAASBIrAABAklgBAACSxAoAAJBkDQx4NOsxADAuNysAAECSWAEAAJLECgAAkCRWAACAJLECAAAkiRUAACDJdDGQYWYYAPiTmxUAACBJrAAAAEliBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAkpZ1Xde7XwQAAMC/uVkBAACSxAoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEj6fvcPLsty5uuAtFe/jsj5YGbOB2xzPmDbO7/u0c0KAACQJFYAAIAksQIAACSJFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEliBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJIkVAAAg6fvuFwAAvLau68f/zmVZPv53AnySmxUAACBJrAAAAEliBQAASBIrAABAklgBAACSrIEBwAnOWO/6tL3XaCmMkYxw3pypY9ysAAAASWIFAABIEisAAECSWAEAAJLECgAAkCRWAACAJNPFAHDQCHOpMJqnnitT4ce4WQEAAJLECgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEmmi4HhjT5zabKSfxx9Fs44A2ZWmcHeszz6Z8tTuFkBAACSxAoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJpotPYOruZ0xgzsX5+JuJ2DbPLIxthHlinwPb3KwAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAk08UvVCbtYDSjn52tqcjRvy6eaYRpVhiNc9XgZgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAksQIAACSZLgamtTdLWbE3jznC6x/Fk2dIPSeM5tPT8We8j5o1vo6bFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkGS6+IXRp+mOTPKN8HUxn8r86hmvozTHCTAi73nP5WYFAABIEisAAECSWAEAAJLECgAAkCRWAACAJGtgvzD68sSVq1+jf6+4n+UrgLmV3ustp17HzQoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgyXczHlCYFud/W8zDr3OOsXzdzufo597nDU3iWt7lZAQAAksQKAACQJFYAAIAksQIAACSJFQAAIEmsAAAASaaLH8AkKrPbOwNXzkGabeVdo//bVT53KmefZ6o857NzswIAACSJFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJJMF/MjpiD5rb1n6IyZyNGnJ525Z9p6Lq/+9x79fMBvXXkGvJ8f42YFAABIEisAAECSWAEAAJLECgAAkCRWAACAJLECAAAkmS4ehHlJgPNcPal95P/r6OzprJ8fZ3wvGdOsZ+Ap3KwAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAk08UhpvWY3ejTrOZQuUvlDIxi6/vlDPMJnqPPcrMCAAAkiRUAACBJrAAAAEliBQAASBIrAABAklgBAACSTBdfbIR5SZN7FFXOjvPBXSpnYM8Z52OEr5v7eU6ey80KAACQJFYAAIAksQIAACSJFQAAIEmsAAAASdbATjDKIoVVI+5QOh/OABzz6bNTel+Ad/j8uI6bFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkGS6+AHM53GXEeZGnQ9+6+gzNML5OOrJXxv3G+H5+vRr9Fm1zc0KAACQJFYAAIAksQIAACSJFQAAIEmsAAAASWIFAABIMl38C1dO65m04y4jTEg6HwA9I3x+0OdmBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJJkufsHsHjMY4Tk3T8xo9p7ZEc7c6LxnMJKr3xNGOh9uVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQNI008UjzESONCPHeJwB6PCsA7zHzQoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEh61HRxZZrVJCU4BwCzu/Jz4OqfAX3GXcfNCgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEliBQAASHrUdPHVzNZxh8pE99eXMwBAg8+j53KzAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJI1MGCXhRUA4C5uVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJLp4hfMtjIDzzkAUORmBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJD1qutj8KjPwnAMAs3CzAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAkpZ1Xde7XwQAAMC/uVkBAACSxAoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEj6fvcPLsty5uuAtFe/jsj5YGbOB2xzPmDbO7/u0c0KAACQJFYAAIAksQIAACSJFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEliBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAksQIAACSJFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkPR99wtgLOu6bv5vy7Jc+EoAxrX3XlrhPR0ocLMCAAAkiRUAACBJrAAAAEliBQAASBIrAABAklgBAACSTBf/wqenJyszkUe/rqP/XeXrBvipESaIjzrytXk/Bz7NzQoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgyXQwAO548T3yUieIxXf0sH31OnvqrITjGzQoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgyXfyCyUo4xtlpMuHJJ2ydb88Xf6p8DlReh/NxjJsVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQZLoY2FWZfOQz9v49zWre74x/A2cYGrz/HuNmBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJJku/pp31nHWrxtmZh7zmbyf84698+8ZupdZ421uVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEiyBnax2RcdYI/zwewsMvEkn35Pdz7m5GYFAABIEisAAECSWAEAAJLECgAAkCRWAACAJLECAAAkTTNdfOXcnflVRuN8AD/hHD/PCP+mV79GU8kNblYAAIAksQIAACSJFQAAIEmsAAAASWIFAABIEisAAEDSo6aLTcz9rfI9GWESkc/ybw7PdeSzxXsCbHM+trlZAQAAksQKAACQJFYAAIAksQIAACSJFQAAIEmsAAAASY+aLr7alTNzlQli+FNlavHo+ai8fpiBcwrb9s7H7GfAzQoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgyXfwLWzNzexNzT54gnn1ab2Qj/NudcXaO/J0jfK/4rFnf0wEK3KwAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAk08UnMGUJMAezxufb+z6aEofnc7MCAAAkiRUAACBJrAAAAEliBQAASBIrAABAklgBAACSTBfzI2YiucvRZ+/T87FmVHnX6LPGR57nEb4uYCxuVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEh61BrYjMsrX19jfG1wJmeAospzaaUOGJmbFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkPSo6eI9phuBn/CeAT83+q8QgD95nhvcrAAAAEliBQAASBIrAABAklgBAACSxAoAAJAkVgAAgKRppotHd+VEnslWRuOZhWuZbQWu4mYFAABIEisAAECSWAEAAJLECgAAkCRWAACAJLECAAAkmS4GgAfbmxk2+w3UuVkBAACSxAoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJpov5i5lLgN/be7/ce5+9UuV1AGxxswIAACSJFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJJMF/MX88QAVPhMgrm5WQEAAJLECgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEmmiwHgYuZ4Ad7jZgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAka2CDsBwDAMBs3KwAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAksQIAACSJFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkPR99wsAKFrX9cf/zbIsJ7wSAGq831/HzQoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEha1iP7nAAAACdzswIAACSJFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkPT97h9cluXM1wFpr34dkfPBzJwP2OZ8wLZ3ft2jmxUAACBJrAAAAEliBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAksQIAACSJFQAAIEmsAAAASWIFAABIEisAAEDS990vgPes63r3SzjNsix3vwQAgP9y5c9efhba5mYFAABIEisAAECSWAEAAJLECgAAkCRWAACAJGtgwKONvqRnIYa7fPrseJYpGv0zYgZuVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJLp4pAz5vM+PRVp4o/f8gz9zN73yxRs25XPumcBtvncGZubFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkGS6+AGunKzc+/8yDcifPA/MwHMODaWzaEr8s9ysAAAASWIFAABIEisAAECSWAEAAJLECgAAkCRWAACAJNPFFztjWm/v7zwyNXx0cs+sMQBwFj9LzMnNCgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEliBQAASDJd/HBHZv6OTiHvOfrfMa6tf/PS9OSVz2Xp62ZMZzyvnks4xs8113GzAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAkkwXX8z0JLMz9wjAnsrPNT6vGtysAAAASWIFAABIEisAAECSWAEAAJLECgAAkCRWAACAJNPFIXtTfZX5vBFeI5ypMqkJMLLKe6mfXfrcrAAAAEliBQAASBIrAABAklgBAACSxAoAAJBkDexiR9cvrGbAtsr5AAA+y80KAACQJFYAAIAksQIAACSJFQAAIEmsAAAASWIFAABIMl18gtFnVM0Tc5fRz84ZnMf7eS4B7uNmBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJJku/gVzlsAnmCfmH54FnqTyc9LRc3X09TvHn+VmBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJJku/upM68Hs9uYeRz+npizbrn6+Ks/DlWdu7++rfD+Yzxln/8jf6Qxsc7MCAAAkiRUAACBJrAAAAEliBQAASBIrAABAklgBAACSTBeHHJ2tG33SFd4x+qyx2Vb+tPU8jP6cHzXrdPTTVZ7nEc7O0dc4w7PsZgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAksQIAACSZLj7BDDNyUHLGmRth6pLn8dwB/Dc3KwAAQJJYAQAAksQKAACQJFYAAIAksQIAACSJFQAAIMl08dcYU8PmLAEAmI2bFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJKsgcGDHF2NG2ER7yhLerxj7wx4hsb05Pc15jL7s+xmBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJJkuDjGPyTvOeE72/s5PT7oenWB0PrhLZTa0dAYq3xPg+dysAAAASWIFAABIEisAAECSWAEAAJLECgAAkCRWAACApOGmi6+cWH31dx5hepLRfPqZLZ0BYJvPCLiO87bNzQoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgabrr4jHniPWZWqbn6DPAZZikB/uPJvxqCz3KzAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAkoabLuZvJlH5h1nj8zlvAD2lzz+fE5/lZgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAIAksQIAACQ9arrYVBxscz5gbGdMs3pfYAae87G5WQEAAJLECgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEmPmi4GgBmZZgWeys0KAACQJFYAAIAksQIAACSJFQAAIEmsAAAASWIFAABIEisAAECSWAEAAJLECgAAkCRWAACAJLECAAAkiRUAACBJrAAAAEliBQAASBIrAABAklgBAACSxAoAAJAkVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAICkZV3X9e4XAQAA8G9uVgAAgCSxAgAAJIkVAAAgSawAAABJYgUAAEgSKwAAQJJYAQAAksQKAACQJFYAAICk/wetfq4hsMdk6gAAAABJRU5ErkJggg==", "text/plain": [ "
" ] @@ -3428,33 +3375,18 @@ "id": "VB2v5A0-QXOU" }, "source": [ - "We can also observe how the network process images at different values of t." + "We can also observe how the network processes images at different times during the sampling process in order to get an idea of how the images evolve during the generation." ] }, { "cell_type": "code", - "execution_count": 18, - "metadata": { - "id": "7ubn3VyRVrSe" - }, - "outputs": [], - "source": [ - "def get_sample():\n", - " for i in train_loader:\n", - " x, y = i\n", - " break\n", - " return x" - ] - }, - { - "cell_type": "code", - "execution_count": 19, + "execution_count": 21, "metadata": { "id": "gqt9eXwlQc9l" }, "outputs": [], "source": [ - "x_0 = get_sample()[0][0]\n", + "x_0 = get_sample(train_loader)[0][0][0]\n", "\n", "Ys = []\n", "Ks = []\n", @@ -3462,8 +3394,7 @@ "\n", "# We set t going from 0 to 2/3\n", "for t in np.linspace(0.001, 0.667, 20):\n", - " l, y, k, t_ = bfn.process(x_0[None, :, :, None].to(torch.int64).to(device), training=False, t=t)\n", - "\n", + " l, y, k, t_ = bfn.process(x_0[None, :, :, None].to(torch.int64).to(DEVICE), training=False, time=t)\n", " Ys.append(y.permute(0, 2, 1, 3).cpu().numpy()[0, :, :, 1])\n", " Ks.append(k.permute(0, 2, 1).cpu().numpy()[0])\n", " Ts.append(t)" @@ -3471,7 +3402,7 @@ }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 22, "metadata": { "colab": { "base_uri": "https://localhost:8080/", @@ -3483,7 +3414,7 @@ "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -3503,6 +3434,13 @@ "\n", " ax[0, i].set_title(np.round(Ts[i], 2))" ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As the process evolves, the images are getting clearer and clearer, to finally look like a sample from the training dataset." + ] } ], "metadata": { @@ -3516,7 +3454,16 @@ "name": "python3" }, "language_info": { - "name": "python" + "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" }, "widgets": { "application/vnd.jupyter.widget-state+json": { From 5f680570dcb6357f668be40cd6ff397de1d0dacd Mon Sep 17 00:00:00 2001 From: Vanonym <60972074+brayevalerien@users.noreply.github.com> Date: Sat, 30 Dec 2023 00:11:04 +0100 Subject: [PATCH 2/2] Minor changes in md cells Fixed typos and a bad link --- BFN_MNIST.ipynb | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/BFN_MNIST.ipynb b/BFN_MNIST.ipynb index 99ed9e2..598baaa 100644 --- a/BFN_MNIST.ipynb +++ b/BFN_MNIST.ipynb @@ -5,7 +5,7 @@ "metadata": {}, "source": [ "# Bayesian Flow Networks for discretized MNIST\n", - "In this notebook, we demonstrate how [Bayesian Flow Networks](https://arxiv.org/abs/2308.07037) (BFN) can be used to generate samples similar to data from discretized MNIST." + "In this notebook, we demonstrate how [Bayesian Flow Networks](https://arxiv.org/abs/2308.07037) (BFN) can be used to generate samples similar to data from the discretized MNIST." ] }, { @@ -15,7 +15,7 @@ }, "source": [ "## Library imports\n", - "This notebook uses Pytorch EMA module. If it is not installed yet on your machine, run the following command:\n", + "This notebook uses the Pytorch EMA module. If it is not installed yet on your machine, run the following command:\n", "```bash\n", "pip install torch-ema\n", "```" @@ -51,7 +51,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "# Preliminary code\n", + "## Preliminary code\n", "In this section we define useful variables and functions that we will need later in the notebook." ] }, @@ -334,7 +334,7 @@ "## Model definition\n", "\n", "### Intermediary model\n", - "We start by defining the convolutional model. For this project we use a simplified version of the [U-Net](https://papers.labml.ai/paper/2e48c3ffdc8311eba3db37f65e372566) architecture, with the following structure:\n", + "We start by defining the convolutional model. For this project we use a simplified version of the [U-Net](http://arxiv.org/abs/1505.04597) architecture, with the following structure:\n", "\n", "![Diagramma senza titolo.drawio.png](data:image/png;base64,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)" ]