From 02e1b5a85bde9d4da9387ee89b117f9e33babcd7 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Mon, 12 Aug 2024 10:36:05 +0200 Subject: [PATCH 1/4] VAE notebooks (copilot-generated) --- .../01_intro_to_vae.ipynb | 252 ++++++++++++++++ .../02_vae_architecture.ipynb | 167 +++++++++++ .../03_vae_training.ipynb | 228 +++++++++++++++ .../04_vae_applications.ipynb | 275 ++++++++++++++++++ docs/_toc.yml | 8 + docs/intro.md | 1 + 6 files changed, 931 insertions(+) create mode 100644 docs/90_variational_auto_encoders/01_intro_to_vae.ipynb create mode 100644 docs/90_variational_auto_encoders/02_vae_architecture.ipynb create mode 100644 docs/90_variational_auto_encoders/03_vae_training.ipynb create mode 100644 docs/90_variational_auto_encoders/04_vae_applications.ipynb diff --git a/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb b/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb new file mode 100644 index 00000000..8820a35d --- /dev/null +++ b/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb @@ -0,0 +1,252 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Introduction to Variational Auto-Encoders (VAEs)\n", + "\n", + "Variational Auto-Encoders (VAEs) are a type of generative model that are widely used in machine learning for tasks such as image generation, anomaly detection, and data compression. In this notebook, we will introduce the basic concepts and theory behind VAEs, and provide simple code examples to help you get started with implementing them." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Basic Concepts\n", + "\n", + "VAEs are a type of auto-encoder, which is a neural network used to learn efficient representations of data, typically for the purpose of dimensionality reduction. However, unlike traditional auto-encoders, VAEs are probabilistic models that learn to generate new data points similar to the training data.\n", + "\n", + "The key idea behind VAEs is to learn a latent space representation of the data, which is a lower-dimensional space that captures the essential features of the data. This latent space is then used to generate new data points by sampling from a probability distribution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Theory\n", + "\n", + "The VAE consists of two main components: the encoder and the decoder. The encoder maps the input data to a latent space, while the decoder maps the latent space back to the original data space.\n", + "\n", + "The encoder is typically a neural network that takes the input data and outputs the parameters of a probability distribution in the latent space. The decoder is another neural network that takes samples from this distribution and generates new data points.\n", + "\n", + "The training of a VAE involves maximizing the likelihood of the data under the model, which is done by minimizing a loss function that consists of two terms: the reconstruction loss and the KL divergence. The reconstruction loss measures how well the decoder can reconstruct the input data from the latent space, while the KL divergence measures how close the learned distribution is to a prior distribution." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Code Example\n", + "\n", + "Let's start with a simple implementation of a VAE using PyTorch." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torchvision import datasets, transforms\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Encoder\n", + "\n", + "The encoder network takes the input data and outputs the parameters of the latent distribution (mean and log variance)." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, latent_dim):\n", + " super(Encoder, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", + " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", + " self.relu = nn.ReLU()\n", + " \n", + " def forward(self, x):\n", + " h = self.relu(self.fc1(x))\n", + " mean = self.fc2_mean(h)\n", + " log_var = self.fc2_log_var(h)\n", + " return mean, log_var" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Decoder\n", + "\n", + "The decoder network takes samples from the latent distribution and generates new data points." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dim, hidden_dim, output_dim):\n", + " super(Decoder, self).__init__()\n", + " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", + " self.relu = nn.ReLU()\n", + " self.sigmoid = nn.Sigmoid()\n", + " \n", + " def forward(self, z):\n", + " h = self.relu(self.fc1(z))\n", + " x_reconstructed = self.sigmoid(self.fc2(h))\n", + " return x_reconstructed" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the VAE\n", + "\n", + "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class VAE(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(VAE, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + " \n", + " def forward(self, x):\n", + " mean, log_var = self.encoder(x)\n", + " std = torch.exp(0.5 * log_var)\n", + " epsilon = torch.randn_like(std)\n", + " z = mean + std * epsilon\n", + " x_reconstructed = self.decoder(z)\n", + " return x_reconstructed, mean, log_var" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Loss Function\n", + "\n", + "The loss function consists of the reconstruction loss and the KL divergence." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "def vae_loss(x, x_reconstructed, mean, log_var):\n", + " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", + " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", + " return reconstruction_loss + kl_divergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train the VAE\n", + "\n", + "Let's train the VAE on a simple dataset, such as the MNIST dataset." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Load the MNIST dataset\n", + "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", + "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", + "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", + "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Define the VAE model\n", + "input_dim = 28 * 28\n", + "hidden_dim = 256\n", + "latent_dim = 2\n", + "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", + "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", + "vae = VAE(encoder, decoder)\n", + "\n", + "# Define the optimizer\n", + "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", + "\n", + "# Train the model\n", + "num_epochs = 10\n", + "for epoch in range(num_epochs):\n", + " vae.train()\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " optimizer.zero_grad()\n", + " x_reconstructed, mean, log_var = vae(x)\n", + " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", + " loss.backward()\n", + " train_loss += loss.item()\n", + " optimizer.step()\n", + " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the Results\n", + "\n", + "Let's visualize the latent space learned by the VAE and generate some new data points." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Encode the test data to the latent space\n", + "vae.eval()\n", + "with torch.no_grad():\n", + " z_mean, z_log_var = [], []\n", + " for x, _ in test_loader:\n", + " mean, log_var = vae.encoder(x)\n", + " z_mean.append(mean)\n", + " z_log_var.append(log_var)\n", + " z_mean = torch.cat(z_mean)\n", + " z_log_var = torch.cat(z_log_var)\n", + " z = z_mean + torch.exp(0.5 * z_log_var) * torch.randn_like(z_mean)\n", + "\n", + "# Plot the latent space\n", + "plt.figure(figsize=(8, 6))\n", + "plt.scatter(z[:, 0].numpy(), z[:, 1].numpy(), c='blue', alpha=0.5)\n", + "plt.xlabel('z1')\n", + "plt.ylabel('z2')\n", + "plt.title('Latent Space')\n", + "plt.show()\n", + "\n", + "# Generate new data points\n", + "z_new = torch.randn(10, latent_dim)\n", + "with torch.no_grad():\n", + " generated = vae.decoder(z_new)\n", + "\n", + "# Plot the generated data points\n", + "plt.figure(figsize=(10, 2))\n", + "for i in range(10):\n", + " plt.subplot(1, 10, i + 1)\n", + " plt.imshow(generated[i].view(28, 28).numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "plt.show()" + ] + } + ] +} diff --git a/docs/90_variational_auto_encoders/02_vae_architecture.ipynb b/docs/90_variational_auto_encoders/02_vae_architecture.ipynb new file mode 100644 index 00000000..bf6740da --- /dev/null +++ b/docs/90_variational_auto_encoders/02_vae_architecture.ipynb @@ -0,0 +1,167 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# VAE Architecture\n", + "\n", + "In this notebook, we will delve into the architecture of Variational Auto-Encoders (VAEs). We will explain the components of a VAE, including the encoder and decoder, and provide code examples for building a VAE architecture using PyTorch." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Encoder\n", + "\n", + "The encoder is a neural network that takes the input data and maps it to a latent space. The output of the encoder is the parameters of a probability distribution in the latent space, typically the mean and log variance." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "\n", + "class Encoder(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, latent_dim):\n", + " super(Encoder, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", + " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", + " self.relu = nn.ReLU()\n", + " \n", + " def forward(self, x):\n", + " h = self.relu(self.fc1(x))\n", + " mean = self.fc2_mean(h)\n", + " log_var = self.fc2_log_var(h)\n", + " return mean, log_var" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Decoder\n", + "\n", + "The decoder is a neural network that takes samples from the latent distribution and maps them back to the original data space. The output of the decoder is the reconstructed data." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dim, hidden_dim, output_dim):\n", + " super(Decoder, self).__init__()\n", + " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", + " self.relu = nn.ReLU()\n", + " self.sigmoid = nn.Sigmoid()\n", + " \n", + " def forward(self, z):\n", + " h = self.relu(self.fc1(z))\n", + " x_reconstructed = self.sigmoid(self.fc2(h))\n", + " return x_reconstructed" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## VAE Model\n", + "\n", + "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class VAE(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(VAE, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + " \n", + " def forward(self, x):\n", + " mean, log_var = self.encoder(x)\n", + " std = torch.exp(0.5 * log_var)\n", + " epsilon = torch.randn_like(std)\n", + " z = mean + std * epsilon\n", + " x_reconstructed = self.decoder(z)\n", + " return x_reconstructed, mean, log_var" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loss Function\n", + "\n", + "The loss function for a VAE consists of two terms: the reconstruction loss and the KL divergence. The reconstruction loss measures how well the decoder can reconstruct the input data from the latent space, while the KL divergence measures how close the learned distribution is to a prior distribution." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "def vae_loss(x, x_reconstructed, mean, log_var):\n", + " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", + " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", + " return reconstruction_loss + kl_divergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training the VAE\n", + "\n", + "Let's train the VAE on a simple dataset, such as the MNIST dataset." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "from torchvision import datasets, transforms\n", + "import torch.optim as optim\n", + "\n", + "# Load the MNIST dataset\n", + "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", + "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", + "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", + "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Define the VAE model\n", + "input_dim = 28 * 28\n", + "hidden_dim = 256\n", + "latent_dim = 2\n", + "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", + "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", + "vae = VAE(encoder, decoder)\n", + "\n", + "# Define the optimizer\n", + "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", + "\n", + "# Train the model\n", + "num_epochs = 10\n", + "for epoch in range(num_epochs):\n", + " vae.train()\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " optimizer.zero_grad()\n", + " x_reconstructed, mean, log_var = vae(x)\n", + " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", + " loss.backward()\n", + " train_loss += loss.item()\n", + " optimizer.step()\n", + " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" + ] + } + ] +} diff --git a/docs/90_variational_auto_encoders/03_vae_training.ipynb b/docs/90_variational_auto_encoders/03_vae_training.ipynb new file mode 100644 index 00000000..bc7d12c3 --- /dev/null +++ b/docs/90_variational_auto_encoders/03_vae_training.ipynb @@ -0,0 +1,228 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training Variational Auto-Encoders (VAEs)\n", + "\n", + "In this notebook, we will focus on training Variational Auto-Encoders (VAEs). We will provide code examples for training VAEs and explain the loss functions and optimization techniques used in the training process." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Code Example\n", + "\n", + "Let's start with a simple implementation of a VAE using PyTorch." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torchvision import datasets, transforms\n", + "import matplotlib.pyplot as plt" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Encoder\n", + "\n", + "The encoder network takes the input data and outputs the parameters of the latent distribution (mean and log variance)." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, latent_dim):\n", + " super(Encoder, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", + " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", + " self.relu = nn.ReLU()\n", + " \n", + " def forward(self, x):\n", + " h = self.relu(self.fc1(x))\n", + " mean = self.fc2_mean(h)\n", + " log_var = self.fc2_log_var(h)\n", + " return mean, log_var" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Decoder\n", + "\n", + "The decoder network takes samples from the latent distribution and generates new data points." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dim, hidden_dim, output_dim):\n", + " super(Decoder, self).__init__()\n", + " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", + " self.relu = nn.ReLU()\n", + " self.sigmoid = nn.Sigmoid()\n", + " \n", + " def forward(self, z):\n", + " h = self.relu(self.fc1(z))\n", + " x_reconstructed = self.sigmoid(self.fc2(h))\n", + " return x_reconstructed" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the VAE\n", + "\n", + "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class VAE(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(VAE, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + " \n", + " def forward(self, x):\n", + " mean, log_var = self.encoder(x)\n", + " std = torch.exp(0.5 * log_var)\n", + " epsilon = torch.randn_like(std)\n", + " z = mean + std * epsilon\n", + " x_reconstructed = self.decoder(z)\n", + " return x_reconstructed, mean, log_var" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Loss Function\n", + "\n", + "The loss function consists of the reconstruction loss and the KL divergence." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "def vae_loss(x, x_reconstructed, mean, log_var):\n", + " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", + " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", + " return reconstruction_loss + kl_divergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train the VAE\n", + "\n", + "Let's train the VAE on a simple dataset, such as the MNIST dataset." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Load the MNIST dataset\n", + "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", + "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", + "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", + "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Define the VAE model\n", + "input_dim = 28 * 28\n", + "hidden_dim = 256\n", + "latent_dim = 2\n", + "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", + "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", + "vae = VAE(encoder, decoder)\n", + "\n", + "# Define the optimizer\n", + "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", + "\n", + "# Train the model\n", + "num_epochs = 10\n", + "for epoch in range(num_epochs):\n", + " vae.train()\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " optimizer.zero_grad()\n", + " x_reconstructed, mean, log_var = vae(x)\n", + " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", + " loss.backward()\n", + " train_loss += loss.item()\n", + " optimizer.step()\n", + " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the Results\n", + "\n", + "Let's visualize the latent space learned by the VAE and generate some new data points." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Encode the test data to the latent space\n", + "vae.eval()\n", + "with torch.no_grad():\n", + " z_mean, z_log_var = [], []\n", + " for x, _ in test_loader:\n", + " mean, log_var = vae.encoder(x)\n", + " z_mean.append(mean)\n", + " z_log_var.append(log_var)\n", + " z_mean = torch.cat(z_mean)\n", + " z_log_var = torch.cat(z_log_var)\n", + " z = z_mean + torch.exp(0.5 * z_log_var) * torch.randn_like(z_mean)\n", + "\n", + "# Plot the latent space\n", + "plt.figure(figsize=(8, 6))\n", + "plt.scatter(z[:, 0].numpy(), z[:, 1].numpy(), c='blue', alpha=0.5)\n", + "plt.xlabel('z1')\n", + "plt.ylabel('z2')\n", + "plt.title('Latent Space')\n", + "plt.show()\n", + "\n", + "# Generate new data points\n", + "z_new = torch.randn(10, latent_dim)\n", + "with torch.no_grad():\n", + " generated = vae.decoder(z_new)\n", + "\n", + "# Plot the generated data points\n", + "plt.figure(figsize=(10, 2))\n", + "for i in range(10):\n", + " plt.subplot(1, 10, i + 1)\n", + " plt.imshow(generated[i].view(28, 28).numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "plt.show()" + ] + } + ] +} diff --git a/docs/90_variational_auto_encoders/04_vae_applications.ipynb b/docs/90_variational_auto_encoders/04_vae_applications.ipynb new file mode 100644 index 00000000..22f0d70c --- /dev/null +++ b/docs/90_variational_auto_encoders/04_vae_applications.ipynb @@ -0,0 +1,275 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Applications of Variational Auto-Encoders (VAEs)\n", + "\n", + "In this notebook, we will explore some practical applications of Variational Auto-Encoders (VAEs). We will provide examples of using VAEs for image generation and other practical applications." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Image Generation\n", + "\n", + "One of the most popular applications of VAEs is image generation. VAEs can be used to generate new images that are similar to the training data. Let's see how we can use a trained VAE to generate new images." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "import torch\n", + "from torch import nn, optim\n", + "from torchvision import datasets, transforms\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Encoder\n", + "\n", + "The encoder network takes the input data and outputs the parameters of the latent distribution (mean and log variance)." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, latent_dim):\n", + " super(Encoder, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", + " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", + " self.relu = nn.ReLU()\n", + " \n", + " def forward(self, x):\n", + " h = self.relu(self.fc1(x))\n", + " mean = self.fc2_mean(h)\n", + " log_var = self.fc2_log_var(h)\n", + " return mean, log_var" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Decoder\n", + "\n", + "The decoder network takes samples from the latent distribution and generates new data points." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dim, hidden_dim, output_dim):\n", + " super(Decoder, self).__init__()\n", + " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", + " self.relu = nn.ReLU()\n", + " self.sigmoid = nn.Sigmoid()\n", + " \n", + " def forward(self, z):\n", + " h = self.relu(self.fc1(z))\n", + " x_reconstructed = self.sigmoid(self.fc2(h))\n", + " return x_reconstructed" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the VAE\n", + "\n", + "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class VAE(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(VAE, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + " \n", + " def forward(self, x):\n", + " mean, log_var = self.encoder(x)\n", + " std = torch.exp(0.5 * log_var)\n", + " epsilon = torch.randn_like(std)\n", + " z = mean + std * epsilon\n", + " x_reconstructed = self.decoder(z)\n", + " return x_reconstructed, mean, log_var" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Loss Function\n", + "\n", + "The loss function consists of the reconstruction loss and the KL divergence." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "def vae_loss(x, x_reconstructed, mean, log_var):\n", + " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", + " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", + " return reconstruction_loss + kl_divergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train the VAE\n", + "\n", + "Let's train the VAE on a simple dataset, such as the MNIST dataset." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Load the MNIST dataset\n", + "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", + "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", + "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", + "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Define the VAE model\n", + "input_dim = 28 * 28\n", + "hidden_dim = 256\n", + "latent_dim = 2\n", + "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", + "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", + "vae = VAE(encoder, decoder)\n", + "\n", + "# Define the optimizer\n", + "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", + "\n", + "# Train the model\n", + "num_epochs = 10\n", + "for epoch in range(num_epochs):\n", + " vae.train()\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " optimizer.zero_grad()\n", + " x_reconstructed, mean, log_var = vae(x)\n", + " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", + " loss.backward()\n", + " train_loss += loss.item()\n", + " optimizer.step()\n", + " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate New Images\n", + "\n", + "Now that we have trained the VAE, we can use it to generate new images." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Generate new data points\n", + "z_new = torch.randn(10, latent_dim)\n", + "with torch.no_grad():\n", + " generated = vae.decoder(z_new)\n", + "\n", + "# Plot the generated data points\n", + "plt.figure(figsize=(10, 2))\n", + "for i in range(10):\n", + " plt.subplot(1, 10, i + 1)\n", + " plt.imshow(generated[i].view(28, 28).numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Anomaly Detection\n", + "\n", + "VAEs can also be used for anomaly detection. By training a VAE on normal data, we can use the reconstruction error to detect anomalies. Data points with high reconstruction error are likely to be anomalies." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Calculate reconstruction error for test data\n", + "vae.eval()\n", + "with torch.no_grad():\n", + " reconstructed, _, _ = vae(torch.tensor(x_test, dtype=torch.float32))\n", + " reconstruction_error = torch.mean((torch.tensor(x_test, dtype=torch.float32) - reconstructed) ** 2, axis=1)\n", + "\n", + "# Plot reconstruction error\n", + "plt.figure(figsize=(8, 6))\n", + "plt.hist(reconstruction_error.numpy(), bins=50)\n", + "plt.xlabel('Reconstruction Error')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Reconstruction Error Histogram')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Compression\n", + "\n", + "VAEs can be used for data compression by encoding the data into a lower-dimensional latent space. The latent representation can then be used to reconstruct the original data." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Encode the test data to the latent space\n", + "vae.eval()\n", + "with torch.no_grad():\n", + " mean, log_var = vae.encoder(torch.tensor(x_test, dtype=torch.float32))\n", + " std = torch.exp(0.5 * log_var)\n", + " z = mean + std * torch.randn_like(std)\n", + "\n", + "# Decode the latent representation to reconstruct the data\n", + "with torch.no_grad():\n", + " reconstructed = vae.decoder(z)\n", + "\n", + "# Plot original and reconstructed data\n", + "plt.figure(figsize=(10, 4))\n", + "for i in range(10):\n", + " # Original data\n", + " plt.subplot(2, 10, i + 1)\n", + " plt.imshow(x_test[i].reshape(28, 28), cmap='gray')\n", + " plt.axis('off')\n", + " \n", + " # Reconstructed data\n", + " plt.subplot(2, 10, i + 11)\n", + " plt.imshow(reconstructed[i].view(28, 28).numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "plt.show()" + ] + } + ] +} diff --git a/docs/_toc.yml b/docs/_toc.yml index 24fb3f8f..04061f49 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -118,6 +118,14 @@ parts: - file: 80_benchmarking_llms/30_measuring_executability.ipynb - file: 80_benchmarking_llms/40_summarize_error_messages.ipynb + + - caption: Variational Auto-Encoders + chapters: + - file: 90_variational_auto_encoders/01_intro_to_vae.ipynb + - file: 90_variational_auto_encoders/02_vae_architecture.ipynb + - file: 90_variational_auto_encoders/03_vae_training.ipynb + - file: 90_variational_auto_encoders/04_vae_applications.ipynb + - caption: Links chapters: diff --git a/docs/intro.md b/docs/intro.md index 7f416652..83561a3b 100644 --- a/docs/intro.md +++ b/docs/intro.md @@ -14,6 +14,7 @@ The notebook collection aims covering these topics: * Prompt Engineering * Retrieval-augmented-generation * Model fine-tuning +* Variational Auto-Encoders (VAEs) ## Covered Python libraries and software From 748443b527528e641e772854b35a333365b0b0b8 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Mon, 12 Aug 2024 10:45:59 +0200 Subject: [PATCH 2/4] fixing JSON format using claude and gpt4o --- .../01_intro_to_vae.ipynb | 44 +- .../02_vae_architecture.ipynb | 353 ++++++----- .../03_vae_training.ipynb | 495 ++++++++------- .../04_vae_applications.ipynb | 594 ++++++++++-------- 4 files changed, 820 insertions(+), 666 deletions(-) diff --git a/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb b/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb index 8820a35d..e6fcfa4c 100644 --- a/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb +++ b/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb @@ -1,5 +1,12 @@ { "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "
This notebook may contain text, code and images generated by artificial intelligence. Used model: claude-3-5-sonnet-20240620, vision model: claude-3-5-sonnet-20240620, endpoint: None, bia-bob version: 0.21.1.. It is good scientific practice to check the code and results it produces carefully. Read more about code generation using bia-bob
" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -44,7 +51,9 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ "import torch\n", "import torch.nn as nn\n", @@ -64,7 +73,9 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ "class Encoder(nn.Module):\n", " def __init__(self, input_dim, hidden_dim, latent_dim):\n", @@ -92,7 +103,9 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ "class Decoder(nn.Module):\n", " def __init__(self, latent_dim, hidden_dim, output_dim):\n", @@ -119,7 +132,9 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ "class VAE(nn.Module):\n", " def __init__(self, encoder, decoder):\n", @@ -147,7 +162,9 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ "def vae_loss(x, x_reconstructed, mean, log_var):\n", " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", @@ -166,7 +183,9 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ "# Load the MNIST dataset\n", "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", @@ -212,7 +231,9 @@ }, { "cell_type": "code", + "execution_count": null, "metadata": {}, + "outputs": [], "source": [ "# Encode the test data to the latent space\n", "vae.eval()\n", @@ -248,5 +269,26 @@ "plt.show()" ] } - ] + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 } diff --git a/docs/90_variational_auto_encoders/02_vae_architecture.ipynb b/docs/90_variational_auto_encoders/02_vae_architecture.ipynb index bf6740da..d611d683 100644 --- a/docs/90_variational_auto_encoders/02_vae_architecture.ipynb +++ b/docs/90_variational_auto_encoders/02_vae_architecture.ipynb @@ -1,167 +1,188 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# VAE Architecture\n", - "\n", - "In this notebook, we will delve into the architecture of Variational Auto-Encoders (VAEs). We will explain the components of a VAE, including the encoder and decoder, and provide code examples for building a VAE architecture using PyTorch." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Encoder\n", - "\n", - "The encoder is a neural network that takes the input data and maps it to a latent space. The output of the encoder is the parameters of a probability distribution in the latent space, typically the mean and log variance." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "\n", - "class Encoder(nn.Module):\n", - " def __init__(self, input_dim, hidden_dim, latent_dim):\n", - " super(Encoder, self).__init__()\n", - " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", - " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", - " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", - " self.relu = nn.ReLU()\n", - " \n", - " def forward(self, x):\n", - " h = self.relu(self.fc1(x))\n", - " mean = self.fc2_mean(h)\n", - " log_var = self.fc2_log_var(h)\n", - " return mean, log_var" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Decoder\n", - "\n", - "The decoder is a neural network that takes samples from the latent distribution and maps them back to the original data space. The output of the decoder is the reconstructed data." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class Decoder(nn.Module):\n", - " def __init__(self, latent_dim, hidden_dim, output_dim):\n", - " super(Decoder, self).__init__()\n", - " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", - " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", - " self.relu = nn.ReLU()\n", - " self.sigmoid = nn.Sigmoid()\n", - " \n", - " def forward(self, z):\n", - " h = self.relu(self.fc1(z))\n", - " x_reconstructed = self.sigmoid(self.fc2(h))\n", - " return x_reconstructed" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## VAE Model\n", - "\n", - "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class VAE(nn.Module):\n", - " def __init__(self, encoder, decoder):\n", - " super(VAE, self).__init__()\n", - " self.encoder = encoder\n", - " self.decoder = decoder\n", - " \n", - " def forward(self, x):\n", - " mean, log_var = self.encoder(x)\n", - " std = torch.exp(0.5 * log_var)\n", - " epsilon = torch.randn_like(std)\n", - " z = mean + std * epsilon\n", - " x_reconstructed = self.decoder(z)\n", - " return x_reconstructed, mean, log_var" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loss Function\n", - "\n", - "The loss function for a VAE consists of two terms: the reconstruction loss and the KL divergence. The reconstruction loss measures how well the decoder can reconstruct the input data from the latent space, while the KL divergence measures how close the learned distribution is to a prior distribution." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "def vae_loss(x, x_reconstructed, mean, log_var):\n", - " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", - " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", - " return reconstruction_loss + kl_divergence" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training the VAE\n", - "\n", - "Let's train the VAE on a simple dataset, such as the MNIST dataset." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "from torchvision import datasets, transforms\n", - "import torch.optim as optim\n", - "\n", - "# Load the MNIST dataset\n", - "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", - "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", - "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", - "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", - "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", - "\n", - "# Define the VAE model\n", - "input_dim = 28 * 28\n", - "hidden_dim = 256\n", - "latent_dim = 2\n", - "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", - "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", - "vae = VAE(encoder, decoder)\n", - "\n", - "# Define the optimizer\n", - "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", - "\n", - "# Train the model\n", - "num_epochs = 10\n", - "for epoch in range(num_epochs):\n", - " vae.train()\n", - " train_loss = 0\n", - " for x, _ in train_loader:\n", - " optimizer.zero_grad()\n", - " x_reconstructed, mean, log_var = vae(x)\n", - " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", - " loss.backward()\n", - " train_loss += loss.item()\n", - " optimizer.step()\n", - " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" - ] - } - ] -} + "cells": [ + { + "cell_type": "markdown", + "id": "directed-compensation", + "metadata": {}, + "source": [ + "
This notebook may contain text, code and images generated by artificial intelligence. Used model: gpt-4o-2024-08-06, vision model: gpt-4o-2024-08-06, endpoint: None, bia-bob version: 0.21.1.. It is good scientific practice to check the code and results it produces carefully. Read more about code generation using bia-bob
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# VAE Architecture\n", + "\n", + "In this notebook, we will delve into the architecture of Variational Auto-Encoders (VAEs). We will explain the components of a VAE, including the encoder and decoder, and provide code examples for building a VAE architecture using PyTorch." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Encoder\n", + "\n", + "The encoder is a neural network that takes the input data and maps it to a latent space. The output of the encoder is the parameters of a probability distribution in the latent space, typically the mean and log variance." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "\n", + "class Encoder(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, latent_dim):\n", + " super(Encoder, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", + " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", + " self.relu = nn.ReLU()\n", + " \n", + " def forward(self, x):\n", + " h = self.relu(self.fc1(x))\n", + " mean = self.fc2_mean(h)\n", + " log_var = self.fc2_log_var(h)\n", + " return mean, log_var" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Decoder\n", + "\n", + "The decoder is a neural network that takes samples from the latent distribution and maps them back to the original data space. The output of the decoder is the reconstructed data." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dim, hidden_dim, output_dim):\n", + " super(Decoder, self).__init__()\n", + " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", + " self.relu = nn.ReLU()\n", + " self.sigmoid = nn.Sigmoid()\n", + " \n", + " def forward(self, z):\n", + " h = self.relu(self.fc1(z))\n", + " x_reconstructed = self.sigmoid(self.fc2(h))\n", + " return x_reconstructed" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## VAE Model\n", + "\n", + "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class VAE(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(VAE, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + " \n", + " def forward(self, x):\n", + " mean, log_var = self.encoder(x)\n", + " std = torch.exp(0.5 * log_var)\n", + " epsilon = torch.randn_like(std)\n", + " z = mean + std * epsilon\n", + " x_reconstructed = self.decoder(z)\n", + " return x_reconstructed, mean, log_var" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loss Function\n", + "\n", + "The loss function for a VAE consists of two terms: the reconstruction loss and the KL divergence. The reconstruction loss measures how well the decoder can reconstruct the input data from the latent space, while the KL divergence measures how close the learned distribution is to a prior distribution." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "def vae_loss(x, x_reconstructed, mean, log_var):\n", + " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", + " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", + " return reconstruction_loss + kl_divergence" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training the VAE\n", + "\n", + "Let's train the VAE on a simple dataset, such as the MNIST dataset." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "from torchvision import datasets, transforms\n", + "import torch.optim as optim\n", + "\n", + "# Load the MNIST dataset\n", + "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", + "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", + "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", + "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Define the VAE model\n", + "input_dim = 28 * 28\n", + "hidden_dim = 256\n", + "latent_dim = 2\n", + "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", + "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", + "vae = VAE(encoder, decoder)\n", + "\n", + "# Define the optimizer\n", + "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", + "\n", + "# Train the model\n", + "num_epochs = 10\n", + "for epoch in range(num_epochs):\n", + " vae.train()\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " optimizer.zero_grad()\n", + " x_reconstructed, mean, log_var = vae(x)\n", + " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", + " loss.backward()\n", + " train_loss += loss.item()\n", + " optimizer.step()\n", + " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" + ], + "outputs": [], + "execution_count": null + } + ], + "metadata": {}, + "nbformat": 4, + "nbformat_minor": 2 +} \ No newline at end of file diff --git a/docs/90_variational_auto_encoders/03_vae_training.ipynb b/docs/90_variational_auto_encoders/03_vae_training.ipynb index bc7d12c3..76c7ad1e 100644 --- a/docs/90_variational_auto_encoders/03_vae_training.ipynb +++ b/docs/90_variational_auto_encoders/03_vae_training.ipynb @@ -1,228 +1,271 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Training Variational Auto-Encoders (VAEs)\n", - "\n", - "In this notebook, we will focus on training Variational Auto-Encoders (VAEs). We will provide code examples for training VAEs and explain the loss functions and optimization techniques used in the training process." - ] + "cells": [ + { + "cell_type": "markdown", + "id": "directed-compensation", + "metadata": {}, + "source": [ + "
This notebook may contain text, code and images generated by artificial intelligence. Used model: gpt-4o-2024-08-06, vision model: gpt-4o-2024-08-06, endpoint: None, bia-bob version: 0.21.1.. It is good scientific practice to check the code and results it produces carefully. Read more about code generation using bia-bob
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Training Variational Auto-Encoders (VAEs)\n", + "\n", + "In this notebook, we will focus on training Variational Auto-Encoders (VAEs). We will provide code examples for training VAEs and explain the loss functions and optimization techniques used in the training process." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Code Example\n", + "\n", + "Let's start with a simple implementation of a VAE using PyTorch." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "import torch.optim as optim\n", + "from torchvision import datasets, transforms\n", + "import matplotlib.pyplot as plt" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Encoder\n", + "\n", + "The encoder network takes the input data and outputs the parameters of the latent distribution (mean and log variance)." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, latent_dim):\n", + " super(Encoder, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", + " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", + " self.relu = nn.ReLU()\n", + " \n", + " def forward(self, x):\n", + " h = self.relu(self.fc1(x))\n", + " mean = self.fc2_mean(h)\n", + " log_var = self.fc2_log_var(h)\n", + " return mean, log_var" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Decoder\n", + "\n", + "The decoder network takes samples from the latent distribution and generates new data points." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dim, hidden_dim, output_dim):\n", + " super(Decoder, self).__init__()\n", + " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", + " self.relu = nn.ReLU()\n", + " self.sigmoid = nn.Sigmoid()\n", + " \n", + " def forward(self, z):\n", + " h = self.relu(self.fc1(z))\n", + " x_reconstructed = self.sigmoid(self.fc2(h))\n", + " return x_reconstructed" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the VAE\n", + "\n", + "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class VAE(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(VAE, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + " \n", + " def forward(self, x):\n", + " mean, log_var = self.encoder(x)\n", + " std = torch.exp(0.5 * log_var)\n", + " epsilon = torch.randn_like(std)\n", + " z = mean + std * epsilon\n", + " x_reconstructed = self.decoder(z)\n", + " return x_reconstructed, mean, log_var" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Loss Function\n", + "\n", + "The loss function consists of the reconstruction loss and the KL divergence." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "def vae_loss(x, x_reconstructed, mean, log_var):\n", + " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", + " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", + " return reconstruction_loss + kl_divergence" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train the VAE\n", + "\n", + "Let's train the VAE on a simple dataset, such as the MNIST dataset." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Load the MNIST dataset\n", + "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", + "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", + "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", + "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Define the VAE model\n", + "input_dim = 28 * 28\n", + "hidden_dim = 256\n", + "latent_dim = 2\n", + "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", + "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", + "vae = VAE(encoder, decoder)\n", + "\n", + "# Define the optimizer\n", + "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", + "\n", + "# Train the model\n", + "num_epochs = 10\n", + "for epoch in range(num_epochs):\n", + " vae.train()\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " optimizer.zero_grad()\n", + " x_reconstructed, mean, log_var = vae(x)\n", + " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", + " loss.backward()\n", + " train_loss += loss.item()\n", + " optimizer.step()\n", + " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Visualize the Results\n", + "\n", + "Let's visualize the latent space learned by the VAE and generate some new data points." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Encode the test data to the latent space\n", + "vae.eval()\n", + "with torch.no_grad():\n", + " z_mean, z_log_var = [], []\n", + " for x, _ in test_loader:\n", + " mean, log_var = vae.encoder(x)\n", + " z_mean.append(mean)\n", + " z_log_var.append(log_var)\n", + " z_mean = torch.cat(z_mean)\n", + " z_log_var = torch.cat(z_log_var)\n", + " z = z_mean + torch.exp(0.5 * z_log_var) * torch.randn_like(z_mean)\n", + "\n", + "# Plot the latent space\n", + "plt.figure(figsize=(8, 6))\n", + "plt.scatter(z[:, 0].numpy(), z[:, 1].numpy(), c='blue', alpha=0.5)\n", + "plt.xlabel('z1')\n", + "plt.ylabel('z2')\n", + "plt.title('Latent Space')\n", + "plt.show()\n", + "\n", + "# Generate new data points\n", + "z_new = torch.randn(10, latent_dim)\n", + "with torch.no_grad():\n", + " generated = vae.decoder(z_new)\n", + "\n", + "# Plot the generated data points\n", + "plt.figure(figsize=(10, 2))\n", + "for i in range(10):\n", + " plt.subplot(1, 10, i + 1)\n", + " plt.imshow(generated[i].view(28, 28).numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "plt.show()" + ], + "outputs": [], + "execution_count": null + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.x" + } }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Code Example\n", - "\n", - "Let's start with a simple implementation of a VAE using PyTorch." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "from torchvision import datasets, transforms\n", - "import matplotlib.pyplot as plt" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Encoder\n", - "\n", - "The encoder network takes the input data and outputs the parameters of the latent distribution (mean and log variance)." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class Encoder(nn.Module):\n", - " def __init__(self, input_dim, hidden_dim, latent_dim):\n", - " super(Encoder, self).__init__()\n", - " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", - " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", - " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", - " self.relu = nn.ReLU()\n", - " \n", - " def forward(self, x):\n", - " h = self.relu(self.fc1(x))\n", - " mean = self.fc2_mean(h)\n", - " log_var = self.fc2_log_var(h)\n", - " return mean, log_var" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Decoder\n", - "\n", - "The decoder network takes samples from the latent distribution and generates new data points." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class Decoder(nn.Module):\n", - " def __init__(self, latent_dim, hidden_dim, output_dim):\n", - " super(Decoder, self).__init__()\n", - " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", - " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", - " self.relu = nn.ReLU()\n", - " self.sigmoid = nn.Sigmoid()\n", - " \n", - " def forward(self, z):\n", - " h = self.relu(self.fc1(z))\n", - " x_reconstructed = self.sigmoid(self.fc2(h))\n", - " return x_reconstructed" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the VAE\n", - "\n", - "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class VAE(nn.Module):\n", - " def __init__(self, encoder, decoder):\n", - " super(VAE, self).__init__()\n", - " self.encoder = encoder\n", - " self.decoder = decoder\n", - " \n", - " def forward(self, x):\n", - " mean, log_var = self.encoder(x)\n", - " std = torch.exp(0.5 * log_var)\n", - " epsilon = torch.randn_like(std)\n", - " z = mean + std * epsilon\n", - " x_reconstructed = self.decoder(z)\n", - " return x_reconstructed, mean, log_var" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Loss Function\n", - "\n", - "The loss function consists of the reconstruction loss and the KL divergence." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "def vae_loss(x, x_reconstructed, mean, log_var):\n", - " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", - " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", - " return reconstruction_loss + kl_divergence" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Train the VAE\n", - "\n", - "Let's train the VAE on a simple dataset, such as the MNIST dataset." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Load the MNIST dataset\n", - "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", - "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", - "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", - "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", - "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", - "\n", - "# Define the VAE model\n", - "input_dim = 28 * 28\n", - "hidden_dim = 256\n", - "latent_dim = 2\n", - "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", - "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", - "vae = VAE(encoder, decoder)\n", - "\n", - "# Define the optimizer\n", - "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", - "\n", - "# Train the model\n", - "num_epochs = 10\n", - "for epoch in range(num_epochs):\n", - " vae.train()\n", - " train_loss = 0\n", - " for x, _ in train_loader:\n", - " optimizer.zero_grad()\n", - " x_reconstructed, mean, log_var = vae(x)\n", - " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", - " loss.backward()\n", - " train_loss += loss.item()\n", - " optimizer.step()\n", - " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualize the Results\n", - "\n", - "Let's visualize the latent space learned by the VAE and generate some new data points." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Encode the test data to the latent space\n", - "vae.eval()\n", - "with torch.no_grad():\n", - " z_mean, z_log_var = [], []\n", - " for x, _ in test_loader:\n", - " mean, log_var = vae.encoder(x)\n", - " z_mean.append(mean)\n", - " z_log_var.append(log_var)\n", - " z_mean = torch.cat(z_mean)\n", - " z_log_var = torch.cat(z_log_var)\n", - " z = z_mean + torch.exp(0.5 * z_log_var) * torch.randn_like(z_mean)\n", - "\n", - "# Plot the latent space\n", - "plt.figure(figsize=(8, 6))\n", - "plt.scatter(z[:, 0].numpy(), z[:, 1].numpy(), c='blue', alpha=0.5)\n", - "plt.xlabel('z1')\n", - "plt.ylabel('z2')\n", - "plt.title('Latent Space')\n", - "plt.show()\n", - "\n", - "# Generate new data points\n", - "z_new = torch.randn(10, latent_dim)\n", - "with torch.no_grad():\n", - " generated = vae.decoder(z_new)\n", - "\n", - "# Plot the generated data points\n", - "plt.figure(figsize=(10, 2))\n", - "for i in range(10):\n", - " plt.subplot(1, 10, i + 1)\n", - " plt.imshow(generated[i].view(28, 28).numpy(), cmap='gray')\n", - " plt.axis('off')\n", - "plt.show()" - ] - } - ] -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/docs/90_variational_auto_encoders/04_vae_applications.ipynb b/docs/90_variational_auto_encoders/04_vae_applications.ipynb index 22f0d70c..6119b61c 100644 --- a/docs/90_variational_auto_encoders/04_vae_applications.ipynb +++ b/docs/90_variational_auto_encoders/04_vae_applications.ipynb @@ -1,275 +1,323 @@ { - "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Applications of Variational Auto-Encoders (VAEs)\n", - "\n", - "In this notebook, we will explore some practical applications of Variational Auto-Encoders (VAEs). We will provide examples of using VAEs for image generation and other practical applications." - ] + "cells": [ + { + "cell_type": "markdown", + "id": "directed-compensation", + "metadata": {}, + "source": [ + "
This notebook may contain text, code and images generated by artificial intelligence. Used model: gpt-4o-2024-08-06, vision model: gpt-4o-2024-08-06, endpoint: None, bia-bob version: 0.21.1.. It is good scientific practice to check the code and results it produces carefully. Read more about code generation using bia-bob
" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Applications of Variational Auto-Encoders (VAEs)\n", + "\n", + "In this notebook, we will explore some practical applications of Variational Auto-Encoders (VAEs). We will provide examples of using VAEs for image generation and other practical applications." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Image Generation\n", + "\n", + "One of the most popular applications of VAEs is image generation. VAEs can be used to generate new images that are similar to the training data. Let's see how we can use a trained VAE to generate new images." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "import torch\n", + "from torch import nn, optim\n", + "from torchvision import datasets, transforms\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Encoder\n", + "\n", + "The encoder network takes the input data and outputs the parameters of the latent distribution (mean and log variance)." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, latent_dim):\n", + " super(Encoder, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", + " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", + " self.relu = nn.ReLU()\n", + " \n", + " def forward(self, x):\n", + " h = self.relu(self.fc1(x))\n", + " mean = self.fc2_mean(h)\n", + " log_var = self.fc2_log_var(h)\n", + " return mean, log_var" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Decoder\n", + "\n", + "The decoder network takes samples from the latent distribution and generates new data points." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dim, hidden_dim, output_dim):\n", + " super(Decoder, self).__init__()\n", + " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", + " self.relu = nn.ReLU()\n", + " self.sigmoid = nn.Sigmoid()\n", + " \n", + " def forward(self, z):\n", + " h = self.relu(self.fc1(z))\n", + " x_reconstructed = self.sigmoid(self.fc2(h))\n", + " return x_reconstructed" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the VAE\n", + "\n", + "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "class VAE(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(VAE, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + " \n", + " def forward(self, x):\n", + " mean, log_var = self.encoder(x)\n", + " std = torch.exp(0.5 * log_var)\n", + " epsilon = torch.randn_like(std)\n", + " z = mean + std * epsilon\n", + " x_reconstructed = self.decoder(z)\n", + " return x_reconstructed, mean, log_var" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Define the Loss Function\n", + "\n", + "The loss function consists of the reconstruction loss and the KL divergence." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "def vae_loss(x, x_reconstructed, mean, log_var):\n", + " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", + " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", + " return reconstruction_loss + kl_divergence" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Train the VAE\n", + "\n", + "Let's train the VAE on a simple dataset, such as the MNIST dataset." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Load the MNIST dataset\n", + "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", + "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", + "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", + "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Define the VAE model\n", + "input_dim = 28 * 28\n", + "hidden_dim = 256\n", + "latent_dim = 2\n", + "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", + "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", + "vae = VAE(encoder, decoder)\n", + "\n", + "# Define the optimizer\n", + "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", + "\n", + "# Train the model\n", + "num_epochs = 10\n", + "for epoch in range(num_epochs):\n", + " vae.train()\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " optimizer.zero_grad()\n", + " x_reconstructed, mean, log_var = vae(x)\n", + " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", + " loss.backward()\n", + " train_loss += loss.item()\n", + " optimizer.step()\n", + " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Generate New Images\n", + "\n", + "Now that we have trained the VAE, we can use it to generate new images." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Generate new data points\n", + "z_new = torch.randn(10, latent_dim)\n", + "with torch.no_grad():\n", + " generated = vae.decoder(z_new)\n", + "\n", + "# Plot the generated data points\n", + "plt.figure(figsize=(10, 2))\n", + "for i in range(10):\n", + " plt.subplot(1, 10, i + 1)\n", + " plt.imshow(generated[i].view(28, 28).numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "plt.show()" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Anomaly Detection\n", + "\n", + "VAEs can also be used for anomaly detection. By training a VAE on normal data, we can use the reconstruction error to detect anomalies. Data points with high reconstruction error are likely to be anomalies." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Calculate reconstruction error for test data\n", + "vae.eval()\n", + "x_test = next(iter(test_loader))[0] # Get the test data from DataLoader\n", + "with torch.no_grad():\n", + " reconstructed, _, _ = vae(x_test)\n", + " reconstruction_error = torch.mean((x_test - reconstructed) ** 2, axis=1)\n", + "\n", + "# Plot reconstruction error\n", + "plt.figure(figsize=(8, 6))\n", + "plt.hist(reconstruction_error.numpy(), bins=50)\n", + "plt.xlabel('Reconstruction Error')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Reconstruction Error Histogram')\n", + "plt.show()" + ], + "outputs": [], + "execution_count": null + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Data Compression\n", + "\n", + "VAEs can be used for data compression by encoding the data into a lower-dimensional latent space. The latent representation can then be used to reconstruct the original data." + ] + }, + { + "cell_type": "code", + "metadata": {}, + "source": [ + "# Encode the test data to the latent space\n", + "vae.eval()\n", + "with torch.no_grad():\n", + " mean, log_var = vae.encoder(x_test)\n", + " std = torch.exp(0.5 * log_var)\n", + " z = mean + std * torch.randn_like(std)\n", + "\n", + "# Decode the latent representation to reconstruct the data\n", + "with torch.no_grad():\n", + " reconstructed = vae.decoder(z)\n", + "\n", + "# Plot original and reconstructed data\n", + "plt.figure(figsize=(10, 4))\n", + "for i in range(10):\n", + " # Original data\n", + " plt.subplot(2, 10, i + 1)\n", + " plt.imshow(x_test[i].reshape(28, 28), cmap='gray')\n", + " plt.axis('off')\n", + " \n", + " # Reconstructed data\n", + " plt.subplot(2, 10, i + 11)\n", + " plt.imshow(reconstructed[i].view(28, 28).numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "plt.show()" + ], + "outputs": [], + "execution_count": null + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "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.8.5" + } }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Image Generation\n", - "\n", - "One of the most popular applications of VAEs is image generation. VAEs can be used to generate new images that are similar to the training data. Let's see how we can use a trained VAE to generate new images." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "import torch\n", - "from torch import nn, optim\n", - "from torchvision import datasets, transforms\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Encoder\n", - "\n", - "The encoder network takes the input data and outputs the parameters of the latent distribution (mean and log variance)." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class Encoder(nn.Module):\n", - " def __init__(self, input_dim, hidden_dim, latent_dim):\n", - " super(Encoder, self).__init__()\n", - " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", - " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", - " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", - " self.relu = nn.ReLU()\n", - " \n", - " def forward(self, x):\n", - " h = self.relu(self.fc1(x))\n", - " mean = self.fc2_mean(h)\n", - " log_var = self.fc2_log_var(h)\n", - " return mean, log_var" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Decoder\n", - "\n", - "The decoder network takes samples from the latent distribution and generates new data points." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class Decoder(nn.Module):\n", - " def __init__(self, latent_dim, hidden_dim, output_dim):\n", - " super(Decoder, self).__init__()\n", - " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", - " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", - " self.relu = nn.ReLU()\n", - " self.sigmoid = nn.Sigmoid()\n", - " \n", - " def forward(self, z):\n", - " h = self.relu(self.fc1(z))\n", - " x_reconstructed = self.sigmoid(self.fc2(h))\n", - " return x_reconstructed" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the VAE\n", - "\n", - "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class VAE(nn.Module):\n", - " def __init__(self, encoder, decoder):\n", - " super(VAE, self).__init__()\n", - " self.encoder = encoder\n", - " self.decoder = decoder\n", - " \n", - " def forward(self, x):\n", - " mean, log_var = self.encoder(x)\n", - " std = torch.exp(0.5 * log_var)\n", - " epsilon = torch.randn_like(std)\n", - " z = mean + std * epsilon\n", - " x_reconstructed = self.decoder(z)\n", - " return x_reconstructed, mean, log_var" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Loss Function\n", - "\n", - "The loss function consists of the reconstruction loss and the KL divergence." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "def vae_loss(x, x_reconstructed, mean, log_var):\n", - " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", - " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", - " return reconstruction_loss + kl_divergence" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Train the VAE\n", - "\n", - "Let's train the VAE on a simple dataset, such as the MNIST dataset." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Load the MNIST dataset\n", - "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", - "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", - "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", - "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", - "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", - "\n", - "# Define the VAE model\n", - "input_dim = 28 * 28\n", - "hidden_dim = 256\n", - "latent_dim = 2\n", - "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", - "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", - "vae = VAE(encoder, decoder)\n", - "\n", - "# Define the optimizer\n", - "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", - "\n", - "# Train the model\n", - "num_epochs = 10\n", - "for epoch in range(num_epochs):\n", - " vae.train()\n", - " train_loss = 0\n", - " for x, _ in train_loader:\n", - " optimizer.zero_grad()\n", - " x_reconstructed, mean, log_var = vae(x)\n", - " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", - " loss.backward()\n", - " train_loss += loss.item()\n", - " optimizer.step()\n", - " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generate New Images\n", - "\n", - "Now that we have trained the VAE, we can use it to generate new images." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Generate new data points\n", - "z_new = torch.randn(10, latent_dim)\n", - "with torch.no_grad():\n", - " generated = vae.decoder(z_new)\n", - "\n", - "# Plot the generated data points\n", - "plt.figure(figsize=(10, 2))\n", - "for i in range(10):\n", - " plt.subplot(1, 10, i + 1)\n", - " plt.imshow(generated[i].view(28, 28).numpy(), cmap='gray')\n", - " plt.axis('off')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Anomaly Detection\n", - "\n", - "VAEs can also be used for anomaly detection. By training a VAE on normal data, we can use the reconstruction error to detect anomalies. Data points with high reconstruction error are likely to be anomalies." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Calculate reconstruction error for test data\n", - "vae.eval()\n", - "with torch.no_grad():\n", - " reconstructed, _, _ = vae(torch.tensor(x_test, dtype=torch.float32))\n", - " reconstruction_error = torch.mean((torch.tensor(x_test, dtype=torch.float32) - reconstructed) ** 2, axis=1)\n", - "\n", - "# Plot reconstruction error\n", - "plt.figure(figsize=(8, 6))\n", - "plt.hist(reconstruction_error.numpy(), bins=50)\n", - "plt.xlabel('Reconstruction Error')\n", - "plt.ylabel('Frequency')\n", - "plt.title('Reconstruction Error Histogram')\n", - "plt.show()" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Data Compression\n", - "\n", - "VAEs can be used for data compression by encoding the data into a lower-dimensional latent space. The latent representation can then be used to reconstruct the original data." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Encode the test data to the latent space\n", - "vae.eval()\n", - "with torch.no_grad():\n", - " mean, log_var = vae.encoder(torch.tensor(x_test, dtype=torch.float32))\n", - " std = torch.exp(0.5 * log_var)\n", - " z = mean + std * torch.randn_like(std)\n", - "\n", - "# Decode the latent representation to reconstruct the data\n", - "with torch.no_grad():\n", - " reconstructed = vae.decoder(z)\n", - "\n", - "# Plot original and reconstructed data\n", - "plt.figure(figsize=(10, 4))\n", - "for i in range(10):\n", - " # Original data\n", - " plt.subplot(2, 10, i + 1)\n", - " plt.imshow(x_test[i].reshape(28, 28), cmap='gray')\n", - " plt.axis('off')\n", - " \n", - " # Reconstructed data\n", - " plt.subplot(2, 10, i + 11)\n", - " plt.imshow(reconstructed[i].view(28, 28).numpy(), cmap='gray')\n", - " plt.axis('off')\n", - "plt.show()" - ] - } - ] -} + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file From 2c446debdc3a63e5498817de86424ea0061d3577 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Mon, 12 Aug 2024 10:52:46 +0200 Subject: [PATCH 3/4] removed VAE training example as it was a duplicate of contents in other notebooks --- .../03_vae_training.ipynb | 271 ------------------ docs/_toc.yml | 1 - 2 files changed, 272 deletions(-) delete mode 100644 docs/90_variational_auto_encoders/03_vae_training.ipynb diff --git a/docs/90_variational_auto_encoders/03_vae_training.ipynb b/docs/90_variational_auto_encoders/03_vae_training.ipynb deleted file mode 100644 index 76c7ad1e..00000000 --- a/docs/90_variational_auto_encoders/03_vae_training.ipynb +++ /dev/null @@ -1,271 +0,0 @@ -{ - "cells": [ - { - "cell_type": "markdown", - "id": "directed-compensation", - "metadata": {}, - "source": [ - "
This notebook may contain text, code and images generated by artificial intelligence. Used model: gpt-4o-2024-08-06, vision model: gpt-4o-2024-08-06, endpoint: None, bia-bob version: 0.21.1.. It is good scientific practice to check the code and results it produces carefully. Read more about code generation using bia-bob
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Training Variational Auto-Encoders (VAEs)\n", - "\n", - "In this notebook, we will focus on training Variational Auto-Encoders (VAEs). We will provide code examples for training VAEs and explain the loss functions and optimization techniques used in the training process." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Code Example\n", - "\n", - "Let's start with a simple implementation of a VAE using PyTorch." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "import torch.optim as optim\n", - "from torchvision import datasets, transforms\n", - "import matplotlib.pyplot as plt" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Encoder\n", - "\n", - "The encoder network takes the input data and outputs the parameters of the latent distribution (mean and log variance)." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class Encoder(nn.Module):\n", - " def __init__(self, input_dim, hidden_dim, latent_dim):\n", - " super(Encoder, self).__init__()\n", - " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", - " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", - " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", - " self.relu = nn.ReLU()\n", - " \n", - " def forward(self, x):\n", - " h = self.relu(self.fc1(x))\n", - " mean = self.fc2_mean(h)\n", - " log_var = self.fc2_log_var(h)\n", - " return mean, log_var" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Decoder\n", - "\n", - "The decoder network takes samples from the latent distribution and generates new data points." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class Decoder(nn.Module):\n", - " def __init__(self, latent_dim, hidden_dim, output_dim):\n", - " super(Decoder, self).__init__()\n", - " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", - " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", - " self.relu = nn.ReLU()\n", - " self.sigmoid = nn.Sigmoid()\n", - " \n", - " def forward(self, z):\n", - " h = self.relu(self.fc1(z))\n", - " x_reconstructed = self.sigmoid(self.fc2(h))\n", - " return x_reconstructed" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the VAE\n", - "\n", - "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class VAE(nn.Module):\n", - " def __init__(self, encoder, decoder):\n", - " super(VAE, self).__init__()\n", - " self.encoder = encoder\n", - " self.decoder = decoder\n", - " \n", - " def forward(self, x):\n", - " mean, log_var = self.encoder(x)\n", - " std = torch.exp(0.5 * log_var)\n", - " epsilon = torch.randn_like(std)\n", - " z = mean + std * epsilon\n", - " x_reconstructed = self.decoder(z)\n", - " return x_reconstructed, mean, log_var" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Loss Function\n", - "\n", - "The loss function consists of the reconstruction loss and the KL divergence." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "def vae_loss(x, x_reconstructed, mean, log_var):\n", - " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", - " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", - " return reconstruction_loss + kl_divergence" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Train the VAE\n", - "\n", - "Let's train the VAE on a simple dataset, such as the MNIST dataset." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Load the MNIST dataset\n", - "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", - "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", - "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", - "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", - "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", - "\n", - "# Define the VAE model\n", - "input_dim = 28 * 28\n", - "hidden_dim = 256\n", - "latent_dim = 2\n", - "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", - "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", - "vae = VAE(encoder, decoder)\n", - "\n", - "# Define the optimizer\n", - "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", - "\n", - "# Train the model\n", - "num_epochs = 10\n", - "for epoch in range(num_epochs):\n", - " vae.train()\n", - " train_loss = 0\n", - " for x, _ in train_loader:\n", - " optimizer.zero_grad()\n", - " x_reconstructed, mean, log_var = vae(x)\n", - " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", - " loss.backward()\n", - " train_loss += loss.item()\n", - " optimizer.step()\n", - " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Visualize the Results\n", - "\n", - "Let's visualize the latent space learned by the VAE and generate some new data points." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Encode the test data to the latent space\n", - "vae.eval()\n", - "with torch.no_grad():\n", - " z_mean, z_log_var = [], []\n", - " for x, _ in test_loader:\n", - " mean, log_var = vae.encoder(x)\n", - " z_mean.append(mean)\n", - " z_log_var.append(log_var)\n", - " z_mean = torch.cat(z_mean)\n", - " z_log_var = torch.cat(z_log_var)\n", - " z = z_mean + torch.exp(0.5 * z_log_var) * torch.randn_like(z_mean)\n", - "\n", - "# Plot the latent space\n", - "plt.figure(figsize=(8, 6))\n", - "plt.scatter(z[:, 0].numpy(), z[:, 1].numpy(), c='blue', alpha=0.5)\n", - "plt.xlabel('z1')\n", - "plt.ylabel('z2')\n", - "plt.title('Latent Space')\n", - "plt.show()\n", - "\n", - "# Generate new data points\n", - "z_new = torch.randn(10, latent_dim)\n", - "with torch.no_grad():\n", - " generated = vae.decoder(z_new)\n", - "\n", - "# Plot the generated data points\n", - "plt.figure(figsize=(10, 2))\n", - "for i in range(10):\n", - " plt.subplot(1, 10, i + 1)\n", - " plt.imshow(generated[i].view(28, 28).numpy(), cmap='gray')\n", - " plt.axis('off')\n", - "plt.show()" - ], - "outputs": [], - "execution_count": null - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.x" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file diff --git a/docs/_toc.yml b/docs/_toc.yml index 04061f49..fb9eb8ce 100644 --- a/docs/_toc.yml +++ b/docs/_toc.yml @@ -123,7 +123,6 @@ parts: chapters: - file: 90_variational_auto_encoders/01_intro_to_vae.ipynb - file: 90_variational_auto_encoders/02_vae_architecture.ipynb - - file: 90_variational_auto_encoders/03_vae_training.ipynb - file: 90_variational_auto_encoders/04_vae_applications.ipynb From 8bce9a1a7288e5232c9c497553018bbd23d18da7 Mon Sep 17 00:00:00 2001 From: Robert Haase Date: Mon, 12 Aug 2024 10:57:07 +0200 Subject: [PATCH 4/4] run notebooks --- .gitignore | 3 +- .../01_intro_to_vae.ipynb | 154 +++- .../02_vae_architecture.ipynb | 397 +++++----- .../04_vae_applications.ipynb | 695 ++++++++++-------- 4 files changed, 734 insertions(+), 515 deletions(-) diff --git a/.gitignore b/.gitignore index 16ec5a31..9b76f9b2 100644 --- a/.gitignore +++ b/.gitignore @@ -21,4 +21,5 @@ docs/29_algorithm_validation/ideas.ipynb docs/29_algorithm_validation/solution for exercise - metrics to investigate segmentation results.ipynb docs/22_feature_extraction/blobs_analysis.csv data/S-BIAD634 -docs/71_fine_tuning_hf/haesleinhuepf \ No newline at end of file +docs/71_fine_tuning_hf/haesleinhuepf +docs/90_variational_auto_encoders/data \ No newline at end of file diff --git a/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb b/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb index e6fcfa4c..d75a8be7 100644 --- a/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb +++ b/docs/90_variational_auto_encoders/01_intro_to_vae.ipynb @@ -1,12 +1,5 @@ { "cells": [ - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "
This notebook may contain text, code and images generated by artificial intelligence. Used model: claude-3-5-sonnet-20240620, vision model: claude-3-5-sonnet-20240620, endpoint: None, bia-bob version: 0.21.1.. It is good scientific practice to check the code and results it produces carefully. Read more about code generation using bia-bob
" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -51,7 +44,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 1, "metadata": {}, "outputs": [], "source": [ @@ -73,7 +66,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 2, "metadata": {}, "outputs": [], "source": [ @@ -103,7 +96,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 3, "metadata": {}, "outputs": [], "source": [ @@ -132,7 +125,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 4, "metadata": {}, "outputs": [], "source": [ @@ -162,7 +155,7 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 5, "metadata": {}, "outputs": [], "source": [ @@ -183,9 +176,110 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 6, "metadata": {}, - "outputs": [], + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 403: Forbidden\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-images-idx3-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/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:01<00:00, 7150299.78it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting ./data\\MNIST\\raw\\train-images-idx3-ubyte.gz to ./data\\MNIST\\raw\n", + "\n", + "Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz\n", + "Failed to download (trying next):\n", + "HTTP Error 403: Forbidden\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/train-labels-idx1-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/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, 260992.37it/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", + "Failed to download (trying next):\n", + "HTTP Error 403: Forbidden\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-images-idx3-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/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, 2029789.12it/s]\n" + ] + }, + { + "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", + "Failed to download (trying next):\n", + "HTTP Error 403: Forbidden\n", + "\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/mnist/t10k-labels-idx1-ubyte.gz\n", + "Downloading https://ossci-datasets.s3.amazonaws.com/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, 2265492.78it/s]\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Extracting ./data\\MNIST\\raw\\t10k-labels-idx1-ubyte.gz to ./data\\MNIST\\raw\n", + "\n", + "Epoch 1, Loss: 182.6514552001953\n", + "Epoch 2, Loss: 165.24368096516926\n", + "Epoch 3, Loss: 161.51080247395834\n", + "Epoch 4, Loss: 159.12194900716145\n", + "Epoch 5, Loss: 157.41532638346354\n", + "Epoch 6, Loss: 156.18680362141927\n", + "Epoch 7, Loss: 155.20852910970052\n", + "Epoch 8, Loss: 154.32584979654948\n", + "Epoch 9, Loss: 153.60243400065104\n", + "Epoch 10, Loss: 152.96523545735678\n" + ] + } + ], "source": [ "# Load the MNIST dataset\n", "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", @@ -231,9 +325,30 @@ }, { "cell_type": "code", - "execution_count": null, + "execution_count": 7, "metadata": {}, - "outputs": [], + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], "source": [ "# Encode the test data to the latent space\n", "vae.eval()\n", @@ -268,6 +383,13 @@ " plt.axis('off')\n", "plt.show()" ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] } ], "metadata": { diff --git a/docs/90_variational_auto_encoders/02_vae_architecture.ipynb b/docs/90_variational_auto_encoders/02_vae_architecture.ipynb index d611d683..b21c0c53 100644 --- a/docs/90_variational_auto_encoders/02_vae_architecture.ipynb +++ b/docs/90_variational_auto_encoders/02_vae_architecture.ipynb @@ -1,188 +1,215 @@ { - "cells": [ + "cells": [ + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# VAE Architecture\n", + "\n", + "In this notebook, we will delve into the architecture of Variational Auto-Encoders (VAEs). We will explain the components of a VAE, including the encoder and decoder, and provide code examples for building a VAE architecture using PyTorch." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Encoder\n", + "\n", + "The encoder is a neural network that takes the input data and maps it to a latent space. The output of the encoder is the parameters of a probability distribution in the latent space, typically the mean and log variance." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "import torch.nn as nn\n", + "\n", + "class Encoder(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, latent_dim):\n", + " super(Encoder, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", + " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", + " self.relu = nn.ReLU()\n", + " \n", + " def forward(self, x):\n", + " h = self.relu(self.fc1(x))\n", + " mean = self.fc2_mean(h)\n", + " log_var = self.fc2_log_var(h)\n", + " return mean, log_var" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Decoder\n", + "\n", + "The decoder is a neural network that takes samples from the latent distribution and maps them back to the original data space. The output of the decoder is the reconstructed data." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dim, hidden_dim, output_dim):\n", + " super(Decoder, self).__init__()\n", + " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", + " self.relu = nn.ReLU()\n", + " self.sigmoid = nn.Sigmoid()\n", + " \n", + " def forward(self, z):\n", + " h = self.relu(self.fc1(z))\n", + " x_reconstructed = self.sigmoid(self.fc2(h))\n", + " return x_reconstructed" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## VAE Model\n", + "\n", + "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "class VAE(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(VAE, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + " \n", + " def forward(self, x):\n", + " mean, log_var = self.encoder(x)\n", + " std = torch.exp(0.5 * log_var)\n", + " epsilon = torch.randn_like(std)\n", + " z = mean + std * epsilon\n", + " x_reconstructed = self.decoder(z)\n", + " return x_reconstructed, mean, log_var" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Loss Function\n", + "\n", + "The loss function for a VAE consists of two terms: the reconstruction loss and the KL divergence. The reconstruction loss measures how well the decoder can reconstruct the input data from the latent space, while the KL divergence measures how close the learned distribution is to a prior distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "def vae_loss(x, x_reconstructed, mean, log_var):\n", + " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", + " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", + " return reconstruction_loss + kl_divergence" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## Training the VAE\n", + "\n", + "Let's train the VAE on a simple dataset, such as the MNIST dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "id": "directed-compensation", - "metadata": {}, - "source": [ - "
This notebook may contain text, code and images generated by artificial intelligence. Used model: gpt-4o-2024-08-06, vision model: gpt-4o-2024-08-06, endpoint: None, bia-bob version: 0.21.1.. It is good scientific practice to check the code and results it produces carefully. Read more about code generation using bia-bob
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# VAE Architecture\n", - "\n", - "In this notebook, we will delve into the architecture of Variational Auto-Encoders (VAEs). We will explain the components of a VAE, including the encoder and decoder, and provide code examples for building a VAE architecture using PyTorch." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Encoder\n", - "\n", - "The encoder is a neural network that takes the input data and maps it to a latent space. The output of the encoder is the parameters of a probability distribution in the latent space, typically the mean and log variance." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "import torch\n", - "import torch.nn as nn\n", - "\n", - "class Encoder(nn.Module):\n", - " def __init__(self, input_dim, hidden_dim, latent_dim):\n", - " super(Encoder, self).__init__()\n", - " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", - " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", - " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", - " self.relu = nn.ReLU()\n", - " \n", - " def forward(self, x):\n", - " h = self.relu(self.fc1(x))\n", - " mean = self.fc2_mean(h)\n", - " log_var = self.fc2_log_var(h)\n", - " return mean, log_var" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Decoder\n", - "\n", - "The decoder is a neural network that takes samples from the latent distribution and maps them back to the original data space. The output of the decoder is the reconstructed data." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class Decoder(nn.Module):\n", - " def __init__(self, latent_dim, hidden_dim, output_dim):\n", - " super(Decoder, self).__init__()\n", - " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", - " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", - " self.relu = nn.ReLU()\n", - " self.sigmoid = nn.Sigmoid()\n", - " \n", - " def forward(self, z):\n", - " h = self.relu(self.fc1(z))\n", - " x_reconstructed = self.sigmoid(self.fc2(h))\n", - " return x_reconstructed" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## VAE Model\n", - "\n", - "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class VAE(nn.Module):\n", - " def __init__(self, encoder, decoder):\n", - " super(VAE, self).__init__()\n", - " self.encoder = encoder\n", - " self.decoder = decoder\n", - " \n", - " def forward(self, x):\n", - " mean, log_var = self.encoder(x)\n", - " std = torch.exp(0.5 * log_var)\n", - " epsilon = torch.randn_like(std)\n", - " z = mean + std * epsilon\n", - " x_reconstructed = self.decoder(z)\n", - " return x_reconstructed, mean, log_var" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Loss Function\n", - "\n", - "The loss function for a VAE consists of two terms: the reconstruction loss and the KL divergence. The reconstruction loss measures how well the decoder can reconstruct the input data from the latent space, while the KL divergence measures how close the learned distribution is to a prior distribution." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "def vae_loss(x, x_reconstructed, mean, log_var):\n", - " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", - " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", - " return reconstruction_loss + kl_divergence" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Training the VAE\n", - "\n", - "Let's train the VAE on a simple dataset, such as the MNIST dataset." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "from torchvision import datasets, transforms\n", - "import torch.optim as optim\n", - "\n", - "# Load the MNIST dataset\n", - "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", - "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", - "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", - "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", - "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", - "\n", - "# Define the VAE model\n", - "input_dim = 28 * 28\n", - "hidden_dim = 256\n", - "latent_dim = 2\n", - "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", - "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", - "vae = VAE(encoder, decoder)\n", - "\n", - "# Define the optimizer\n", - "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", - "\n", - "# Train the model\n", - "num_epochs = 10\n", - "for epoch in range(num_epochs):\n", - " vae.train()\n", - " train_loss = 0\n", - " for x, _ in train_loader:\n", - " optimizer.zero_grad()\n", - " x_reconstructed, mean, log_var = vae(x)\n", - " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", - " loss.backward()\n", - " train_loss += loss.item()\n", - " optimizer.step()\n", - " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" - ], - "outputs": [], - "execution_count": null + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Loss: 182.64177789713543\n", + "Epoch 2, Loss: 164.48488276367186\n", + "Epoch 3, Loss: 161.2271118815104\n", + "Epoch 4, Loss: 159.09910853678386\n", + "Epoch 5, Loss: 157.53306800944011\n", + "Epoch 6, Loss: 156.28730290527344\n", + "Epoch 7, Loss: 155.26126284179688\n", + "Epoch 8, Loss: 154.44241954752604\n", + "Epoch 9, Loss: 153.73177485351562\n", + "Epoch 10, Loss: 153.18850033365885\n" + ] } - ], - "metadata": {}, - "nbformat": 4, - "nbformat_minor": 2 -} \ No newline at end of file + ], + "source": [ + "from torchvision import datasets, transforms\n", + "import torch.optim as optim\n", + "\n", + "# Load the MNIST dataset\n", + "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", + "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", + "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", + "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Define the VAE model\n", + "input_dim = 28 * 28\n", + "hidden_dim = 256\n", + "latent_dim = 2\n", + "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", + "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", + "vae = VAE(encoder, decoder)\n", + "\n", + "# Define the optimizer\n", + "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", + "\n", + "# Train the model\n", + "num_epochs = 10\n", + "for epoch in range(num_epochs):\n", + " vae.train()\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " optimizer.zero_grad()\n", + " x_reconstructed, mean, log_var = vae(x)\n", + " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", + " loss.backward()\n", + " train_loss += loss.item()\n", + " optimizer.step()\n", + " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/docs/90_variational_auto_encoders/04_vae_applications.ipynb b/docs/90_variational_auto_encoders/04_vae_applications.ipynb index 6119b61c..e1b2ef14 100644 --- a/docs/90_variational_auto_encoders/04_vae_applications.ipynb +++ b/docs/90_variational_auto_encoders/04_vae_applications.ipynb @@ -1,323 +1,392 @@ { - "cells": [ - { - "cell_type": "markdown", - "id": "directed-compensation", - "metadata": {}, - "source": [ - "
This notebook may contain text, code and images generated by artificial intelligence. Used model: gpt-4o-2024-08-06, vision model: gpt-4o-2024-08-06, endpoint: None, bia-bob version: 0.21.1.. It is good scientific practice to check the code and results it produces carefully. Read more about code generation using bia-bob
" - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "# Applications of Variational Auto-Encoders (VAEs)\n", - "\n", - "In this notebook, we will explore some practical applications of Variational Auto-Encoders (VAEs). We will provide examples of using VAEs for image generation and other practical applications." - ] - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Image Generation\n", - "\n", - "One of the most popular applications of VAEs is image generation. VAEs can be used to generate new images that are similar to the training data. Let's see how we can use a trained VAE to generate new images." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "import torch\n", - "from torch import nn, optim\n", - "from torchvision import datasets, transforms\n", - "import matplotlib.pyplot as plt\n", - "import numpy as np" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Encoder\n", - "\n", - "The encoder network takes the input data and outputs the parameters of the latent distribution (mean and log variance)." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class Encoder(nn.Module):\n", - " def __init__(self, input_dim, hidden_dim, latent_dim):\n", - " super(Encoder, self).__init__()\n", - " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", - " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", - " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", - " self.relu = nn.ReLU()\n", - " \n", - " def forward(self, x):\n", - " h = self.relu(self.fc1(x))\n", - " mean = self.fc2_mean(h)\n", - " log_var = self.fc2_log_var(h)\n", - " return mean, log_var" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Decoder\n", - "\n", - "The decoder network takes samples from the latent distribution and generates new data points." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class Decoder(nn.Module):\n", - " def __init__(self, latent_dim, hidden_dim, output_dim):\n", - " super(Decoder, self).__init__()\n", - " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", - " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", - " self.relu = nn.ReLU()\n", - " self.sigmoid = nn.Sigmoid()\n", - " \n", - " def forward(self, z):\n", - " h = self.relu(self.fc1(z))\n", - " x_reconstructed = self.sigmoid(self.fc2(h))\n", - " return x_reconstructed" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the VAE\n", - "\n", - "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "class VAE(nn.Module):\n", - " def __init__(self, encoder, decoder):\n", - " super(VAE, self).__init__()\n", - " self.encoder = encoder\n", - " self.decoder = decoder\n", - " \n", - " def forward(self, x):\n", - " mean, log_var = self.encoder(x)\n", - " std = torch.exp(0.5 * log_var)\n", - " epsilon = torch.randn_like(std)\n", - " z = mean + std * epsilon\n", - " x_reconstructed = self.decoder(z)\n", - " return x_reconstructed, mean, log_var" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Define the Loss Function\n", - "\n", - "The loss function consists of the reconstruction loss and the KL divergence." - ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "def vae_loss(x, x_reconstructed, mean, log_var):\n", - " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", - " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", - " return reconstruction_loss + kl_divergence" - ], - "outputs": [], - "execution_count": null - }, - { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Train the VAE\n", - "\n", - "Let's train the VAE on a simple dataset, such as the MNIST dataset." - ] - }, + "cells": [ + { + "cell_type": "markdown", + "id": "directed-compensation", + "metadata": {}, + "source": [ + "
This notebook may contain text, code and images generated by artificial intelligence. Used model: gpt-4o-2024-08-06, vision model: gpt-4o-2024-08-06, endpoint: None, bia-bob version: 0.21.1.. It is good scientific practice to check the code and results it produces carefully. Read more about code generation using bia-bob
" + ] + }, + { + "cell_type": "markdown", + "id": "d63c57fe", + "metadata": {}, + "source": [ + "# Applications of Variational Auto-Encoders (VAEs)\n", + "\n", + "In this notebook, we will explore some practical applications of Variational Auto-Encoders (VAEs). We will provide examples of using VAEs for image generation and other practical applications." + ] + }, + { + "cell_type": "markdown", + "id": "7aa831f4", + "metadata": {}, + "source": [ + "## Image Generation\n", + "\n", + "One of the most popular applications of VAEs is image generation. VAEs can be used to generate new images that are similar to the training data. Let's see how we can use a trained VAE to generate new images." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "97d7eadd", + "metadata": {}, + "outputs": [], + "source": [ + "import torch\n", + "from torch import nn, optim\n", + "from torchvision import datasets, transforms\n", + "import matplotlib.pyplot as plt\n", + "import numpy as np" + ] + }, + { + "cell_type": "markdown", + "id": "0be44b86", + "metadata": {}, + "source": [ + "### Define the Encoder\n", + "\n", + "The encoder network takes the input data and outputs the parameters of the latent distribution (mean and log variance)." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "85f2b640", + "metadata": {}, + "outputs": [], + "source": [ + "class Encoder(nn.Module):\n", + " def __init__(self, input_dim, hidden_dim, latent_dim):\n", + " super(Encoder, self).__init__()\n", + " self.fc1 = nn.Linear(input_dim, hidden_dim)\n", + " self.fc2_mean = nn.Linear(hidden_dim, latent_dim)\n", + " self.fc2_log_var = nn.Linear(hidden_dim, latent_dim)\n", + " self.relu = nn.ReLU()\n", + " \n", + " def forward(self, x):\n", + " h = self.relu(self.fc1(x))\n", + " mean = self.fc2_mean(h)\n", + " log_var = self.fc2_log_var(h)\n", + " return mean, log_var" + ] + }, + { + "cell_type": "markdown", + "id": "572eb6c2", + "metadata": {}, + "source": [ + "### Define the Decoder\n", + "\n", + "The decoder network takes samples from the latent distribution and generates new data points." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "38b43173", + "metadata": {}, + "outputs": [], + "source": [ + "class Decoder(nn.Module):\n", + " def __init__(self, latent_dim, hidden_dim, output_dim):\n", + " super(Decoder, self).__init__()\n", + " self.fc1 = nn.Linear(latent_dim, hidden_dim)\n", + " self.fc2 = nn.Linear(hidden_dim, output_dim)\n", + " self.relu = nn.ReLU()\n", + " self.sigmoid = nn.Sigmoid()\n", + " \n", + " def forward(self, z):\n", + " h = self.relu(self.fc1(z))\n", + " x_reconstructed = self.sigmoid(self.fc2(h))\n", + " return x_reconstructed" + ] + }, + { + "cell_type": "markdown", + "id": "563c8846", + "metadata": {}, + "source": [ + "### Define the VAE\n", + "\n", + "The VAE model combines the encoder and decoder, and includes a sampling layer to sample from the latent distribution." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5f113558", + "metadata": {}, + "outputs": [], + "source": [ + "class VAE(nn.Module):\n", + " def __init__(self, encoder, decoder):\n", + " super(VAE, self).__init__()\n", + " self.encoder = encoder\n", + " self.decoder = decoder\n", + " \n", + " def forward(self, x):\n", + " mean, log_var = self.encoder(x)\n", + " std = torch.exp(0.5 * log_var)\n", + " epsilon = torch.randn_like(std)\n", + " z = mean + std * epsilon\n", + " x_reconstructed = self.decoder(z)\n", + " return x_reconstructed, mean, log_var" + ] + }, + { + "cell_type": "markdown", + "id": "6fad01da", + "metadata": {}, + "source": [ + "### Define the Loss Function\n", + "\n", + "The loss function consists of the reconstruction loss and the KL divergence." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "b35e02c9", + "metadata": {}, + "outputs": [], + "source": [ + "def vae_loss(x, x_reconstructed, mean, log_var):\n", + " reconstruction_loss = nn.functional.binary_cross_entropy(x_reconstructed, x, reduction='sum')\n", + " kl_divergence = -0.5 * torch.sum(1 + log_var - mean.pow(2) - log_var.exp())\n", + " return reconstruction_loss + kl_divergence" + ] + }, + { + "cell_type": "markdown", + "id": "45253ced", + "metadata": {}, + "source": [ + "### Train the VAE\n", + "\n", + "Let's train the VAE on a simple dataset, such as the MNIST dataset." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "20470855", + "metadata": {}, + "outputs": [ { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Load the MNIST dataset\n", - "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", - "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", - "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", - "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", - "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", - "\n", - "# Define the VAE model\n", - "input_dim = 28 * 28\n", - "hidden_dim = 256\n", - "latent_dim = 2\n", - "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", - "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", - "vae = VAE(encoder, decoder)\n", - "\n", - "# Define the optimizer\n", - "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", - "\n", - "# Train the model\n", - "num_epochs = 10\n", - "for epoch in range(num_epochs):\n", - " vae.train()\n", - " train_loss = 0\n", - " for x, _ in train_loader:\n", - " optimizer.zero_grad()\n", - " x_reconstructed, mean, log_var = vae(x)\n", - " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", - " loss.backward()\n", - " train_loss += loss.item()\n", - " optimizer.step()\n", - " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" - ], - "outputs": [], - "execution_count": null - }, + "name": "stdout", + "output_type": "stream", + "text": [ + "Epoch 1, Loss: 185.8339251871745\n", + "Epoch 2, Loss: 166.8651765625\n", + "Epoch 3, Loss: 163.44859486490884\n", + "Epoch 4, Loss: 161.4818348063151\n", + "Epoch 5, Loss: 159.99831422526043\n", + "Epoch 6, Loss: 158.78891735026042\n", + "Epoch 7, Loss: 157.77428404947918\n", + "Epoch 8, Loss: 156.8380381347656\n", + "Epoch 9, Loss: 156.01695650227865\n", + "Epoch 10, Loss: 155.277118351237\n" + ] + } + ], + "source": [ + "# Load the MNIST dataset\n", + "transform = transforms.Compose([transforms.ToTensor(), transforms.Lambda(lambda x: x.view(-1))])\n", + "train_dataset = datasets.MNIST(root='./data', train=True, transform=transform, download=True)\n", + "test_dataset = datasets.MNIST(root='./data', train=False, transform=transform, download=True)\n", + "train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=64, shuffle=True)\n", + "test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=64, shuffle=False)\n", + "\n", + "# Define the VAE model\n", + "input_dim = 28 * 28\n", + "hidden_dim = 256\n", + "latent_dim = 2\n", + "encoder = Encoder(input_dim, hidden_dim, latent_dim)\n", + "decoder = Decoder(latent_dim, hidden_dim, input_dim)\n", + "vae = VAE(encoder, decoder)\n", + "\n", + "# Define the optimizer\n", + "optimizer = optim.Adam(vae.parameters(), lr=1e-3)\n", + "\n", + "# Train the model\n", + "num_epochs = 10\n", + "for epoch in range(num_epochs):\n", + " vae.train()\n", + " train_loss = 0\n", + " for x, _ in train_loader:\n", + " optimizer.zero_grad()\n", + " x_reconstructed, mean, log_var = vae(x)\n", + " loss = vae_loss(x, x_reconstructed, mean, log_var)\n", + " loss.backward()\n", + " train_loss += loss.item()\n", + " optimizer.step()\n", + " print(f'Epoch {epoch + 1}, Loss: {train_loss / len(train_loader.dataset)}')" + ] + }, + { + "cell_type": "markdown", + "id": "7f330fe4", + "metadata": {}, + "source": [ + "### Generate New Images\n", + "\n", + "Now that we have trained the VAE, we can use it to generate new images." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "35155de6", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "### Generate New Images\n", - "\n", - "Now that we have trained the VAE, we can use it to generate new images." + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Generate new data points\n", - "z_new = torch.randn(10, latent_dim)\n", - "with torch.no_grad():\n", - " generated = vae.decoder(z_new)\n", - "\n", - "# Plot the generated data points\n", - "plt.figure(figsize=(10, 2))\n", - "for i in range(10):\n", - " plt.subplot(1, 10, i + 1)\n", - " plt.imshow(generated[i].view(28, 28).numpy(), cmap='gray')\n", - " plt.axis('off')\n", - "plt.show()" - ], - "outputs": [], - "execution_count": null - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Generate new data points\n", + "z_new = torch.randn(10, latent_dim)\n", + "with torch.no_grad():\n", + " generated = vae.decoder(z_new)\n", + "\n", + "# Plot the generated data points\n", + "plt.figure(figsize=(10, 2))\n", + "for i in range(10):\n", + " plt.subplot(1, 10, i + 1)\n", + " plt.imshow(generated[i].view(28, 28).numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "921feb3d", + "metadata": {}, + "source": [ + "## Anomaly Detection\n", + "\n", + "VAEs can also be used for anomaly detection. By training a VAE on normal data, we can use the reconstruction error to detect anomalies. Data points with high reconstruction error are likely to be anomalies." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "710d9a57", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Anomaly Detection\n", - "\n", - "VAEs can also be used for anomaly detection. By training a VAE on normal data, we can use the reconstruction error to detect anomalies. Data points with high reconstruction error are likely to be anomalies." + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Calculate reconstruction error for test data\n", - "vae.eval()\n", - "x_test = next(iter(test_loader))[0] # Get the test data from DataLoader\n", - "with torch.no_grad():\n", - " reconstructed, _, _ = vae(x_test)\n", - " reconstruction_error = torch.mean((x_test - reconstructed) ** 2, axis=1)\n", - "\n", - "# Plot reconstruction error\n", - "plt.figure(figsize=(8, 6))\n", - "plt.hist(reconstruction_error.numpy(), bins=50)\n", - "plt.xlabel('Reconstruction Error')\n", - "plt.ylabel('Frequency')\n", - "plt.title('Reconstruction Error Histogram')\n", - "plt.show()" - ], - "outputs": [], - "execution_count": null - }, + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "# Calculate reconstruction error for test data\n", + "vae.eval()\n", + "x_test = next(iter(test_loader))[0] # Get the test data from DataLoader\n", + "with torch.no_grad():\n", + " reconstructed, _, _ = vae(x_test)\n", + " reconstruction_error = torch.mean((x_test - reconstructed) ** 2, axis=1)\n", + "\n", + "# Plot reconstruction error\n", + "plt.figure(figsize=(8, 6))\n", + "plt.hist(reconstruction_error.numpy(), bins=50)\n", + "plt.xlabel('Reconstruction Error')\n", + "plt.ylabel('Frequency')\n", + "plt.title('Reconstruction Error Histogram')\n", + "plt.show()" + ] + }, + { + "cell_type": "markdown", + "id": "e4f34351", + "metadata": {}, + "source": [ + "## Data Compression\n", + "\n", + "VAEs can be used for data compression by encoding the data into a lower-dimensional latent space. The latent representation can then be used to reconstruct the original data." + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "3a983ee3", + "metadata": {}, + "outputs": [ { - "cell_type": "markdown", - "metadata": {}, - "source": [ - "## Data Compression\n", - "\n", - "VAEs can be used for data compression by encoding the data into a lower-dimensional latent space. The latent representation can then be used to reconstruct the original data." + "data": { + "image/png": "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", + "text/plain": [ + "
" ] - }, - { - "cell_type": "code", - "metadata": {}, - "source": [ - "# Encode the test data to the latent space\n", - "vae.eval()\n", - "with torch.no_grad():\n", - " mean, log_var = vae.encoder(x_test)\n", - " std = torch.exp(0.5 * log_var)\n", - " z = mean + std * torch.randn_like(std)\n", - "\n", - "# Decode the latent representation to reconstruct the data\n", - "with torch.no_grad():\n", - " reconstructed = vae.decoder(z)\n", - "\n", - "# Plot original and reconstructed data\n", - "plt.figure(figsize=(10, 4))\n", - "for i in range(10):\n", - " # Original data\n", - " plt.subplot(2, 10, i + 1)\n", - " plt.imshow(x_test[i].reshape(28, 28), cmap='gray')\n", - " plt.axis('off')\n", - " \n", - " # Reconstructed data\n", - " plt.subplot(2, 10, i + 11)\n", - " plt.imshow(reconstructed[i].view(28, 28).numpy(), cmap='gray')\n", - " plt.axis('off')\n", - "plt.show()" - ], - "outputs": [], - "execution_count": null - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3", - "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.8.5" + }, + "metadata": {}, + "output_type": "display_data" } + ], + "source": [ + "# Encode the test data to the latent space\n", + "vae.eval()\n", + "with torch.no_grad():\n", + " mean, log_var = vae.encoder(x_test)\n", + " std = torch.exp(0.5 * log_var)\n", + " z = mean + std * torch.randn_like(std)\n", + "\n", + "# Decode the latent representation to reconstruct the data\n", + "with torch.no_grad():\n", + " reconstructed = vae.decoder(z)\n", + "\n", + "# Plot original and reconstructed data\n", + "plt.figure(figsize=(10, 4))\n", + "for i in range(10):\n", + " # Original data\n", + " plt.subplot(2, 10, i + 1)\n", + " plt.imshow(x_test[i].reshape(28, 28), cmap='gray')\n", + " plt.axis('off')\n", + " \n", + " # Reconstructed data\n", + " plt.subplot(2, 10, i + 11)\n", + " plt.imshow(reconstructed[i].view(28, 28).numpy(), cmap='gray')\n", + " plt.axis('off')\n", + "plt.show()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "language": "python", + "name": "python3" }, - "nbformat": 4, - "nbformat_minor": 5 -} \ No newline at end of file + "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.9" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +}