03.ldm_nano.ipynb

{"cells":[{"cell_type":"markdown","metadata":{"id":"HHGqxfJQAhql"},"source":["# Latent Diffusion Model"]},{"cell_type":"markdown","metadata":{"id":"j5_XnpOliCap"},"source":["`02.vae_latent_2d.ipynb` 파일에서 학습 데이터를 잠재변수로 만들었습니다. [en] In the `02.vae_latent_2d.ipynb` file, the training data was transformed into latent variables.\n","\n","\n","<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/ldm-figure3.png\" width=700>\n","\n","\n","이제 위 그림을 구현할 모든 준비를 마쳤습니다. 앞서 만든 VAE로 그림 왼편 Pixel Space 부분을 처리하고 DDPM에서 만들어 본 노이즈 제거 모델을 사용해서 Latent Space 부분을 처리합니다. [en] Now, we have completed all the parts to implement the above figure. The VAE created earlier will handle the Pixel Space section on the left side of the figure, while the denoising model from the DDPM will handle the Latent Space section.\n","\n","단일 단어로 구성된 이미지의 레이블은 컨디션이 되어서 그림의 $\\tau_\\theta$에 의해 임베딩 벡터로 바뀌게 됩니다. DDPM을 구현할 때 이 임베딩 벡터는 CNN의 특징맵feature map에 단순히 더해졌지만 여기서는 멀티헤드어텐션을 사용하여 피처맵에 추가되는 방식으로 구현합니다. 물론 그럼처럼 잠재변수에 바로 concat으로 추가될 수도 있습니다. 두 방식 모두 구현하도록 하겠습니다. [en] The labels of images, consisting of single words, act as conditions and are converted into embedding vectors by $\\tau_\\theta$ in the figure. When implementing DDPM, these embedding vectors were simply added to the feature map of the CNN. However, we will implement this by incorporating the embedding vectors into the feature map using multi-head attention. Of course, as in the previous method, they can also be directly concatenated to the latent variables. We will implement both approaches."]},{"cell_type":"code","execution_count":1,"metadata":{"executionInfo":{"elapsed":17480,"status":"ok","timestamp":1736429819409,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"2GFlHODbZkVt"},"outputs":[],"source":["# import the necessary packages\n","import os, random, shutil\n","\n","import numpy as np\n","import matplotlib.pyplot as plt\n","import pandas as pd\n","from PIL import Image\n","\n","import torch\n","import torch.nn.functional as F\n","from torch.utils.data import Dataset, DataLoader\n","from torchvision import transforms\n","\n","from tqdm import tqdm\n","from matplotlib.animation import FuncAnimation, PillowWriter"]},{"cell_type":"code","execution_count":3,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":36},"executionInfo":{"elapsed":424,"status":"ok","timestamp":1736429927210,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"szOQb7slZkVu","outputId":"13b3713d-9290-4a57-b386-f4468bb941cd"},"outputs":[{"output_type":"execute_result","data":{"text/plain":["'cuda'"],"application/vnd.google.colaboratory.intrinsic+json":{"type":"string"}},"metadata":{},"execution_count":3}],"source":["device = 'cuda' if torch.cuda.is_available() else 'cpu'\n","device"]},{"cell_type":"markdown","metadata":{"id":"ndqtq09CZkVt"},"source":["## Prepare Dataset\n"]},{"cell_type":"code","execution_count":2,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":19804,"status":"ok","timestamp":1736429924892,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"ZCrXcpKVAsSe","outputId":"a080f94e-d530-486b-b7e2-22276479d600"},"outputs":[{"output_type":"stream","name":"stdout","text":["Downloading...\n","From: https://drive.google.com/uc?id=1gADYmo2UXlr24dUUNaqyPF2LZXk1HhrJ\n","To: /content/sprites_1788_16x16.npy\n","100% 68.7M/68.7M [00:03<00:00, 17.3MB/s]\n","Downloading...\n","From: https://drive.google.com/uc?id=1gAY7uXhe6jBRv0NMk7iXWKRln-nPjo4s\n","To: /content/sprite_labels_nc_1788_16x16.npy\n","100% 3.58M/3.58M [00:00<00:00, 216MB/s]\n"]}],"source":["!gdown 1gADYmo2UXlr24dUUNaqyPF2LZXk1HhrJ\n","!gdown 1gAY7uXhe6jBRv0NMk7iXWKRln-nPjo4s"]},{"cell_type":"code","execution_count":4,"metadata":{"id":"6ILRVNyrZkVu","executionInfo":{"status":"ok","timestamp":1736429931926,"user_tz":-540,"elapsed":1142,"user":{"displayName":"조준우","userId":"07581913480846489655"}}},"outputs":[],"source":["sprites = np.load('sprites_1788_16x16.npy')\n","sprite_labels = np.load('sprite_labels_nc_1788_16x16.npy').astype(np.float32)"]},{"cell_type":"code","execution_count":5,"metadata":{"id":"S_gRovdMZkVx","executionInfo":{"status":"ok","timestamp":1736429933133,"user_tz":-540,"elapsed":1,"user":{"displayName":"조준우","userId":"07581913480846489655"}}},"outputs":[],"source":["IMAGE_SIZE = 16\n","CHANNELS = 3\n","LATENT_EMB_DIM = 4\n","LATENT_HEIGHT = 8\n","LATENT_WIDTH = 8\n","CTX_LEN = 5\n","\n","LABEL_NAMES = np.array(['hero', 'non-hero', 'food', 'spell', 'side-facing'])"]},{"cell_type":"markdown","metadata":{"id":"jBHCQKcfZkVx"},"source":["## VAE Model\n","\n","앞서 만들어둔 VAE를 복원합니다. 모델을 정의한 소스를 그대로 복사하고 학습 후 백업한 파라미터 파일을 이용합니다."]},{"cell_type":"code","execution_count":6,"metadata":{"id":"-BT-z7T4ZkVx","executionInfo":{"status":"ok","timestamp":1736429934620,"user_tz":-540,"elapsed":472,"user":{"displayName":"조준우","userId":"07581913480846489655"}}},"outputs":[],"source":["# define a convolutional block for the encoder part of the vae\n","class ConvBlock(torch.nn.Module):\n","    def __init__(self, in_channels, out_channels, kernel_size=3, stride=2, padding=1):\n","        super().__init__()\n","\n","        # sequential block consisting of a 2d convolution,\n","        # batch normalization, and leaky relu activation\n","        self.block = torch.nn.Sequential(\n","            torch.nn.Conv2d(\n","                in_channels,  # number of input channels\n","                out_channels=out_channels,  # number of output channels\n","                kernel_size=kernel_size,  # size of the convolutional kernel\n","                stride=stride,  # stride of the convolution\n","                padding=padding,  # padding added to the input\n","            ),\n","            torch.nn.BatchNorm2d(out_channels),  # normalize the activations of the layer\n","            torch.nn.LeakyReLU(),  # apply leaky relu activation\n","        )\n","\n","    def forward(self, x):\n","        # pass the input through the sequential block\n","        return self.block(x)\n","\n","# define a transposed convolutional block for the decoder part of the vae\n","class ConvTBlock(torch.nn.Module):\n","    def __init__(self, in_channels, out_channels, kernel_size=3, stride=2, padding=1, output_padding=1):\n","        super().__init__()\n","\n","        # sequential block consisting of a transposed 2d convolution,\n","        # batch normalization, and leaky relu activation\n","        self.block = torch.nn.Sequential(\n","            torch.nn.ConvTranspose2d(\n","                in_channels,  # number of input channels\n","                out_channels,  # number of output channels\n","                kernel_size=kernel_size,  # size of the convolutional kernel\n","                stride=stride,  # stride of the convolution\n","                padding=padding,  # padding added to the input\n","                output_padding=output_padding,  # additional padding added to the output\n","            ),\n","            torch.nn.BatchNorm2d(out_channels),  # normalize the activations of the layer\n","            torch.nn.LeakyReLU(),  # apply leaky relu activation\n","        )\n","\n","    def forward(self, x):\n","        return self.block(x)  # pass the input through the sequential block\n","\n","# define the main vae class\n","class VAE(torch.nn.Module):\n","    \"\"\"\n","    image          encoder        latent       decoder         final layer\n","    (3, 16, 16) -> (128, 8, 8) -> (4, 8, 8) -> (128, 16, 16) -> (16, 16, 16) -> (3, 16, 16)\n","    \"\"\"\n","    def __init__(self, in_channels, latent_dim):\n","        super().__init__()\n","\n","        self.latent_dim = latent_dim  # dimensionality of the latent space\n","        hidden_dims = [128,]  # hidden dimensions\n","        # img size     8\n","\n","        self.encoder = torch.nn.Sequential(\n","            # (3,16,16) -> (128,8,8)\n","            ConvBlock(in_channels, hidden_dims[0]),\n","            # hidden_dims에 추가 레이어가 있으면 [en] If there are additional layers in hidden_dims\n","            # ConvBlock(hidden_dims[0], hidden_dims[1]),\n","            # ConvBlock(hidden_dims[1], hidden_dims[2]), ...\n","        )\n","\n","        # layer for the mean of the latent space\n","        self.conv_mu = torch.nn.Conv2d(hidden_dims[-1], latent_dim, kernel_size=3, stride=1, padding=1)\n","\n","        # layer for the variance of the latent space\n","        self.conv_var = torch.nn.Conv2d(hidden_dims[-1], latent_dim, kernel_size=3, stride=1, padding=1)\n","\n","\n","        self.decoder = torch.nn.Sequential(\n","            ConvTBlock(latent_dim, hidden_dims[-1]),\n","            # hidden_dims에 추가 레이어가 있으면 [en] If there are additional layers in hidden_dims\n","            # ConvTBlock(hidden_dims[-1], hidden_dims[-2]),\n","            # ConvTBlock(hidden_dims[-2], hidden_dims[-3]), ...\n","        )\n","\n","        # final layer to reconstruct the original input\n","        self.final_layer = torch.nn.Sequential(\n","            torch.nn.Conv2d(\n","                hidden_dims[0], hidden_dims[0],\n","                kernel_size=3, stride=1, padding=1\n","            ),\n","\n","            # normalize the activations of the layer\n","            torch.nn.BatchNorm2d(hidden_dims[0]),\n","\n","            # apply leaky relu activation\n","            torch.nn.LeakyReLU(),\n","\n","            # final convolution to match the output channels\n","            torch.nn.Conv2d(hidden_dims[0], out_channels=3, kernel_size=3, stride=1, padding=1),\n","        )\n","\n","    # encoding function to map the input to the latent space\n","    def encode(self, input):\n","        # pass the input through the encoder\n","        result = self.encoder(input) # (B,3,16,16)->(B,128,8,8)\n","\n","        # compute the mean of the latent space\n","        mu = self.conv_mu(result) # (B,128,8,8)->(B,4,8,8)\n","\n","        # compute the log variance of the latent space\n","        log_var = self.conv_var(result) # (B,128,8,8)->(B,4,8,8)\n","\n","        return [mu, log_var]\n","\n","        # decoding function to map the latent space to the reconstructed input\n","    def decode(self, z):\n","        # pass the result through the decoder\n","        result = self.decoder(z) # (B,4,8,8) -> (B,128,16,16)\n","\n","        # pass the result through the final layer\n","        result = self.final_layer(result) # (B,128,16,16)->(B,128,16,16)->(B,3,16,16)\n","        return result\n","\n","        # reparameterization trick to sample from the latent space\n","    def reparameterize(self, mu, logvar):\n","        # compute the standard deviation from the log variance\n","        std = torch.exp(0.5 * logvar)\n","        # sample random noise\n","        eps = torch.randn_like(std)\n","        # compute the sample from the latent space\n","        return eps * std + mu\n","\n","    # forward pass of the vae\n","    def forward(self, input):\n","        # encode the input to the latent space\n","        mu, log_var = self.encode(input) # (B, 3, 16, 16) -> [(B, 4, 8, 8), (B, 4, 8, 8)]\n","\n","        # sample from the latent space\n","        z = self.reparameterize(mu, log_var) # [(B, 4, 8, 8), (B, 4, 8, 8)] -> (B, 4, 8, 8)\n","\n","        # decode the sample, and return the reconstruction\n","        # along with the original input, mean, and log variance\n","        recon_input = self.decode(z) # (B, 4, 8, 8) -> (B, 3, 16, 16)\n","\n","        return [recon_input, input, mu, log_var]"]},{"cell_type":"code","source":["# download vae weights best_vae.pt\n","!gdown 1bGhqQB30EurDt9b_ZsKML51jk-Y55Fio"],"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"id":"T700kUjvSS5j","executionInfo":{"status":"ok","timestamp":1736429939110,"user_tz":-540,"elapsed":4492,"user":{"displayName":"조준우","userId":"07581913480846489655"}},"outputId":"4e02c65e-614c-453c-b903-4db0ce4e4360"},"execution_count":7,"outputs":[{"output_type":"stream","name":"stdout","text":["Downloading...\n","From: https://drive.google.com/uc?id=1bGhqQB30EurDt9b_ZsKML51jk-Y55Fio\n","To: /content/best_vae.pt\n","\r  0% 0.00/690k [00:00<?, ?B/s]\r100% 690k/690k [00:00<00:00, 106MB/s]\n"]}]},{"cell_type":"code","execution_count":8,"metadata":{"id":"uErA2FOfZkVx","executionInfo":{"status":"ok","timestamp":1736429966588,"user_tz":-540,"elapsed":1471,"user":{"displayName":"조준우","userId":"07581913480846489655"}}},"outputs":[],"source":["# create output directory\n","output_dir = \"assets\"\n","os.makedirs(output_dir, exist_ok=True)\n","\n","vae_weights_dir = os.path.join(output_dir, f\"vae_latent_2d_emb{LATENT_EMB_DIM}\")\n","os.makedirs(vae_weights_dir, exist_ok=True)\n","\n","VAE_BEST_WEIGHTS_PATH = os.path.join(vae_weights_dir, \"best_vae.pt\")\n"]},{"cell_type":"code","source":["# move best_vae.pt to VAE_BEST_WEIGHTS_PATH\n","import shutil\n","\n","if os.path.exists(\"./best_vae.pt\"):\n","    shutil.move(\"./best_vae.pt\", VAE_BEST_WEIGHTS_PATH)"],"metadata":{"id":"B5o4tOkxSn1h","executionInfo":{"status":"ok","timestamp":1736430067562,"user_tz":-540,"elapsed":410,"user":{"displayName":"조준우","userId":"07581913480846489655"}}},"execution_count":9,"outputs":[]},{"cell_type":"markdown","metadata":{"id":"X_rrmTp12ZaE"},"source":["이미지 파일을 모두 잠재 변수 $z$로 바꿀것이기 때문에 VAE모델에 이미지를 공급할 `Dataset`을 정의합니다."]},{"cell_type":"code","execution_count":10,"metadata":{"id":"y90-BpzRZkVy","executionInfo":{"status":"ok","timestamp":1736430074706,"user_tz":-540,"elapsed":548,"user":{"displayName":"조준우","userId":"07581913480846489655"}}},"outputs":[],"source":["class MyVaeDataset(Dataset):\n","    def __init__(self, data, sprite_labels, transform=None):\n","        self.data = data\n","        self.labels = sprite_labels\n","        self.transform = transform\n","\n","    def __len__(self):\n","        return self.data.shape[0]\n","\n","    def __getitem__(self, i):\n","        x_0 = self.data[i]\n","        label = self.labels[i]\n","\n","        if self.transform:\n","            x_0 = self.transform(x_0)\n","\n","        return x_0, label"]},{"cell_type":"code","execution_count":11,"metadata":{"id":"HDhO7cKpZkVy","executionInfo":{"status":"ok","timestamp":1736430074707,"user_tz":-540,"elapsed":3,"user":{"displayName":"조준우","userId":"07581913480846489655"}}},"outputs":[],"source":["# Define the transformations\n","valid_transforms = transforms.Compose(\n","    [\n","        transforms.ToTensor()\n","    ]\n",")\n","\n","def set_seed(seed_value=42):\n","    random.seed(seed_value)  # Python\n","    np.random.seed(seed_value)  # Numpy\n","    torch.manual_seed(seed_value)  # PyTorch\n","    torch.cuda.manual_seed_all(seed_value)  # Pytorch All GPU\n","\n","seed = 100\n","set_seed(seed)  # 시드 값을 설정합니다.\n","\n","VAE_BATCH_SIZE = 32\n","\n","train_ds = MyVaeDataset(sprites, sprite_labels, valid_transforms)\n","train_loader = DataLoader(train_ds, batch_size=VAE_BATCH_SIZE, shuffle=False)"]},{"cell_type":"markdown","metadata":{"id":"-kOmtwqO2ZaF"},"source":["Dataset이 잘 작동하는지 이미지를 그려 확인합니다."]},{"cell_type":"code","execution_count":12,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":430},"executionInfo":{"elapsed":4,"status":"ok","timestamp":1736430078559,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"Uv7thKwtZkVy","outputId":"225f6fa7-4b32-41c1-ae96-a2e0adc692ff"},"outputs":[{"output_type":"display_data","data":{"text/plain":["<Figure size 640x480 with 1 Axes>"],"image/png":"iVBORw0KGgoAAAANSUhEUgAAAaAAAAGdCAYAAABU0qcqAAAAOnRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjEwLjAsIGh0dHBzOi8vbWF0cGxvdGxpYi5vcmcvlHJYcgAAAAlwSFlzAAAPYQAAD2EBqD+naQAAHRtJREFUeJzt3X9wVPW9//HXkpAlcpPVRPNjJZHUoaKAiPKjiNPCkJGbwSjtqNVBzBfm+qMNQohfCmkbbFWI2NZGlAngHYXOCOofgsgdYWhEkCm/Y6xMW35cU4zQJOV+dRfCl5WbPfePe9nbSCA/PCfv3fB8zJw/dvfkc96zyfKcs1lOfI7jOAIAoJf1sx4AAHB5IkAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMBEsvUAXxeNRnXixAmlpaXJ5/NZjwMA6CbHcXTq1CkFg0H163fx85y4C9CJEyeUl5dnPQYA4BtqbGzUoEGDLvp43AUoLS1N0n8Pnp6ebjwN3DB76IOerf3rb8/zbO0t/7HLs7W9NCVzvGdr/9/Dv/Vs7Zf/ss6ztdG7wuGw8vLyYv+eX0zcBej8227p6ekEqI9I6dffs7XTkwd6tvYVSQM8W9tLXj4nnn4veb33OZ39GoUPIQAATBAgAIAJAgQAMEGAAAAmPAvQ8uXLNXjwYA0YMEDjxo3T3r17vToUACABeRKgN998U+Xl5XrqqadUV1enkSNHasqUKWppafHicACABORJgF544QU98sgjmjlzpm666SatWLFCV1xxhV599VUvDgcASECuB+irr77SgQMHVFhY+L8H6ddPhYWF2rXrwv/YF4lEFA6H220AgL7P9QCdPHlSbW1tys7Obnd/dna2mpqaLti/qqpKgUAgtnEZHgC4PJh/Cq6iokKhUCi2NTY2Wo8EAOgFrl+K5+qrr1ZSUpKam5vb3d/c3KycnJwL9vf7/fL7/W6PAQCIc66fAaWkpOi2225TbW1t7L5oNKra2lqNH+/dRRIBAInFk4uRlpeXq6SkRKNHj9bYsWNVXV2t1tZWzZw504vDAQASkCcB+uEPf6i///3vWrRokZqamnTLLbdo8+bNF3wwAQBw+fLszzHMnj1bs2fP9mp5AECCM/8UHADg8kSAAAAmCBAAwAQBAgCY8OxDCEgc/zJomqfrvzx0gWdr/9vJnZ6tnai8fE68/F56+XP4r59v8Gxt9BxnQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACaSrQdA1/zLoGmerV109QTP1pakfzu507O1Xz3+jmdro3d5+XPo5etHkv718w2ert9XcQYEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMuB6gqqoqjRkzRmlpacrKytK0adN06NAhtw8DAEhwrgdo+/btKi0t1e7du7V161adO3dOd955p1pbW90+FAAggbl+JYTNmze3u7169WplZWXpwIED+u53v+v24QAACcrzS/GEQiFJUkZGRoePRyIRRSKR2O1wOOz1SACAOODphxCi0ajKyso0YcIEDR8+vMN9qqqqFAgEYlteXp6XIwEA4oSnASotLdXBgwf1xhtvXHSfiooKhUKh2NbY2OjlSACAOOHZW3CzZ8/Wpk2btGPHDg0aNOii+/n9fvn9fq/GAADEKdcD5DiOnnjiCa1fv14ffPCBCgoK3D4EAKAPcD1ApaWlWrt2rd555x2lpaWpqalJkhQIBJSamur24QAACcr13wHV1NQoFApp4sSJys3NjW1vvvmm24cCACQwT96CAwCgM1wLDgBgggABAEwQIACACQIEADDh+bXggFePv2M9Qo/k+q+2HqFH/hY56dnaXn4vZ117j2drIz5xBgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGAi2XoAdM3Gc3/wbO2/HT/p2dpey/VfbT1C3PHyOflbxLuflVePv+PZ2vv6HfZsbfQcZ0AAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMCE5wF67rnn5PP5VFZW5vWhAAAJxNMA7du3TytXrtTNN9/s5WEAAAnIswCdPn1a06dP1yuvvKKrrrrKq8MAABKUZwEqLS3V1KlTVVhY6NUhAAAJzJNrwb3xxhuqq6vTvn37Ot03EokoEonEbofDYS9GAgDEGdfPgBobGzV37ly9/vrrGjBgQKf7V1VVKRAIxLa8vDy3RwIAxCGf4ziOmwtu2LBB3//+95WUlBS7r62tTT6fT/369VMkEmn3WEdnQHl5eQqFQkpPT3dztISWlZ3l2dpjot/2bG2vcTXs3uXl1bC95PXVsFuaWzxdP9GEw2EFAoFO/x13/S24yZMn65NPPml338yZMzV06FAtWLCgXXwkye/3y+/3uz0GACDOuR6gtLQ0DR8+vN19AwcOVGZm5gX3AwAuX1wJAQBgolf+IuoHH3zQG4cBACQQzoAAACYIEADABAECAJggQAAAEwQIAGCiVz4Fd7nw8moFXq59TF96trYkHaye49navsmPeba2U7vSs7W9lKjPyfCyZZ6tnSXvXj+St6/PvnyVBc6AAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATCRbD4C+78S/H7IeAS7hewk3cQYEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMeBKg48eP66GHHlJmZqZSU1M1YsQI7d+/34tDAQASlOv/EfWLL77QhAkTNGnSJL333nu65pprdOTIEV111VVuHwoAkMBcD9DSpUuVl5en1157LXZfQUGB24cBACQ419+C27hxo0aPHq377rtPWVlZGjVqlF555ZWL7h+JRBQOh9ttAIC+z/UAffrpp6qpqdGQIUO0ZcsW/ehHP9KcOXO0Zs2aDvevqqpSIBCIbXl5eW6PBACIQ64HKBqN6tZbb9WSJUs0atQoPfroo3rkkUe0YsWKDvevqKhQKBSKbY2NjW6PBACIQ64HKDc3VzfddFO7+2688UZ99tlnHe7v9/uVnp7ebgMA9H2uB2jChAk6dKj9JdsPHz6s6667zu1DAQASmOsBmjdvnnbv3q0lS5bo6NGjWrt2rVatWqXS0lK3DwUASGCuB2jMmDFav3691q1bp+HDh+uZZ55RdXW1pk+f7vahAAAJzJO/iHrXXXfprrvu8mJpAEAfwbXgAAAmCBAAwAQBAgCYIEAAABM+x3Ec6yH+UTgcViAQUCgU4j+l/oOs7KyEXFuSClK+8mztlY8Ve7Y2LvTYync9W7vhqxTP1m5pbvFs7d5YP9F09d9xzoAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMJFsPgK5paW7xbO3iQeM9W1uS/tk/wLO1H1v5rmdr40L//MW1nq29OXLWs7UPNh/0bG30HGdAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADAhOsBamtrU2VlpQoKCpSamqrrr79ezzzzjBzHcftQAIAE5vp/RF26dKlqamq0Zs0aDRs2TPv379fMmTMVCAQ0Z84ctw8HAEhQrgfoD3/4g+655x5NnTpVkjR48GCtW7dOe/fudftQAIAE5vpbcLfffrtqa2t1+PBhSdLHH3+snTt3qqioqMP9I5GIwuFwuw0A0Pe5fga0cOFChcNhDR06VElJSWpra9PixYs1ffr0DvevqqrSL3/5S7fHAADEOdfPgN566y29/vrrWrt2rerq6rRmzRr9+te/1po1azrcv6KiQqFQKLY1Nja6PRIAIA65fgY0f/58LVy4UA888IAkacSIETp27JiqqqpUUlJywf5+v19+v9/tMQAAcc71M6AzZ86oX7/2yyYlJSkajbp9KABAAnP9DKi4uFiLFy9Wfn6+hg0bpo8++kgvvPCCZs2a5fahAAAJzPUAvfTSS6qsrNSPf/xjtbS0KBgM6rHHHtOiRYvcPhQAIIG5HqC0tDRVV1erurra7aUBAH0I14IDAJggQAAAEwQIAGCCAAEATLj+IQR4o3jQeO/WDn7Hs7UlaUTkuHeLf+Hd0rjQrf90jWdr98+81rO1vXz9SNK7n+/ydP2+ijMgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAE8nWA/Qljw25y7O1fzH8Yc/W9tpXfzvu2dq3/tM1nq2N3nVbxrcTcm3J29f+yiObPFvbGmdAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADARLcDtGPHDhUXFysYDMrn82nDhg3tHnccR4sWLVJubq5SU1NVWFioI0eOuDUvAKCP6HaAWltbNXLkSC1fvrzDx59//nktW7ZMK1as0J49ezRw4EBNmTJFZ8+e/cbDAgD6jm5fCaGoqEhFRUUdPuY4jqqrq/Xzn/9c99xzjyTpd7/7nbKzs7VhwwY98MAD32xaAECf4ervgBoaGtTU1KTCwsLYfYFAQOPGjdOuXbs6/JpIJKJwONxuAwD0fa4GqKmpSZKUnZ3d7v7s7OzYY19XVVWlQCAQ2/Ly8twcCQAQp8w/BVdRUaFQKBTbGhsbrUcCAPQCVwOUk5MjSWpubm53f3Nzc+yxr/P7/UpPT2+3AQD6PlcDVFBQoJycHNXW1sbuC4fD2rNnj8aPH+/moQAACa7bn4I7ffq0jh49Grvd0NCg+vp6ZWRkKD8/X2VlZXr22Wc1ZMgQFRQUqLKyUsFgUNOmTXNzbgBAgut2gPbv369JkybFbpeXl0uSSkpKtHr1av3kJz9Ra2urHn30UX355Ze64447tHnzZg0YMMC9qQEACa/bAZo4caIcx7no4z6fT08//bSefvrpbzQYAKBvM/8UHADg8kSAAAAmCBAAwAQBAgCY6PaHEGDjtowhnq194P95++cyVp8549na/+eKKzxbGxfy8nv5qGcre/v6kST9u7fL91WcAQEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJjwOY7jWA/xj8LhsAKBgEKhkNLT063HiRuPDbnLeoQe+///GbEeAQkgNdlvPUKPrTyyyXqEuNLVf8c5AwIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACa6HaAdO3aouLhYwWBQPp9PGzZsiD127tw5LViwQCNGjNDAgQMVDAb18MMP68SJE27ODADoA7odoNbWVo0cOVLLly+/4LEzZ86orq5OlZWVqqur09tvv61Dhw7p7rvvdmVYAEDfkdzdLygqKlJRUVGHjwUCAW3durXdfS+//LLGjh2rzz77TPn5+T2bEgDQ53Q7QN0VCoXk8/l05ZVXdvh4JBJRJPK/l2oJh8NejwQAiAOefgjh7NmzWrBggR588MGLXg+oqqpKgUAgtuXl5Xk5EgAgTngWoHPnzun++++X4ziqqam56H4VFRUKhUKxrbGx0auRAABxxJO34M7H59ixY3r//fcveTVUv98vvz9xr4ILAOgZ1wN0Pj5HjhzRtm3blJmZ6fYhAAB9QLcDdPr0aR09ejR2u6GhQfX19crIyFBubq7uvfde1dXVadOmTWpra1NTU5MkKSMjQykpKe5NDgBIaN0O0P79+zVp0qTY7fLycklSSUmJfvGLX2jjxo2SpFtuuaXd123btk0TJ07s+aQAgD6l2wGaOHGiLvVHVOPsD6wCAOIU14IDAJggQAAAEwQIAGCCAAEATBAgAIAJzy9GCnesPLLJs7W/nT7Is7Ul6TuZN3q6vlf+46vEvDBuZsrFrzwSz7Y113u29uHw556tjZ7jDAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMBEsvUAsHeDf5Cn68/N+r6n63vlwT8vsR6hR56+scR6hB754vQp6xHQyzgDAgCYIEAAABMECABgggABAEwQIACACQIEADDR7QDt2LFDxcXFCgaD8vl82rBhw0X3ffzxx+Xz+VRdXf0NRgQA9EXdDlBra6tGjhyp5cuXX3K/9evXa/fu3QoGgz0eDgDQd3X7P6IWFRWpqKjokvscP35cTzzxhLZs2aKpU6f2eDgAQN/l+u+AotGoZsyYofnz52vYsGFuLw8A6CNcvxTP0qVLlZycrDlz5nRp/0gkokgkErsdDofdHgkAEIdcPQM6cOCAXnzxRa1evVo+n69LX1NVVaVAIBDb8vLy3BwJABCnXA3Qhx9+qJaWFuXn5ys5OVnJyck6duyYnnzySQ0ePLjDr6moqFAoFIptjY2Nbo4EAIhTrr4FN2PGDBUWFra7b8qUKZoxY4ZmzpzZ4df4/X75/X43xwAAJIBuB+j06dM6evRo7HZDQ4Pq6+uVkZGh/Px8ZWZmttu/f//+ysnJ0Q033PDNpwUA9BndDtD+/fs1adKk2O3y8nJJUklJiVavXu3aYACAvq3bAZo4caIcx+ny/n/961+7ewgAwGWAa8EBAEwQIACACQIEADBBgAAAJggQAMCE69eCQ+J59++7PV2/+JrveLq+Vw6HP7ceoUcS9fn2+ucQ8YczIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYIIAAQBMECAAgAkCBAAwQYAAACYIEADABAECAJggQAAAEwQIAGCCAAEATBAgAIAJAgQAMEGAAAAmCBAAwAQBAgCYSLYe4Oscx5EkhcNh40nglnPR/7QeoUcS9WeQ5xvWzn8vz/97fjFxF6BTp05JkvLy8ownweUuEAhYj3BZ4fnue06dOnXJ76vP6SxRvSwajerEiRNKS0uTz+frdP9wOKy8vDw1NjYqPT29FyZ0B3P3rkSdW0rc2Zm7d8XT3I7j6NSpUwoGg+rX7+K/6Ym7M6B+/fpp0KBB3f669PR08ye9J5i7dyXq3FLizs7cvSte5u7KGS0fQgAAmCBAAAATCR8gv9+vp556Sn6/33qUbmHu3pWoc0uJOztz965EnDvuPoQAALg8JPwZEAAgMREgAIAJAgQAMEGAAAAmEjpAy5cv1+DBgzVgwACNGzdOe/futR6pU1VVVRozZozS0tKUlZWladOm6dChQ9Zjddtzzz0nn8+nsrIy61E6dfz4cT300EPKzMxUamqqRowYof3791uPdUltbW2qrKxUQUGBUlNTdf311+uZZ57p9NpaFnbs2KHi4mIFg0H5fD5t2LCh3eOO42jRokXKzc1VamqqCgsLdeTIEZth/8Gl5j537pwWLFigESNGaODAgQoGg3r44Yd14sQJu4H/R2fP9z96/PHH5fP5VF1d3WvzdUfCBujNN99UeXm5nnrqKdXV1WnkyJGaMmWKWlparEe7pO3bt6u0tFS7d+/W1q1bde7cOd15551qbW21Hq3L9u3bp5UrV+rmm2+2HqVTX3zxhSZMmKD+/fvrvffe05/+9Cf95je/0VVXXWU92iUtXbpUNTU1evnll/XnP/9ZS5cu1fPPP6+XXnrJerQLtLa2auTIkVq+fHmHjz///PNatmyZVqxYoT179mjgwIGaMmWKzp4928uTtnepuc+cOaO6ujpVVlaqrq5Ob7/9tg4dOqS7777bYNL2Onu+z1u/fr12796tYDDYS5P1gJOgxo4d65SWlsZut7W1OcFg0KmqqjKcqvtaWlocSc727dutR+mSU6dOOUOGDHG2bt3qfO9733Pmzp1rPdIlLViwwLnjjjusx+i2qVOnOrNmzWp33w9+8ANn+vTpRhN1jSRn/fr1sdvRaNTJyclxfvWrX8Xu+/LLLx2/3++sW7fOYMKOfX3ujuzdu9eR5Bw7dqx3huqCi839+eefO9dee61z8OBB57rrrnN++9vf9vpsXZGQZ0BfffWVDhw4oMLCwth9/fr1U2FhoXbt2mU4WfeFQiFJUkZGhvEkXVNaWqqpU6e2e+7j2caNGzV69Gjdd999ysrK0qhRo/TKK69Yj9Wp22+/XbW1tTp8+LAk6eOPP9bOnTtVVFRkPFn3NDQ0qKmpqd3PSyAQ0Lhx4xLyterz+XTllVdaj3JJ0WhUM2bM0Pz58zVs2DDrcS4p7i5G2hUnT55UW1ubsrOz292fnZ2tv/zlL0ZTdV80GlVZWZkmTJig4cOHW4/TqTfeeEN1dXXat2+f9Shd9umnn6qmpkbl5eX66U9/qn379mnOnDlKSUlRSUmJ9XgXtXDhQoXDYQ0dOlRJSUlqa2vT4sWLNX36dOvRuqWpqUmSOnytnn8sEZw9e1YLFizQgw8+GBcX+ryUpUuXKjk5WXPmzLEepVMJGaC+orS0VAcPHtTOnTutR+lUY2Oj5s6dq61bt2rAgAHW43RZNBrV6NGjtWTJEknSqFGjdPDgQa1YsSKuA/TWW2/p9ddf19q1azVs2DDV19errKxMwWAwrufui86dO6f7779fjuOopqbGepxLOnDggF588UXV1dV16c/ZWEvIt+CuvvpqJSUlqbm5ud39zc3NysnJMZqqe2bPnq1NmzZp27ZtPfrzE73twIEDamlp0a233qrk5GQlJydr+/btWrZsmZKTk9XW1mY9Yodyc3N10003tbvvxhtv1GeffWY0UdfMnz9fCxcu1AMPPKARI0ZoxowZmjdvnqqqqqxH65bzr8dEfa2ej8+xY8e0devWuD/7+fDDD9XS0qL8/PzY6/TYsWN68sknNXjwYOvxLpCQAUpJSdFtt92m2tra2H3RaFS1tbUaP3684WSdcxxHs2fP1vr16/X++++roKDAeqQumTx5sj755BPV19fHttGjR2v69Omqr69XUlKS9YgdmjBhwgUfcz98+LCuu+46o4m65syZMxf8Ia+kpCRFo1GjiXqmoKBAOTk57V6r4XBYe/bsifvX6vn4HDlyRL///e+VmZlpPVKnZsyYoT/+8Y/tXqfBYFDz58/Xli1brMe7QMK+BVdeXq6SkhKNHj1aY8eOVXV1tVpbWzVz5kzr0S6ptLRUa9eu1TvvvKO0tLTY++CBQECpqanG011cWlraBb+nGjhwoDIzM+P691fz5s3T7bffriVLluj+++/X3r17tWrVKq1atcp6tEsqLi7W4sWLlZ+fr2HDhumjjz7SCy+8oFmzZlmPdoHTp0/r6NGjsdsNDQ2qr69XRkaG8vPzVVZWpmeffVZDhgxRQUGBKisrFQwGNW3aNLuhdem5c3Nzde+996qurk6bNm1SW1tb7LWakZGhlJQUq7E7fb6/Hsr+/fsrJydHN9xwQ2+P2jnrj+F9Ey+99JKTn5/vpKSkOGPHjnV2795tPVKnJHW4vfbaa9ajdVsifAzbcRzn3XffdYYPH+74/X5n6NChzqpVq6xH6lQ4HHbmzp3r5OfnOwMGDHC+9a1vOT/72c+cSCRiPdoFtm3b1uHPdElJieM4//1R7MrKSic7O9vx+/3O5MmTnUOHDtkO7Vx67oaGhou+Vrdt2xa3c3cknj+GzZ9jAACYSMjfAQEAEh8BAgCYIEAAABMECABgggABAEwQIACACQIEADBBgAAAJggQAMAEAQIAmCBAAAATBAgAYOK/AOOIVeXF8BKOAAAAAElFTkSuQmCC\n"},"metadata":{}}],"source":["# 샘플 확인\n","plt.imshow(train_ds[0][0].permute(1,2,0))\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"M1LYU7zyCNK-"},"source":["### Test VAE"]},{"cell_type":"code","execution_count":13,"metadata":{"executionInfo":{"elapsed":1046,"status":"ok","timestamp":1736430083735,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"RJJv-jz_ZkVy"},"outputs":[],"source":["# make vae\n","vae = VAE(CHANNELS, LATENT_EMB_DIM)\n","\n","# load parameters\n","model_state = torch.load(VAE_BEST_WEIGHTS_PATH, weights_only=True)\n","vae.load_state_dict(model_state['vae'])\n","vae.eval();"]},{"cell_type":"code","execution_count":14,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":201},"executionInfo":{"elapsed":566,"status":"ok","timestamp":1736430086910,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"71VDGODxt0ox","outputId":"8dab94e8-6033-4e9c-9472-a84b3434c1b8"},"outputs":[{"output_type":"stream","name":"stdout","text":["torch.Size([5, 3, 16, 16])\n","torch.Size([5, 3, 16, 16])\n"]},{"output_type":"display_data","data":{"text/plain":["<Figure size 1300x500 with 1 Axes>"],"image/png":"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\n"},"metadata":{}}],"source":["# Reconstruction experiments of the VAE\n","val_loader_iter = iter(train_loader)\n","x_test = next(val_loader_iter)[0][:5].clone()\n","print(x_test.shape)\n","\n","predictions = vae(x_test)\n","print(predictions[0].shape)\n","\n","fig = plt.figure(figsize=(13,5))\n","plt.imshow(torch.cat([x_test, predictions[0]]).permute(2, 0, 3, 1).reshape(IMAGE_SIZE, -1, 3).cpu().detach().numpy().clip(0,1))\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"J35Bp5pN2ZaH"},"source":["LDM(Latent Diffusion Model)은 VAE를 거친 잠재변수에 노이즈를 추가하고 추가된 노이즈를 제거하는 모델이기 때문에 데이터 셋에 있는 모든 이미지를 잠재변수로 변환합니다. [en] The LDM (Latent Diffusion Model) adds noise to the latent variables obtained from the VAE and removes the added noise. Therefore, all images in the dataset are converted into latent variables."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":6288,"status":"ok","timestamp":1736235849268,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"roCBwOGYZkVy","outputId":"4543e877-957b-400d-e869-673e0aea6372"},"outputs":[{"name":"stderr","output_type":"stream","text":["100%|███████████████████████████████████████████████████████████████████| 2794/2794 [00:03<00:00, 814.87it/s]\n"]}],"source":["# 모든 데이터를 latent z로 만들기 [en] Encode all data into latent z\n","# 데이터셋의 미니배치 사이즈 32이므로 32장씩 변환 [en] Convert in batches of 32 as the dataset's mini-batch size is 32.\n","vae.to(device)\n","\n","latents = []\n","labels = []\n","\n","for i, D_batched in enumerate(tqdm(train_loader)):\n","    X_batched = D_batched[0].to(device)\n","    y_batched = D_batched[1]\n","\n","    mu, log_var = vae.encode(X_batched)\n","    z = vae.reparameterize(mu, log_var)\n","    z = z.detach().cpu()\n","    latents.append(z)\n","    labels.append(y_batched)"]},{"cell_type":"markdown","metadata":{"id":"C0A9iueN2ZaH"},"source":["변환된 잠재변수는 32개씩 2794세트가 있으므로 이를 모두 이어 붙여 전체 데이터 셋을 구성합니다."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":449,"status":"ok","timestamp":1736235851519,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"cMNt7A9XZkVz","outputId":"fa01ab84-256c-4a94-da43-18ac4edb27d8"},"outputs":[{"data":{"text/plain":["(2794, torch.Size([32, 4, 8, 8]))"]},"execution_count":14,"metadata":{},"output_type":"execute_result"}],"source":["# 변환된 잠재 변수 개수와 잠재변수의 모양 [en] Number of converted latent variables and their shape\n","len(latents), latents[0].shape"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":2,"status":"ok","timestamp":1736235853159,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"lJDiEkrEZkVz","outputId":"89bc27c1-9a04-474d-db62-c175e0337fbf"},"outputs":[{"data":{"text/plain":["(torch.Size([89400, 4, 8, 8]),\n"," device(type='cpu'),\n"," torch.Size([89400, 5]),\n"," device(type='cpu'))"]},"execution_count":15,"metadata":{},"output_type":"execute_result"}],"source":["# concat\n","latents = torch.cat(latents, axis=0)\n","labels = torch.cat(labels, axis=0)\n","latents.shape, latents.device, labels.shape, labels.device"]},{"cell_type":"markdown","metadata":{"id":"5itwDXwwZkVz"},"source":["### Latent variable reconstruction experiment\n","\n","변환된 전체 데이터 셋에서 임의로 5개를 가져와 VAE로 복원해보겠습니다. [en] Randomly select 5 samples from the converted dataset and reconstruct them using the VAE."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":219},"executionInfo":{"elapsed":474,"status":"ok","timestamp":1736235861705,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"eG2OVuKzZkVz","outputId":"f8fa7ca4-ad8c-443f-ee2e-f5b125712d8f"},"outputs":[{"name":"stdout","output_type":"stream","text":["torch.Size([5, 4, 8, 8])\n","torch.Size([5, 3, 16, 16])\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"},{"data":{"text/plain":["array(['spell', 'non-hero', 'spell', 'spell', 'non-hero'], dtype='<U11')"]},"execution_count":16,"metadata":{},"output_type":"execute_result"}],"source":["shuffled_indices = torch.randperm(latents.size(0))\n","latents = latents[shuffled_indices]\n","labels = labels[shuffled_indices]\n","\n","x_test = latents[:5].to(device)\n","print(x_test.shape)\n","\n","predictions = vae.decode(x_test)\n","print(predictions.shape)\n","\n","plt.imshow(predictions.permute(2, 0, 3, 1).reshape(IMAGE_SIZE, -1, 3).cpu().detach().numpy().clip(0,1))\n","plt.show()\n","\n","LABEL_NAMES[np.argmax(labels[:5].numpy(), axis=1)]"]},{"cell_type":"markdown","metadata":{"id":"cVZY-TgK2ZaI"},"source":["복원된 이미지와 레이블이 잘 일치하는지 확인합니다. 잘 일치하는것 같습니다.\n","\n","이것으로 VAE에 대한 준비는 마쳤습니다. 이제 노이즈 제거 모델을 정의하고 학습하겠습니다."]},{"cell_type":"markdown","metadata":{"id":"YM243VNEZkVz"},"source":["## Latent Diffusion Model"]},{"cell_type":"markdown","metadata":{"id":"UH2u24Zg2ZaI"},"source":["### Dataset and DataLoader"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Gj5tob-aZkVz"},"outputs":[],"source":["class MyDataset(Dataset):\n","    # beta는 DDPM 원문의 설정을 따름\n","    # [en] Beta follows the settings from the original DDPM paper.\n","    beta_1 = 1e-4\n","    beta_T = 0.02\n","    # 시간 단계는 deeplearning.ai에서 제공하는 숏코스 How Diffusion Models Work의 설정을 따름\n","    # [en] Time steps follow the settings from deeplearning.ai's short course \"How Diffusion Models Work\"\n","    T = 500\n","\n","    # beta는 첨자 1부터 T까지 사용하기 위해 제일 앞에 더미 데이터 tf.constant([0.])를 추가하여 만듬\n","    # [en] Beta is created by adding dummy data tf.constant([0.]) at the beginning to use subscripts from 1 to T\n","    beta = torch.cat([ torch.tensor([0]), torch.linspace(beta_1, beta_T, T)], axis=0)\n","    alpha = 1 - beta\n","    alpha_bar = torch.exp(torch.cumsum(torch.log(alpha), axis=0))\n","\n","    labels = LABEL_NAMES\n","\n","    def __init__(self, data, ctx, transform=None):\n","        self.data = data\n","        self.transform = transform\n","        self.ctx = ctx\n","\n","    def __len__(self):\n","        return self.data.shape[0]\n","\n","    def __getitem__(self, i):\n","        x_0 = self.data[i]\n","        ctx = self.ctx[i]\n","        label = MyDataset.labels[np.argmax(ctx)]\n","\n","        # 잠재변수를 normalize -1~1로 만들기\n","        if self.transform:\n","            x_0 = self.transform(x_0)\n","\n","        # noise 추가\n","        t = np.random.randint(1, MyDataset.T+1)\n","        eps = torch.randn_like(x_0)\n","        x_t = torch.sqrt(MyDataset.alpha_bar[t]) * x_0 + torch.sqrt(1 - MyDataset.alpha_bar[t]) * eps\n","\n","        return x_0, x_t, eps, t, ctx, label"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"81_kB2jfZkVz"},"outputs":[],"source":["BATCH_SIZE = 256\n","\n","# 잠재변수에 대한 Transform은 필요없음\n","# [en] No transformation needed for latent variables\n","train_ds = MyDataset(latents, labels, None)\n","train_loader = DataLoader(train_ds, batch_size=BATCH_SIZE, shuffle=True)#, num_workers=2)\n","train_loader_iter = iter(train_loader)"]},{"cell_type":"markdown","metadata":{"id":"ZeP2sMqG2ZaI"},"source":["정의된 데이터로더로 부터 임의의 데이터 5개를 가져와서 각 항목의 텐서 모양과 데이터를 확인합니다."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"AV5f1kl5ZkVz"},"outputs":[],"source":["samples = next(train_loader_iter)\n","\n","x_0s = samples[0][:6].numpy()\n","x_ts = samples[1][:6].numpy()\n","epss = samples[2][:6].numpy()\n","ts =  samples[3][:6].numpy()\n","ctx = samples[4][:6].numpy()\n","labels = samples[5][:6]"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":683,"status":"ok","timestamp":1736235882982,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"FCrtadFRZkVz","outputId":"de93e402-e915-4058-ac72-218efc391ea6"},"outputs":[{"data":{"text/plain":["((6, 4, 8, 8),\n"," (6, 4, 8, 8),\n"," (6, 4, 8, 8),\n"," array([  9, 281, 324, 360, 344,  80], dtype=int64))"]},"execution_count":20,"metadata":{},"output_type":"execute_result"}],"source":["x_0s.shape, x_ts.shape, epss.shape, ts"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":1,"status":"ok","timestamp":1736235885402,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"02VZv_V3Nhd7","outputId":"8ef6bf6f-380b-484a-9a4b-b06f22e66030"},"outputs":[{"data":{"text/plain":["(array([[0., 0., 0., 1., 0.],\n","        [0., 1., 0., 0., 0.],\n","        [0., 1., 0., 0., 0.],\n","        [0., 1., 0., 0., 0.],\n","        [0., 0., 0., 1., 0.],\n","        [0., 1., 0., 0., 0.]], dtype=float32),\n"," ('spell', 'non-hero', 'non-hero', 'non-hero', 'spell', 'non-hero'))"]},"execution_count":21,"metadata":{},"output_type":"execute_result"}],"source":["ctx, labels"]},{"cell_type":"markdown","metadata":{"id":"wSzbuL0y2ZaK"},"source":["데이터로더에서 가져온 원본 잠재변수 $\\mathbf{x}_0$를 VAE로 디코딩 해봅니다."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":165},"executionInfo":{"elapsed":471,"status":"ok","timestamp":1736235893215,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"Uc07TiHbZkVz","outputId":"b3eb1834-0c6f-4252-a5cc-cb72a3c48a82"},"outputs":[{"name":"stdout","output_type":"stream","text":["torch.Size([6, 3, 16, 16])\n"]},{"data":{"image/png":"iVBORw0KGgoAAAANSUhEUgAAAh8AAACBCAYAAABgrtjLAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAomUlEQVR4nO2deXxV1bn+n33GzAkkkAEICUgbVBQFQZywhWrR61DbXrVosfbqVeGnSFuVKli1NFqv/Wlbq62t2jqhtIpDq14LVkWRSUZBQGQIQxKm5GQ8J+ec9fvDGgnPG6u/wkmU5+snn495svd+115r7X3es3nWuz3nnIMQQgghRIrwdXUDhBBCCHFooeRDCCGEEClFyYcQQgghUoqSDyGEEEKkFCUfQgghhEgpSj6EEEIIkVKUfAghhBAipSj5EEIIIURKUfIhhBBCiJSi5EMIIYQQKeWgJR/33nsvysrKkJaWhpEjR2LhwoUHK5QQQgghPkd4B+PdLk8++SS++93v4v7778fIkSNx9913Y9asWVi7di169+79ifsmk0ls374d2dnZ8DzvQDdNCCGEEAcB5xwaGhpQUlICn+9fPNtwB4ERI0a4iRMntv+eSCRcSUmJq6ys/Jf7VlVVOQD60Y9+9KMf/ejnc/hTVVX1Lz/rAzjAxGIxLFmyBFOnTm3XfD4fxo4di/nz59P20WgU0Wi0/Xf3zwcxWzZuRk52zsd60IpmPBmJxztpGZ+qQ9LQ/Lyn1UuujbWooQFAIMOIkyDNetLTFuPs0Z/e2TkaJHh/n9/xdsYDsKTRv87jPvPDHBy0tnE7fQHuX+sBVzDB7Wn1WAt2kl3HElHSQl6INGfs7nPWEzfWPKMvAMCz9ufhRtzY3/Pxvr44N9KzuxyIG23y8zgkjE5PGuPIowV4UeNkACSNsfUbB7Bmb8CYkmdMnUvatmCBGTt3LW/794cmkxYyH6buZimjJ0mRvXvN2Dnp3B+JRC5py6vrSPvJDx8hraBHHmm/vP58M3b6gHTSPGMcfG3cwQ71pJX16k+aNQcAoBjZpG1BA2k5pJg9juqN21gMZdnBw8a9NsjzN2pdDknuC+ue6HmdzPP4p7tXBo1xsPa17onGrRMAEPDzCSU8vj9Yu4eSxv0mwVsmA3yfBIAEuM99bR3bHmmIoHxAf2Rn89zYnwOefOzatQuJRAKFhYUd9MLCQrz33nu0fWVlJW655RbSc7JzkJOj5OPznHyEDnDyEVLy8fF2h0DyEQhnkuYL2h9G/mAaafvePz7CTj5iLGUYH5nGjRroLPng/bMaebtAgNsdDHJCkZNlfYQD6Tn/TvJhfOAaMTp7eO63rolPub+1nTVeSj460t2Tj/bjfgrLRJevdpk6dSrq6+vbf6qqqrq6SUIIIYQ4iBzwJx8FBQXw+/2oqanpoNfU1KCoqIi2D4fDCIfDpHuBD38+wnpKYWZOgU6+EhrfrJKe8U3NWd9mjUhJjpNIM75BAfC1tJLmpfM3HitdNb4EIWZ8iwkZWT8AJNqMbwh+o+1Gku83Zwf32e4IP74FgJhxzB4Z/Dg6zTWT1mJkzrvjfMDGSK0Zu6KYjc0OPM9i1ncwQwo461uQnd0njbY7H49ZwMd92dzaRFpGGj8BaLG/lCGeNJ6UtfE3mQxjXtXV8zj4fDynM/15Zuyg8YXJuOywZy8/lbr9j8tIW5J5BGmhihIzdrxwIGn9R/6ItGXz7yTtnK/+mrSlzXwfKA4Wm7G/9vVepN019VuknXHuz7mNd91F2pWDOMaoi24wY6+cP4O0mOP7TWgX/5PR4X1KSbtn8DDSTultfw1/dzvPl9555aTtWLGJtKZB/DS4PJ8f1Xf2Tz5rI3ydRB23M+z4CC7M12fCuMcH4/bHoxfg/eNRntNBI7bPuD4TSb6Yo632BR70G09vg3yPTxpDlgjzvAgEuc+T5lULBK0nJ6GOnyWB0Kd/nnHAn3yEQiEMGzYMc+bMadeSySTmzJmDUaNGHehwQgghhPicccCffADAlClTMGHCBAwfPhwjRozA3XffjaamJnzve987GOGEEEII8TnioCQf559/Pnbu3Inp06ejuroaQ4cOxUsvvUQmVCGEEEIcehyU5AMAJk2ahEmTJh2swwshhBDic8pBSz7+XZLOQ3KfJYs+71M2tRMjnulcMlw58RjHsUL7DM1LsDEQsJeSWhg+PPQwXDmmubST83ZBbmizsbQwbC4v5U7b8h7Xann81SfM2Nt28Zr/Oyb/gjdM5JMUy+TOWLFzAWnfufICM3bt8xv4mIZRLGz4i30+7kxnLTu2fVlIGubomGcsO27jcfQMc+nvK9kQecct08zYq19+g7RXr7yEtOMfmkVaYiTX0DihZAhpyzbYK9KC7AEEsriTLpn8KGlzRnyftAzDwL1nxkQzdv6F15K2dysbIotyruCdr+Wl/v5z+Cnt5rVmaDx15/+Q9uTvxpPmO/4E0qo38LyYtISrYBw1gfsHANDC12jIWKZe1oeNuhcPYlP2lDVLSKtbY4fONZfYc3tiYKNjyyo2qT9Rwe0p6snGVAAoymWT717DuB5N8KQMJI1jWu7HTpZWG95xBENsZrf86HsNY+qNN19M2tQJ15ixsyr6knb25eeS9vBtj5NWmDGYtKS1RiJof2A5n7EwJLHfvW7/3z+BLl9qK4QQQohDCyUfQgghhEgpSj6EEEIIkVKUfAghhBAipSj5EEIIIURK8ZzrzLPfNUQiEeTm5qK+vm6/Fw1ZL+sy3Mh2TXA4o3a5Zyz2iRkrYJyxAiYtncuEh7NtZ3a0odpQjXYGjFwwznbkVldHWhDcHsB+z1ibUYbYM2qhZxgvLJrws9NIa/iy/QbD6i0R0srTB5B252QuO/3AGw+T9pO/80qZ48dwCW4AWPLzlaQ1P8XjYLzzz3zhFqzVQJ2sYoq3GS8sNFbaGFWwEa/eQtpf/ouL8118dJkZ+/Vn55B2Ul9eufFKM9dXX1LDq1guu/BC0n7w59lm7Ec2cJ9by7DOnPYMaYvyziYtt7/x4rIbLzFjb2rggSw+/CjSWr/LqwhqrZfaGfMiHjGWowHmcriMnVzyuvnuW0k78iIuw76t4ljS9v7hHjN08i0+n8Eev7rh/57Cq0MueX0raZsdrw7ZDfu+ZhW6b97DZdzbenD/ZHt8z8gIsRazlqMB+J9yXvVRmM4rba5YzEt1tkf4vpSTbryUrtUu7h42li/+9nc3kfabV58mLWsoj0P+SI6zZ/EeM/a2Bo7dawDfSNw2XpkSbOFVhX32cJ/PevAFM7a1oNKf6LjCKBKJILdnMerr6+0XBe6DnnwIIYQQIqUo+RBCCCFESlHyIYQQQoiUouRDCCGEECml25ZXd//8+QjPMgH6OXeKd2Kf9SeNU/WzhSZk1E330tmcN2/+Ut63+l0z9sYP2NhV1IvNP7lFg0jrOeBLpOX780irNUoqA0AIbJJzhnPIqGYO+NiEVZPOfb7rjVozdpOfD1rrvUza9x/fRdqa6DrSQoexgcktM1ybAApCbMCtj3P55XzjEvCMstEJj41vnrNz96BVnjjOWmzPdtJ+dAYber+TYENafXrIjH3yKVwOvfHdbaQdlc6m49GlFaS9PXsVaRW9OAYAoJlNlrEQ9+WsG/6TtLOvn0nammae+/HsYjP0gLNGk7a3iI2XdfVsivWVDyQtsIuNk+mZRWbslm08N5pzWkgrnjaZtJq7uDR79PDXSesR59cFAEDMsAFWG9d8ca9G0lgB0gxzac9OKmZ7PjanZmTyNep5PH+j4LlSG+H7ZNSzza6jMvlVAFcdznMjK8n3bl+YTZZR41IO25cYHn/6TtKCWetJu2HCSaT9n7l/Ji0nj9vYOLaT5wIBLr2fvdsosZ+XR1qfPfzqhtuuPYe0My9hozYA/PXhFSz6/Z/8+yegJx9CCCGESClKPoQQQgiRUpR8CCGEECKlKPkQQgghRErptoZTD0l42NfpZBhZEmxa8vy2S8gzzKUwjHxegLvk5Tde5e2K2QjVow+bdwAgs/9G0gINbPfy53H1u83r3ietKcnn6MXt6ouBgLFtiPvCO5bNWpnF3D+nnj6YtN/f9FM7tlE8976qB0nbBjaclnmlpE2uGEba+c7u81t6/pa0gjFsuEKkB0lu7WbSfAmeF3E/G8UAu5puMsDjc+eFbJI8eedO0vqOGEFaImHVGwR89Txmtbu5PYeddjppm3fyOHzl8nGk/e626Wbs1//MptEhF36HtB6Z/J3nqv/ksf32jGdJC47+phm7oVdP0sq/zNcTHn6cpN2D2JyckZ9FmpesM2Nn+NkEGLvqK6S1/Y2v5ZaJk0hrfoAr+V54zy1m7GSSx9uo+4w3F/L9ptko0dvWxpU109u4bwEAaTyOHhfWhOVXDUTZiJybZldpttic4CqlwTo2wO4xDLlZAeva4XO54r8vMGP/PfIKaUUVfL+6ahRXr03O53PcXcojFopaowjseo8/8048oj9p5Sgjbe1fd/DxttSQNuIUPhcAmPZbrnZ8wamTO/ze2Mhj0Bl68iGEEEKIlKLkQwghhBApRcmHEEIIIVKKkg8hhBBCpJRuazh1CT/cPobQpGGw81tFTzspsOZa+dX0vnQ2jW7YyQac0FY2Ya15kY2TK3K4UiIAjBz1VdLScrk9i1a8Q9pL73JFxmBvw9VlOb0AIFlPUvm3uJIqDuNzHHIlb+cyudPv3vxrM3RWGhsyq0Nszgu38Hb5BWyUXVDFlTrrvMfM2PmnsJH0jFI2Ac59hCt4ll3E5sdNf1puRLFLP/qNCqktDZznD0zj+fe1o3gOhbK5Mut9i9iYCgAD93KcU4fx+Tz5CJvmqgyT5Q9vvIy04iRXiASAtHquCuoPcl889iwbLyf/8k+k5Ya5kqrvGK7CCgAtmTxf3jOu+QzDj562myuh+hvZ8BePNZixC3xsfqw3bq3VO/j17vGyY/mAp7JJd+6zq83Y0ZOOJy1mFNh1eb1Z3FFNUrDNMH3aRUbh4txvjT4Obs2WRJjv5/EkVysOuE7KjBqMHMRGyawqNlEjxh8SdTEew29dyYZRAHjihbmkuWN4/0uX3kVa7qV8PbSGed/IDnsBAYy31M/ewNdTzxrWsJ1jf3MDm+sTcTstuOr680mbMmtqh9/jrbZR1kJPPoQQQgiRUpR8CCGEECKlKPkQQgghREpR8iGEEEKIlNJtDadA7J8/H+IPsfEoWseGsrDfNgH6erHh6q9vvUhaTSubntJy2XF1xJjvklZVy+YdAMgIsMFp80Y2eC5fyqayX/9PJWltTWzsi8Zsg1JzkA1kj1U+TdqZ151H2lDHrxD3p7Oxta7Jrra5s4nPMTPOhtWCNB7bpe9uIe0Iw4z52rpNZuxQkE1cUbBxs7WNL4Gq9zk2fGyKZfvWhxx9PL+Sevnb/DrqFVuMfjMqBBY38py87qkHzNj3nMEVM1c3sEvt6MobSBs79EjSRn/1RNLuf+RqM/afn/wraYPcJaTNfJ1Nvrs2cF+knX8Eaa1gkyMAZKUbFTNjfH9oySwjrZdRbbPxEa4yGu7d14wdHcGVav238jWWN4AN3Lta+bzTL+aKtrUrNpix8zJ4/rYZRnwvz9g5zvfKaLrl2DcOCCAU56qp2QE2LceSvH/IZ8SJG9+FQ/ZVlmdob1azmT0BwyRseFjzQmyLnXLfBDN2/n9zNejtDWyGj/bmQLvb6kjLMk4xfYAZGk1Gsdl0XlMAF+NxCFXweMWN+3FOHZ8fAOyp5wqpl503vsPvzQ0tmHvDG+b++6MnH0IIIYRIKUo+hBBCCJFSlHwIIYQQIqUo+RBCCCFESum2hlPP54e3jympLWGYSwNsAvSCRnk/AK++NZu01kQLaVv/9xnSAkE24PQYOYq0ojKjiiCAZQsXk/bG28tIu/nnM0hzznpFMRvFfJ1UOE0zfKhjB3Hbw1VcMbMhyWbVyGY2UZUMsPt8Uw0bY4t68WvOt+xkx9TA0jzSdmzi7QYMtMsv7tjIRqr+eezWyuvN5se6Dfza6ngzmz631PP8AYBTQjwPBuexg+yu3gWknXFUOWkvvcbVCh85/Toz9rkrXyatf7ExN17cRNLOLN7uvhVsgi7YZlV7BVa/z9Vms5p4/i54fg5pgTF8Pq2G0RZR+5YVffQfpCXB4zjsorNIi19xMml9R3Dl0K27/2bGbu7J+7elsck3dscTpGWceiYfL8n7lvW1TYAW8Vae++lpfI3edjLPyf4+/j5a7WxDOYJ87bkox/HCxv3B8IG2ZPO9Jduz7y1XV5SQdvPq7RymhT83HPh8ouDK1qMvt+/nv45+QFp+P/4sytnKN9/amXy8rBvZRL0tzZj7AIxmImqtNVjD5lJYJtYao5Lvl6vM0C/vZcP+5pUdx6etma+5ztCTDyGEEEKkFCUfQgghhEgpSj6EEEIIkVKUfAghhBAipSj5EEIIIURK6barXdw///sIz2OHslfag7Qlb62zD1jEbuTwlvdIG/z100iLh9h93juYSdrbi18zQ69azas+fn7v7aQ5x9slrZUtRs7o76TWdzzIKzJcm7FKKK0/aX97kEuCe4ZrPtrCZdQBoFcJ99Hc3StJKzBKKCeq+Xi19Wzrzsi0V5y4bB6zZB/Woov4Etj1Gru9Az52pG947EEz9pgCPu9so+1fP20Yae8aK6NimTzPz7zwW2bsaJhX0FS9vZa0jLRC0uZ/fxppZ//iB6StWbHUjP3D8d8hbcF83rbwBL7Gdi1+ig84bCxJpZ2sdtlSx+W683x87exczaubEn0PIy34jnWO9kXWsHghH3PUUNJCZf1Ia03y6oCMw7nUt3/Pu2ZsgEvQ+43y4TFnrIAxVpJMO45XkfTz7O+oVU18TF8mHzOYz/M3Vr2etOIMnrs3DrVXnFQu41LfjU28GsOqxu8lea6MOe8k0qq/b78uo+Jw1npmGqXqB/BKm1pj0VJ6C69sCfHbIQAASV6cgiyupI66BcbOxqK3nmWsBf12n3sxLl+fk9Fx2VKbMxrYCXryIYQQQoiUouRDCCGEEClFyYcQQgghUspnTj5ef/11nHXWWSgpKYHneZg9e3aHvzvnMH36dBQXFyM9PR1jx47F+vX873tCCCGEODTxnDOcSJ/Aiy++iDfffBPDhg3Deeedh2eeeQbnnntu+9/vuOMOVFZW4o9//CPKy8sxbdo0rFy5EqtXr0ZamuH+2Y9IJILc3FzU761DTs4+BkEfN9Pz2Dj0t2e4vDQA9Ghi809zMedeyZ1Grdp01oryhpD2xnNPm7Gv+VUlabGoUV/YygUdG7gMCXYRYgBGKeF4C5e8XvI+G9q+WckGwupMNt0lY1vMyMccdxxpv/nGraTVbGXDap8Cdkc9uuo50p54mkt6A0BrhF13jU08jsvuf5O0I0uPIa3NMC8GE3buflLJINKOyeC5eltFBR8zh42/i5eyCbW5ynDkAhhaMZi04qNO5Q3P4bLeDZu4lHokyvWcX3yby6MDQLyE+/z8O37B7Tmar4e2Nh7vtK9yG5N9y8zYgRw2K4Z7sROvKcL9FhvI+3oLNpGW3jPfjF2QzybYeA+eL/UNfA9qyOU25rXyvKqbcYMZ2y3l/rXuBgmefmgyKnCXZ/M4fG2Ifd9+fiVve+X115MW7cVG7yd+eDlpx/XNI23eVsNECqDB8bVsfZDFY2zoDRoGd+s+GTrZNjd/7Qk2BL/dwvfzPUaDRvCuMKrhIzfMiwIAID/Kc3Xd5jrSSoqKSNuxh8vPB/pwP+7aaacEw2q+TNpRbniH36NNMdz5jZmor6/v+Plt8JlXu4wbNw7jxo0z/+acw913342bbroJ55xzDgDgT3/6EwoLCzF79mxccMEFnzWcEEIIIb5gHFDPx8aNG1FdXY2xYz9eIpebm4uRI0di/vz55j7RaBSRSKTDjxBCCCG+uBzQ5KO6+sNHmoWFHWsIFBYWtv9tfyorK5Gbm9v+068fr4UXQgghxBeHLl/tMnXqVNTX17f/VFXZr/MVQgghxBeDA1rhtOifJpeamhoUF39cyq2mpgZDhw419wmHwwiH2biUbPOQbPvYOOVzXMnSKNCHt9bZ/7wTD/QhzVfHZqZAZCtraVyx8rTTjidt0r03m7ETUTafWXXgAobPJ2mZS/lwiPs6qSzXxia3lnQe9vJBw0nzAmxuKjQMSk3eADP06BPHkHZ0YARpvgo2Km4xxuHIonrS+gy2za7vvL2G4xgm397FbBxuM7oybhj2gp1UlX151TukfX0wl0WctYUryDY2cTXSXMMgXB+0DWl7VizhbbfwMfc++gfeuTdXt3w3h2P/au6fzdjpCZ6srUmef/fcMoG0n//kAdI2zedqpD0aZpmxg1NuIi3hjErAxWzES27exQccwlVPmzrxyzdGeH9fI9/T0o3Kmhmz+ctW3cJ/kNazhit6fhiIjZIwztsyoeYYlTFrd7MLNSPfnmtXz/gtacMO78vHTHAbb7vpCj7evX8ircUwlgJAWwsfMxg0TOGWudS4z9bUc58V15aasZNz+P7Z57A80kIxvodN+soZpK0Gm/03buDrDgBKs3kccwPc53l+7p+/P8fH7H80T+px5eVm7B3v8b126qRXO/weiTTgTsw099+fA/rko7y8HEVFRZgz52M3fCQSwYIFCzBq1KgDGUoIIYQQn1M+85OPxsZGvP/+++2/b9y4EcuWLUPPnj1RWlqKyZMn46c//SkGDRrUvtS2pKSkw3JcIYQQQhy6fObkY/HixfjKV77S/vuUKVMAABMmTMDDDz+M6667Dk1NTbj88stRV1eHk046CS+99NKnqvEhhBBCiC8+nzn5OPXUU/FJdck8z8Ott96KW2/lYlJCCCGEEAfUcHog8YU//PmYDNommWRTjRcwnIGAVcAOsLaNG8fM4Ept03/0E9JcvJOkjD13CFg+KC7GB88YIfO87cjwB9jMmen4vINpfIRojE2+v76MTbXbF60zY7d+wP3mBvEJxeLcGZtrPyDt5ZeeJ+23E39lxj5u6dmkFfr51d69gtwX0QQPWHrAsEe1GgMGIGCMWUsLv476sh98j7Tf3PJH0p7ezaa76rSeZuxwAVfhvH/cUaTNXsLmsasv/BZpJ9/6U9J69GODGwC0tXA7Q8br3c/5Nhv5CkuuI+3bp/+AtKaB/Ap5AGh98a8shtkoHg7y68JDq/5CWuzk/yIto2abGTuWaxgyB7ORuXXlG7xdC8+rTMPvd+PPrUqmQNLx69gjMZ6/WUHuizaP568L8X0gZt48gW+cwibq9HquiJtoYe2iu+7n2M3G9WRfYmjzG9WpfXwtWzZ8Y0pi8n/wgoQ19/L8A4DYEXyEn7zJJsvy0aeQ9uP7uEpzjz58krGw4QYGsDzOpvmcL/HnTu1sNkGX7OXjTUgvI+3yw3lRAACcNZvvGY/NvKXD7y3NxoddJ3T5UlshhBBCHFoo+RBCCCFESlHyIYQQQoiUouRDCCGEECnFc5+0dKULiEQiyM3NxZ79XsnbZniewoZflO1X/9y/kauZZmQaB4hxPhYIG+5Q603P7IntFMuW43es+hI8PEnDROrrZBQ9zzaLMVzZ8D8uPYe0O69nQ2RZCb8GHgDSjGp8zrCA+QynbdLjvmhL8DgsjxvvBQfwH6dyUbtt85dzHMPs6jmuTumLcnXAgO0JA8DH3NXE4zAsiyfMCaNPJO2tVVyhdOn2nWbkWD337zijWmduHzZJLn/nPdK27KgjLTvPeC84gKRxmfgMY2DEMHWnR/lavPJZNrjNK7CrTtYv5vlS/8hPSGtpYsPpCdk8hzbWcrtzSyyrIrChnu86hQGeL40tvF1y1GmkDWx9m7SnZtvVkw8DV/V0hpHec0bFzKTx3dPPc/LoL9nX910P/Ia0/qXslh39VTbfbt/ILxCNxzi239lWeo8vUSQNd6rPWFORNMpGb3qVDcsTJnElXgC47PvHkvaXNVyN94KbxpKWH+Br5826paRFPPv63mPcR9J7c2dse4Ur5/55/M9I+8VjD5N27ED7Gtu8i4/56ksdPwjbYgn85fH1qN/v89tCTz6EEEIIkVKUfAghhBAipSj5EEIIIURKUfIhhBBCiJSi5EMIIYQQKaXbllf3JxPw71tG3CqnaxQVNwodAwBCRhltL2G41x2XiG4zygsHw0Z7nO2Gd21cEjcUMlYMJLmNSfAyFp+hOcPBDQBNxjGzgtbSmDxSXnjwNfOYnxZzAU6C3flWWWQHdkp7Hp/jEWF7Cm987X3SfEb5+0SAjxkwFgg1NlurXezxTk/yLCzINErIGwvNWo3lWl4az0nD7P8hudy/S6s3kWYsooLRvWhrNApU26cNn7F6ImmMdyhmXE/GyrPrT+US8isf4ZUBALB2Aa+eKJ/O7v6Nt99LWpXj8t+BfG733lZ7SVnZoKNJq4/x9Z05glcyYTSXKN/6Gz7H4kZuDwAgj+e/FzfW0nnGiz19Vu1yPsdNm+yy8l86qh9p5T25/H3CmOdxY7VgIMzzPGmtyAHgGR9dHjp5tcZ++Bz35S/uv4u0WI59Tz3yhEGklQ/tRdo9j84jbe0mLnt+5Rh+FUTVu9wXAHBc0TDSfv/cbNKuv5RfV1D25WtI27puOmmxnVvN2PM21JJWV95x/ra2xvAXrDf33x89+RBCCCFESlHyIYQQQoiUouRDCCGEEClFyYcQQgghUkq3La9et3dvx/KsPjapWaajRCfGS89jA49Vedz5jdLlxiGdYXbtrCN9hmE18SnNUdZWiSQfzxlmSgB4Z94i0oZ8lU1h/oRh1Y1zdF/YKI9ulBMHAFjt9PGYOaNEtGecjzNKLftM8ywAZ7Td4zhGpW/Axzn5gr+/QdqQ0VxKGgByQn05Thv3WzLAWsgw2FlzJRmzz9vqD7/PGJ8EmxJjSd43EDCsrf5OYhvXhNW9KxZuIK20Ipe0TH8BaWvYuw0AOPuS27g9GSWk/e8fvk9aL8P73dPwMTd38qYCyxo4e9Ee0u59ciFpG5azKfHH155L2iVjh5uxexg3iEDIMAkb3zOjxuQPB3iu7NzJ5m0AOO4ULg2//nV+FQCy2dgaTLOM4oaT2biHAEDceJ+E3zI8Gx9vfmOezn2CS8WfOO7LZuzn5s0lrb5qO2lPLn2LtLxCntO3Xc5m1+KsPmZsL1RMWrqvnrTmZnau74lWkzZjEptdd2yx3h0CnHLW6aSdNenaDr83NjRh5GFfU3l1IYQQQnQ/lHwIIYQQIqUo+RBCCCFESul2RcY+sqBEIvsVDZLn4+N9P4Pno7GJi2NR3wLwJ4yCQ/J8tNNk9mMnBoSQ8bpweT7aaWzkfmuIGOdtXIuNjWZoJONGdba2Ft7fmPth43QC/6bno6WJ4ySiPIdcnPdubeaTbDDaDQD+FHg+GhrseW4VkIs0GO10hucj1r08H00tPFciDTxeANDczGPW0sLXUzzG/dMW5bFpNOJEnN3nXjCTj+njbZtb+HpoiPK8irUZbbQqEAJojfI47t/2j37/NFbSbmc43bp1K/r148p5QgghhOj+VFVVoW9fNt7vS7dLPpLJJLZv347s7Gw0NDSgX79+qKqq+pfOWZFaIpGIxqYbo/Hpvmhsui8am38P5xwaGhpQUlICn/EEeV+63T+7+Hy+9ozpo3d55OTkaCJ0UzQ23RuNT/dFY9N90dj8/5Oby8vmLWQ4FUIIIURKUfIhhBBCiJTSrZOPcDiMm2++GeFwpy8QF12ExqZ7o/Hpvmhsui8am9TR7QynQgghhPhi062ffAghhBDii4eSDyGEEEKkFCUfQgghhEgpSj6EEEIIkVK6bfJx7733oqysDGlpaRg5ciQWLlzY1U06JKmsrMRxxx2H7Oxs9O7dG+eeey7Wrl3bYZvW1lZMnDgR+fn5yMrKwje/+U3U1NR0UYsPXW6//XZ4nofJkye3axqbrmPbtm246KKLkJ+fj/T0dAwZMgSLFy9u/7tzDtOnT0dxcTHS09MxduxYrF+/vgtbfGiQSCQwbdo0lJeXIz09HQMHDsRtt93W4X0kGpsU4LohM2fOdKFQyD344IPu3XffdZdddpnLy8tzNTU1Xd20Q47TTz/dPfTQQ27VqlVu2bJl7owzznClpaWusbGxfZsrrrjC9evXz82ZM8ctXrzYHX/88e6EE07owlYfeixcuNCVlZW5o446yl1zzTXtusama9izZ4/r37+/u+SSS9yCBQvcBx984F5++WX3/vvvt29z++23u9zcXDd79my3fPlyd/bZZ7vy8nLX0tLShS3/4jNjxgyXn5/vXnjhBbdx40Y3a9Ysl5WV5e655572bTQ2B59umXyMGDHCTZw4sf33RCLhSkpKXGVlZRe2SjjnXG1trQPgXnvtNeecc3V1dS4YDLpZs2a1b7NmzRoHwM2fP7+rmnlI0dDQ4AYNGuReeeUVN3r06PbkQ2PTdVx//fXupJNO6vTvyWTSFRUVuTvvvLNdq6urc+Fw2D3xxBOpaOIhy5lnnukuvfTSDtp5553nxo8f75zT2KSKbvfPLrFYDEuWLMHYsWPbNZ/Ph7Fjx2L+/Pld2DIBAPX19QCAnj17AgCWLFmCtra2DuNVUVGB0tJSjVeKmDhxIs4888wOYwBobLqS5557DsOHD8e3v/1t9O7dG8cccwweeOCB9r9v3LgR1dXVHcYmNzcXI0eO1NgcZE444QTMmTMH69atAwAsX74c8+bNw7hx4wBobFJFt3ux3K5du5BIJFBYWNhBLywsxHvvvddFrRLAh28cnjx5Mk488UQceeSRAIDq6mqEQiHk5eV12LawsBDV1dVd0MpDi5kzZ+Kdd97BokWL6G8am67jgw8+wH333YcpU6bgxz/+MRYtWoSrr74aoVAIEyZMaO9/6z6nsTm43HDDDYhEIqioqIDf70cikcCMGTMwfvx4ANDYpIhul3yI7svEiROxatUqzJs3r6ubIgBUVVXhmmuuwSuvvIK0tLSubo7Yh2QyieHDh+NnP/sZAOCYY47BqlWrcP/992PChAld3LpDm6eeegqPPfYYHn/8cRxxxBFYtmwZJk+ejJKSEo1NCul2/+xSUFAAv99PjvyamhoUFRV1UavEpEmT8MILL+DVV19F37592/WioiLEYjHU1dV12F7jdfBZsmQJamtrceyxxyIQCCAQCOC1117DL3/5SwQCARQWFmpsuoji4mIcfvjhHbTBgwdjy5YtANDe/7rPpZ4f/ehHuOGGG3DBBRdgyJAhuPjii3HttdeisrISgMYmVXS75CMUCmHYsGGYM2dOu5ZMJjFnzhyMGjWqC1t2aOKcw6RJk/DMM89g7ty5KC8v7/D3YcOGIRgMdhivtWvXYsuWLRqvg8yYMWOwcuVKLFu2rP1n+PDhGD9+fPv/a2y6hhNPPJGWpK9btw79+/cHAJSXl6OoqKjD2EQiESxYsEBjc5Bpbm6Gz9fxo8/v9yOZTALQ2KSMrna8WsycOdOFw2H38MMPu9WrV7vLL7/c5eXluerq6q5u2iHHlVde6XJzc90//vEPt2PHjvaf5ubm9m2uuOIKV1pa6ubOnesWL17sRo0a5UaNGtWFrT502Xe1i3Mam65i4cKFLhAIuBkzZrj169e7xx57zGVkZLhHH320fZvbb7/d5eXluWeffdatWLHCnXPOOVrOmQImTJjg+vTp077U9umnn3YFBQXuuuuua99GY3Pw6ZbJh3PO/epXv3KlpaUuFAq5ESNGuLfffrurm3RIAsD8eeihh9q3aWlpcVdddZXr0aOHy8jIcN/4xjfcjh07uq7RhzD7Jx8am67j+eefd0ceeaQLh8OuoqLC/e53v+vw92Qy6aZNm+YKCwtdOBx2Y8aMcWvXru2i1h46RCIRd80117jS0lKXlpbmBgwY4G688UYXjUbbt9HYHHw85/Yp6yaEEEIIcZDpdp4PIYQQQnyxUfIhhBBCiJSi5EMIIYQQKUXJhxBCCCFSipIPIYQQQqQUJR9CCCGESClKPoQQQgiRUpR8CCGEECKlKPkQQgghREpR8iGEEEKIlKLkQwghhBApRcmHEEIIIVLK/wNmpFynIDCCeAAAAABJRU5ErkJggg==","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# 원본 잠재 변수 x0를 디코딩\n","# [en] Decode the original latent variables x0\n","predictions = vae.decode(torch.tensor(x_0s).to(device))\n","print(predictions.shape)\n","\n","plt.imshow(predictions.permute(2, 0, 3, 1).reshape(IMAGE_SIZE, -1, 3).cpu().detach().numpy().clip(0,1))\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"O_pcf4Cs2ZaK"},"source":["이번에는 $\\mathbf{x}_0$에 잡음이 추가된 $\\mathbf{x}_t$를 디코딩 해보겠습니다.\n","\n","결과를 보면 $\\mathbf{x}_0$는 잘 복원이 되지만 잡음이 추가된 $\\mathbf{x}_t$는 잘 복원하지 못하는 것을 알 수 있습니다. 이 결과로 부터 가우시안 노이즈에서 노이즈를 제거하여 잠재변수로 만들어주는 노이즈 제거 모델이 있으면 이 모델과 VAE를 함께 사용하여 이미지를 생성할 수 있다는 것을 확실히 이해할 수 있습니다."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":184},"executionInfo":{"elapsed":485,"status":"ok","timestamp":1736235899061,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"rJ0XEI3LZkV0","outputId":"ed982db7-b255-4143-81e7-274d65dc141d"},"outputs":[{"name":"stdout","output_type":"stream","text":["torch.Size([6, 3, 16, 16])\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["# 원본 잠재변수에 잡음이 추가된 xt를 디코딩\n","# [en] Decode xt, the original latent variables with added noise\n","predictions = vae.decode(torch.tensor(x_ts).to(device))\n","print(predictions.shape)\n","\n","plt.imshow(predictions.permute(2, 0, 3, 1).reshape(IMAGE_SIZE, -1, 3).cpu().detach().numpy().clip(0,1))\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"YUa4ReWq2ZaL"},"source":["### Convolution Block\n","\n","이미지 인코더와 디코더에 사용할 컨볼루션 레이어 블록을 정의 합니다. 다음 세종류의 블록으로 구성됩니다.\n","\n","- `UnetConv`: 입력 사이즈를 줄이지 않는 더블 컨볼루션 블록\n","- `UnetDownConv`: 입력 사이즈를 반으로 줄이는 더블 컨볼루션 블록\n","- `UnetUpConv`: 입력 사이즈를 두배로 늘리는 트리플 컨볼루션 블록\n","\n","각 컨볼루션 블록은 내부적으로 스킵 커넥션 구조를 가지고 있습니다. 이는 `ResidualConvBlock`이 담당합니다."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"kUSUeUl2ZkV0"},"outputs":[],"source":["class ResidualConvBlock(torch.nn.Module):\n","    def __init__(self, in_channels, out_channels, is_res = True):\n","        super().__init__()\n","\n","        # Check if input and output channels are the same for the residual connection\n","        self.same_channels = in_channels == out_channels\n","\n","        # Flag for whether or not to use residual connection\n","        self.is_res = is_res\n","\n","        # First convolutional layer\n","        self.conv1 = torch.nn.Sequential(\n","            # 3x3 kernel with stride 1 and padding 1\n","            torch.nn.Conv2d(in_channels, out_channels, 3, 1, 1),\n","            torch.nn.BatchNorm2d(out_channels),   # Batch normalization\n","            torch.nn.GELU(),   # GELU activation function\n","        )\n","\n","        # Second convolutional layer\n","        self.conv2 = torch.nn.Sequential(\n","            # 3x3 kernel with stride 1 and padding 1\n","            torch.nn.Conv2d(out_channels, out_channels, 3, 1, 1),\n","            torch.nn.BatchNorm2d(out_channels),   # Batch normalization\n","            torch.nn.GELU(),   # GELU activation function\n","        )\n","\n","    def forward(self, x):\n","        # If using residual connection\n","        if self.is_res:\n","            # Apply first convolutional layer\n","            x1 = self.conv1(x)\n","\n","            # Apply second convolutional layer\n","            x2 = self.conv2(x1)\n","\n","            # If input and output channels are the same, add residual connection directly\n","            if self.same_channels:\n","                out = x + x2\n","            else:\n","                # If not, apply a 1x1 convolutional layer\n","                # to match dimensions before adding residual connection\n","                shortcut = torch.nn.Conv2d(x.shape[1], x2.shape[1],\n","                                     kernel_size=1, stride=1, padding=0).to(x.device)\n","                out = shortcut(x) + x2\n","            # print(f\"resconv forward: x {x.shape}, x1 {x1.shape}, x2 {x2.shape}, out {out.shape}\")\n","\n","            # Normalize output tensor, 분산을 1로 만들기 위해\n","            return out / 1.414 # sqrt(2)\n","\n","        # If not using residual connection, return output of second convolutional layer\n","        else:\n","            x1 = self.conv1(x)\n","            x2 = self.conv2(x1)\n","            return x2\n","\n","class UnetConv(torch.nn.Module):\n","    # 입력 사이즈를 줄이지 않는 더블 컨볼루션\n","    def __init__(self, in_channels, out_channels):\n","        super().__init__()\n","\n","        layers = [\n","            ResidualConvBlock(in_channels, out_channels),\n","            ResidualConvBlock(out_channels, out_channels)\n","        ]\n","\n","        # Use the layers to create a sequential model\n","        self.model = torch.nn.Sequential(*layers)\n","\n","    def forward(self, x):\n","        # Pass the input through the sequential model and return the output\n","        return self.model(x)\n","\n","class UnetDownConv(torch.nn.Module):\n","    # 입력 사이즈를 반으로 줄이는 더블 컨볼루션\n","    def __init__(self, in_channels, out_channels):\n","        super().__init__()\n","\n","        # Create a list of layers for the downsampling block\n","        # Each block consists of two ResidualConvBlock layers,\n","        # followed by a MaxPool2d layer for downsampling\n","        layers = [\n","            ResidualConvBlock(in_channels, out_channels),\n","            ResidualConvBlock(out_channels, out_channels),\n","            torch.nn.MaxPool2d(2)\n","        ]\n","\n","        # Use the layers to create a sequential model\n","        self.model = torch.nn.Sequential(*layers)\n","\n","    def forward(self, x):\n","        # Pass the input through the sequential model and return the output\n","        return self.model(x)\n","\n","class UnetUpConv(torch.nn.Module):\n","    # 입력 사이즈를 두배로 늘리는 트리플 컨볼루션\n","    def __init__(self, in_channels, out_channels):\n","        super().__init__()\n","\n","        self.layers = torch.nn.ModuleList([\n","            torch.nn.ConvTranspose2d(in_channels, out_channels, kernel_size=2, stride=2),\n","            torch.nn.GroupNorm(out_channels//8, out_channels), # normalize\n","            torch.nn.GELU(),\n","            ResidualConvBlock(out_channels, out_channels),\n","            ResidualConvBlock(out_channels, out_channels),\n","        ])\n","\n","    def forward(self, x, output_size=None):\n","        for i, layer in enumerate(self.layers):\n","            if i == 0:\n","                # 첫번째 컨볼루션은 이미지 사이즈를 줄이는데\n","                # 외부에서 넘겨준 사이즈에 맞게 조정\n","                x = layer(x, output_size=output_size)\n","            else:\n","                # 나머지 레이어는 그냥 진행하면 됨\n","                x = layer(x)\n","\n","        return x"]},{"cell_type":"markdown","metadata":{"id":"IBWqbl_02ZaL"},"source":["### Condition Encoder $\\tau_\\theta$"]},{"cell_type":"markdown","metadata":{"id":"TXjqSJ4l2ZaL","jp-MarkdownHeadingCollapsed":true},"source":["<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/ldm-figure3.png\" width=700>\n","\n","그림을 보면 모델은 각종 컨디션을 인코딩해서 모델에 공급할 컨디션 인코더 $\\tau_\\theta$가 필요합니다. DDPM 구현에서는 $\\tau_\\theta$에 해당하는 부분을  `Linear` 레이어로 모델 내부에 구현했지만 여기서는 따로 만들도록 하겠습니다.\n","\n","$\\tau_\\theta$는 특별한 구조없이 컨디션 벡터를 `Linear`레이어 두개로 피드포워드 시키는 MLP 입니다."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"lgWY8XOO2ZaL"},"outputs":[],"source":["class CondEncoder(torch.nn.Module):\n","    def __init__(self, input_dim, hidden_dim, output_dim):\n","        super().__init__()\n","\n","        self.ctx_emb_1 = torch.nn.Linear(in_features=input_dim, out_features=hidden_dim)\n","        self.ctx_emb_2 = torch.nn.Linear(in_features=hidden_dim, out_features=output_dim)\n","        self.relu = torch.nn.ReLU()\n","\n","    def forward(self, ctx):\n","        ctx = self.relu( self.ctx_emb_1(ctx) )\n","        ctx = self.relu( self.ctx_emb_2(ctx) )\n","\n","        return ctx\n"]},{"cell_type":"markdown","metadata":{"id":"cdPzeW-A2ZaL"},"source":["### LDM Class"]},{"cell_type":"markdown","metadata":{"id":"nuVvaIbU2ZaL"},"source":["이번에는 LDM 클래스를 정의합니다. 여기서는 $\\tau_\\theta(y)$를 처리하는 매커니즘을 제외하고는 DDPM과 완전히 동일합니다.\n","\n","LDM 모델의 손실은 다음처럼 정의됩니다.\n","\n","$$\n","L_{LDM} := \\mathbb{E}_{\\mathcal{E}(x), y, \\epsilon \\sim \\mathcal{N}(0,1), t}\n","\\left[\n","\\left\\|\n","\\epsilon - \\epsilon_\\theta(z_t, t, \\tau_\\theta(y))\n","\\right\\|_2^2\n","\\right]\n","$$\n","\n","모델은 잠재변수 $z_t$, 시간 단계 $t$, 컨디션 인코더 $\\tau_\\theta(y)$의 출력을 입력받아 노이즈를 출력합니다. 입력된 $\\tau_\\theta(y)$를 초기 잠재변수에 채널 방향으로 concat할지 컨볼루션 블록의 출력 특징맵에 크로스 어텐션할지에 따라 동작 방식이 달라지게 됩니다.\n","\n","코드를 살펴보기 전에 이미지 데이터와 컨디션 임베딩 벡터 간에 크로스 어텐션이 어떻게 작동하는지 확인해보도록 하겠습니다.\n"]},{"cell_type":"markdown","metadata":{"id":"Tdws3Dvo2ZaL"},"source":["#### Cross attention"]},{"cell_type":"markdown","metadata":{"id":"qCh1Gj7K2ZaL"},"source":["컨디션 인코더 $\\tau_\\theta(y)$의 출력 차원은 $(M \\times d_{\\tau})$로 표시합니다. 여기서 $M$은 컨디션의 시퀀스 길이가 됩니다.\n","\n","$$\n","\\tau_{\\theta}(y) \\in \\mathbb{R}^{M \\times d_{\\tau}}\n","$$\n","\n","예를 들어 이미지 생성을 위한 컨디션 문장이 \"brave hero\"이고 공백을 기준으로 토큰화 한다면 $M=2$입니다. $d_\\tau$는 한 토큰이 임베딩된 임베딩 벡터의 길이입니다. $\\tau_{\\theta}(y)$를 이미지로 만들어진 텐서에 컨디션으로 주입해야 되기 때문에 $\\tau_{\\theta}(y)$가 어텐션에서 키와 벨류가 됩니다.\n","\n","쿼리는 U-Net을 통과하는 특징맵이 될텐데 이를 원 논문에서 $\\varphi_i(z_t)$로 표현합니다. 여기서 $t$는 노이즈의 시간단계를 나타내고 $i$는 U-Net의 레이어 번호입니다. 즉 $i$번째 레이어의 출력입니다. 모양은 다음과 같고\n","\n","$$\n","\\varphi_i(z_t) \\in \\mathbb{R}^{N \\times d^{i}_{\\epsilon}}\n","$$\n","\n","$N$은 특징맵의 시퀀스 길이, $d^{i}_{\\epsilon}$은 $i$번째 노이즈 제거 레이어가 출력하는 특징맵의 채널 수 입니다. 이를 그림으로 나타내면 다음과 같습니다. 그림에서 $B$는 미니 배치 사이즈를 나타냅니다."]},{"cell_type":"markdown","metadata":{"id":"xjaMh0bV2ZaL"},"source":["\n","<div style=\"text-align: center;\">\n","<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/featuremap-tau.png\" width=950 align=\"center\">\n","</div>\n"]},{"cell_type":"markdown","metadata":{"id":"tXgL6Kw02ZaL"},"source":["특징맵은 3차원 텐서인데 이를 어텐션 레이어에 입력하기 위해 아래 그림처럼 공간spacial 차원을 펼치게 됩니다. 원 논문에서 아래 문구를 읽을 수 있습니다.\n","\n","> $\\varphi_i(z_t)$ denotes a (flattened) intermediate representation of the UNet implementing $\\epsilon_\\theta$\n","\n","이를 그림으로 나타내면 다음과 같습니다."]},{"cell_type":"markdown","metadata":{"id":"G3iKlL_g2ZaL"},"source":["\n","<div style=\"text-align: center;\">\n","<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/flatten-featuremap.png\" width=900>\n","</div>\n","\n"]},{"cell_type":"markdown","metadata":{"id":"C88zjGG02ZaM"},"source":["이렇게 잠재변수에 대한 특징맵을 어텐션 레이어에 입력할 준비를 마칩니다.\n","\n","어텐션 레이어는 내부에 아래와 같은 변환 가중치를 가지고 있습니다.\n","\n","$$\n","W^{(i)}_Q \\in \\mathbb{R}^{d \\times d^i_\\epsilon}\n","$$\n","\n","$$\n","W^{(i)}_K \\in \\mathbb{R}^{d \\times d_\\tau}\n","$$\n","\n","$$\n","W^{(i)}_V \\in \\mathbb{R}^{d \\times d_\\tau}\n","$$\n","\n","이 가중치들을  $\\varphi_i(z_t)$, $\\tau_{\\theta}(y)$에 곱해 $Q$, $K$, $V$를 만들게 됩니다.\n","\n","$$\n","Q =  \\varphi_i(z_t) {W^{(i)}_Q}^T, \\qquad (N \\times d^{i}_{\\epsilon}) \\times  (d^i_\\epsilon \\times d) = (N \\times d)\n","$$\n","\n","쿼리에 대한 계산은 위와 같고 이를 그림으로 표현하면 다음과 같습니다.\n","\n","<div style=\"text-align: center;\">\n","<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/Q.png\" width=500>\n","</div>\n","\n","나머지 키와 벨류도 동일하게 계산합니다.\n","\n","$$\n","K =  \\tau_{\\theta}(y) {W^{(i)}_K}^T,  \\qquad (M \\times d_\\tau) \\times (d_\\tau \\times d) = (M \\times d)\n","$$\n","\n","$$\n","V =  \\tau_{\\theta}(y) {W^{(i)}_V}^T,  \\qquad (M \\times d_\\tau) \\times (d_\\tau \\times d) = (M \\times d)\n","$$\n","\n","키와 벨류에 대한 그림 표현입니다.\n","\n","<div style=\"text-align: center;\">\n","<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/KV.png\" width=500>\n","</div>\n"]},{"cell_type":"markdown","metadata":{"id":"mFyqAtr_2ZaM"},"source":["쿼리와 키로부터 $N \\times M$인 어텐션 행렬을 계산할 수 있는데 이 행렬에는 네트워크가 출력하는 피처맵의 위치가 컨디션 시퀀스의 어느 부분과 관련이 높은지 기록되어 있습니다.\n","\n","\n","<div style=\"text-align: center;\">\n","<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/attn-matrix.png\" width=800>\n","</div>\n","\n","\n","\n","이 어텐션 행렬을 다시 벨류 $V$에 곱하면 쿼리의 각 위치마다 벨류를 조합한 벡터로 만들어지는 어텐션 헤드가 얻어집니다.\n","\n","<div style=\"text-align: center;\">\n","<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/attn-head.png\" width=550>\n","</div>\n","\n","계산된 여러개의 어텐션 헤드를 이어 붙인 후 마지막 출력으로 만들기 위해 $W^{(i)}_O$를 곱해 최종 어텐션 결과를 만들게 됩니다.\n","\n","\n","<div style=\"text-align: center;\">\n","<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/attn-result.png\" width=800>\n","</div>\n"]},{"cell_type":"markdown","metadata":{"id":"9refhdWP7cxt"},"source":["이렇게 계산된 어텐션 결과의 각 행은 U-Net 특징맵의 각 위치를 나타내고 그 행에는 컨디션의 각 토큰이 조합된 결과가 들어있습니다. 그림에서 초록색 벡터는 특징맵의 제일 처음, 좌표상으로 (0,0)인 위치에 잘 매치되는 컨디션의 각 토큰이 조합된 벡터들인 것입니다.\n","\n","이렇게 계산된 어텐션 결과를 원래 특징맵 $\\varphi_i(z_t)$에 더하고 모양을 바꿔 다시 원래 모양으로 돌려놓습니다.\n","\n","<div style=\"text-align: center;\">\n","<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/add-attn.png\" width=850>\n","</div>"]},{"cell_type":"markdown","metadata":{"id":"M8hSewtMOjjo"},"source":["지금까지 논의를 간단하게 코드로 테스트합니다. 코드에서 $B=1$, $N=4$, $M=1$, $d_\\tau=d_\\epsilon = d=5$입니다."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":317,"status":"ok","timestamp":1736345804052,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"WA4dL0ZzOPU2","outputId":"eb2155e9-b122-4168-8f0f-ba0abca9aa13"},"outputs":[{"name":"stdout","output_type":"stream","text":["tensor([[[ 0.2000, -0.0817, -0.2757,  0.1270,  0.2358],\n","         [ 0.2000, -0.0817, -0.2757,  0.1270,  0.2358],\n","         [ 0.2000, -0.0817, -0.2757,  0.1270,  0.2358],\n","         [ 0.2000, -0.0817, -0.2757,  0.1270,  0.2358]]],\n","       grad_fn=<AddBackward0>)\n","torch.Size([1, 4, 5]) torch.Size([1, 1, 5])\n","tensor([[[ 0.2000, -0.0817, -0.2757,  0.1270,  0.2358],\n","         [ 0.2000, -0.0817, -0.2757,  0.1270,  0.2358],\n","         [ 0.2000, -0.0817, -0.2757,  0.1270,  0.2358],\n","         [ 0.2000, -0.0817, -0.2757,  0.1270,  0.2358]]],\n","       grad_fn=<TransposeBackward0>)\n","tensor([[[1.],\n","         [1.],\n","         [1.],\n","         [1.]]], grad_fn=<MeanBackward1>)\n"]}],"source":["B = 1 # mini-batch size\n","N = 4 # feature map spacial size, assume feature map (2x2)\n","M = 1 # condition token length\n","d_tau = d_e = d = 5 # attention vector size\n","\n","mha = torch.nn.MultiheadAttention(embed_dim=d, num_heads=1, batch_first=True)\n","\n","# feature map\n","phi = torch.rand(B, N, d_e)\n","\n","# condition encoding\n","tau = torch.rand(B, M, d_tau)\n","\n","# Decompose the weights inside the multi-head attention layer\n","Wq = mha.in_proj_weight[:d]\n","Wk = mha.in_proj_weight[d:2*d]\n","Wv = mha.in_proj_weight[2*d:]\n","bq = mha.in_proj_bias[:d]\n","bk = mha.in_proj_bias[d:2*d]\n","bv = mha.in_proj_bias[2*d:]\n","Wo = mha.out_proj.weight\n","bo = mha.out_proj.bias\n","\n","# Transform into Q, K, and V\n","Q = torch.matmul(phi, Wq.T) + bq\n","K = torch.matmul(tau, Wk.T) + bk\n","V = torch.matmul(tau, Wv.T) + bv\n","\n","# Compute attention heads\n","attn_weight = F.softmax(torch.matmul(Q, K.permute(0,2,1)) / np.sqrt(d), dim=-1)\n","head = torch.matmul(attn_weight, V)\n","\n","# Atten result\n","attn_output = torch.matmul(head, Wo.T) + bo\n","print(attn_output)\n","\n","print(phi.shape, tau.shape)\n","#                               Q    K    V\n","attn_output, attn_matrix = mha(phi, tau, tau)\n","\n","print(attn_output)\n","print(attn_matrix)"]},{"cell_type":"markdown","metadata":{"id":"Dk516ocNQgjp"},"source":["파이토치 `MultiheadAttention` 계산 결과와 직접 계산한 결과가 일치합니다. 그리고 어텐션 행렬은 모두 1로 채워진 행렬입니다. 이 행렬은 컨디션의 하나뿐인 토큰에 대한 임베딩 벡터가 특징맵의 모든 행에 더해지는 결과를 낳게됩니다. 현재 데이터 셋도 이미지당 한 단어로 레이블이 구성되므로 위 예처럼 작동할 것입니다. 위 코드에서 $M$을 2이상으로 만들면 두 개의 임베딩 벡터가 어텐션 행렬로 조합되어 특징맵 각 위치에 더해지게 될 것 입니다. 직접 실험해보시길 바라겠습니다.\n","\n","이상의 내용을 LDM 클래스에 적용합니다. 모델 구조는 아래 그림과 같습니다. 구조는 간단하기 때문에 어텐션 매커니즘만 잘 이해한다면 쉽게 이해할 수 있습니다."]},{"cell_type":"markdown","metadata":{"id":"Vc7BLrXeRxjC"},"source":["<div style=\"text-align: center;\">\n","<img src=\"https://raw.githubusercontent.com/metamath1/stable-diffusion-nano/main/assets/ldm.png\">\n","</div>"]},{"cell_type":"markdown","metadata":{"id":"WJomxRcbRxjC"},"source":["모델은 노이즈를 예측하는 방식으로 학습되며 컨디션 벡터를 모양 바꿔 입력에 concat 시키거나 각 특징맵으로 어텐션 합니다. 소스 코드에는 어텐션 레이어가 4개 있으며 각 conv 레이어가 출력하는 특징맵에 컨디션 벡터를 입히게 됩니다.\n","\n","우측 상단 LDM 논문의 그림 3과 구현할 네트워크의 구조를 비교해보세요. 네트워크가 충분히 크지 않은 점만 제외하면 거의 모든 부분이 동일합니다!"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"DlwrYXW02ZaM"},"outputs":[],"source":["class LDM(torch.nn.Module):\n","    def __init__(self, switch):\n","        super().__init__()\n","\n","        self.switch = switch\n","\n","        self.time_emb = torch.nn.Sequential(\n","            torch.nn.Linear(in_features=1, out_features=64),\n","            torch.nn.ReLU(),\n","            torch.nn.Linear(in_features=64, out_features=128),\n","            torch.nn.ReLU()\n","        )\n","\n","        if switch == \"QKV\":\n","            #########################################\n","            # 컨디션을 어텐션으로 처리하는 경우\n","            # [en] For attention conditioning\n","            #########################################\n","\n","            # 컨디션 인코더의 출력은 암의로 설정하면 됨\n","            # 주의할 점은 컨디션 인코딩 벡터의 길이가 아래 정의될 어텐션 레이어의 kdim, vdim과 같아야 함\n","            # [en] The output of the condition encoder can be set arbitrarily.\n","            # Note that the length of the condition encoding vector must match the kdim and vdim\n","            # defined in the attention layer below.\n","            self.tau = CondEncoder(CTX_LEN, 64, 128)\n","\n","            # 멀티헤드어텐션 레이어가 필요\n","            # 첫 conv 레이어의 입력 채널은 잠재변수의 채널수\n","            # [en] When handling conditions with attention:\n","            # - A multi-head attention layer is required.\n","            # - The input channels of the first conv layer must match the number of channels in the latent variables.\n","            self.mha1 = torch.nn.MultiheadAttention(embed_dim=64, kdim=128, vdim=128, num_heads=4, batch_first=True)\n","            self.mha2 = torch.nn.MultiheadAttention(embed_dim=128, kdim=128, vdim=128, num_heads=4, batch_first=True)\n","            self.mha3 = torch.nn.MultiheadAttention(embed_dim=128, kdim=128, vdim=128, num_heads=4, batch_first=True)\n","            self.mha4 = torch.nn.MultiheadAttention(embed_dim=64, kdim=128, vdim=128, num_heads=4, batch_first=True)\n","\n","            self.conv1 = UnetConv(in_channels=LATENT_EMB_DIM, out_channels=64)\n","        elif switch == \"CONCAT\":\n","            #########################################\n","            # 컨디션을 concat으로 처리하는 경우\n","            # [en] For concat conditioning\n","            #########################################\n","\n","            # 컨디션 인코더의 출력은 잠재변수 높이*잠재변수 너비로 설정하여\n","            # 잠재변수의 채널 방향으로 concat\n","            # [en] The output of the condition encoder is set to the height × width of the latent variables\n","            # and concatenated along the channel direction of the latent variables.\n","            self.tau = CondEncoder(CTX_LEN, 32, LATENT_HEIGHT*LATENT_WIDTH)\n","\n","            # 멀티헤드어텐션 레이어가 필요없음\n","            # 첫 conv 레이어의 입력 채널은 잠재변수의 채널수+1\n","            # [en] When handling conditions with concat:\n","            # - No multi-head attention layer is needed.\n","            # - The input channels of the first conv layer must equal the number of latent variable channels + 1.\n","            self.conv1 = UnetConv(in_channels=LATENT_EMB_DIM+1, out_channels=64)\n","        else:\n","            raise NotImplementedError(\"The switch must be either 'QKV' or 'CONCAT'. \")\n","\n","        self.conv2 = UnetConv(in_channels=64, out_channels=128)\n","        self.down_conv = UnetDownConv(in_channels=128, out_channels=256)\n","\n","        self.up_conv = UnetUpConv(in_channels=256, out_channels=128)\n","        self.conv3 = UnetConv(in_channels=128, out_channels=64)\n","        self.conv4 = torch.nn.Sequential(\n","            torch.nn.Conv2d(in_channels=128, out_channels=64, kernel_size=3, padding=1),\n","            torch.nn.GroupNorm(8, 64), # normalize, 64채널을 8개 그룹으로 나눠서 노멀라이즈\n","            torch.nn.GELU(),\n","            torch.nn.Conv2d(in_channels=64, out_channels=LATENT_EMB_DIM, kernel_size=3, padding=1)\n","        )\n","\n","        self.relu = torch.nn.ReLU()\n","\n","    def attention(self, mha, z, tau):\n","        # mha: pytorch multiheadattention layer\n","        # z: (B, dε, sqrt(N), sqrt(N))\n","        # tau: (B, dτ)\n","        batch_size = z.shape[0]\n","        tau_ = tau.reshape(batch_size, 1, -1) # (B, dτ) -> (B, M, dτ)\n","        batch_ch_size = z.shape[:2] # (B, dε)\n","        latent_size = z.shape[2:] # (sqrt(N), sqrt(N))\n","\n","        z = z.reshape(*batch_ch_size, -1) # (B, dε, sqrt(N), sqrt(N)) -> (B, dε, N)\n","        z = z.permute(0,2,1) # (B, N, dε)\n","\n","        # The input order for multi-head attention is Q, K, V.\n","        # Q is the feature map output from the CNN.\n","        # K and V are the condition encodings generated by tau.\n","        attn_ctx, _ = mha(z, tau_, tau_) # (B, N, dε)\n","        z = z + attn_ctx # (B, N, dε)+(B, N, dε) -> (B, N, dε)\n","\n","        # (B, N, dε) -> (B, dε, N) -> (B, dε, sqrt(N), sqrt(N))\n","        z = z.permute(0,2,1).reshape(*batch_ch_size, *latent_size)\n","\n","        return z\n","\n","    def forward(self, z, t, y):\n","        # z: (B, C, H, W)\n","        # t: (B, 1)\n","        # y: (B, 5)\n","        batch_size = t.shape[0]\n","\n","        # time embedding\n","        t = self.time_emb(t) # (N,1) -> (B, 128)\n","        t = t.reshape(batch_size, -1, 1, 1) # (B, 128, 1, 1)\n","\n","        # condition embedding\n","        tau = self.tau(y)\n","\n","        # add condition embedding for concat mode\n","        if self.switch == \"CONCAT\":\n","            # (B, LATENT_WIDTH*LATENT_HEIGHT) -> (B, 1, LATENT_HEIGHT, LATENT_WIDTH)\n","            tau = tau.reshape(tau.shape[0], 1, LATENT_HEIGHT, LATENT_WIDTH)\n","            z = torch.concat([z, tau], axis=1)\n","\n","        # conv\n","        z = self.conv1(z)  # (B, LATENT_EMB_DIM(+1), 8, 8)->(B, 64, 8, 8)\n","        # add condition embedding for attention mode\n","        if self.switch == \"QKV\":\n","            z = self.attention(self.mha1, z, tau)\n","        z_64 = z.clone()\n","        size_64 = z_64.shape\n","\n","        # conv\n","        z = self.conv2(z) # (B, 64, 8, 8)->(B, 128, 8, 8)\n","        # add time embedding\n","        z = z + t\n","        # add condition embedding for attention mode\n","        if self.switch == \"QKV\":\n","            z = self.attention(self.mha2, z, tau)\n","\n","        # down conv\n","        z =  self.down_conv(z) # (B, 128, 8, 8) -> (B, 256, 4, 4)\n","\n","        # up conv\n","        z = self.up_conv(z, output_size=size_64) # (B, 256, 4, 4) -> (B, 128, 8, 8)\n","        # add condition embedding for attention mode\n","        if self.switch == \"QKV\":\n","            z = self.attention(self.mha3, z, tau)\n","\n","        # conv\n","        z = self.conv3(z) # (B, 128, 8, 8) -> (B, 64, 8, 8)\n","        # add condition embedding for attention mode\n","        if self.switch == \"QKV\":\n","            z = self.attention(self.mha4, z, tau)\n","\n","        # skip connection and conv\n","        z = torch.concat([z, z_64], axis=1) # (B, 64, 8, 8)+(B, 64, 8, 8) -> (B, 128, 8, 8)\n","        out = self.conv4(z) # (B, 128, 8, 8) -> (B, 64, 8, 8) -> (B, LATENT_EMB_DIM, 8, 8)\n","\n","        return out"]},{"cell_type":"markdown","metadata":{"id":"v-j5wlOd2ZaM"},"source":["`SWITCH` 변수를 `CONCAT` 또는 `QKV`로 세팅하고 모델을 생성합니다."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"rwOlYTpOZkV0"},"outputs":[],"source":["SWITCH = \"QKV\" # \"QKV\" or \"CONCAT\"\n","\n","model = LDM(SWITCH)\n","model = model.to(device)"]},{"cell_type":"markdown","metadata":{"id":"8SmJrhhySQnL"},"source":["#### Forward Test\n","\n","생성된 모델에 적당히 샘플을 입력하고 잘 작동하는지 확인합니다. 모델의 출력은 (B, 4, 8, 8)이 되어야 합니다."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":1432,"status":"ok","timestamp":1736235918918,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"_qfAaJCrZkV0","outputId":"29d5f4da-905c-4cf5-aa71-18734ca6aa06"},"outputs":[{"name":"stdout","output_type":"stream","text":["torch.Size([256, 4, 8, 8])\n"]}],"source":["output = model(\n","    samples[0].to(device), # image\n","    samples[3].reshape(-1,1).float().to(device), # time\n","    samples[4].to(device) # condition\n","    )\n","\n","print(output.shape)"]},{"cell_type":"markdown","metadata":{"id":"Yf8FeKPrEsTR"},"source":["### Training"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"odLba23YZkV0"},"outputs":[],"source":["epochs = 20\n","learning_rate = 0.001"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"dulojRZTZkV0"},"outputs":[],"source":["loss_func = torch.nn.MSELoss()\n","optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"O52MqLOm2ZaO"},"outputs":[],"source":["# create the model_weights directory inside the `output_dir`\n","# for storing autoencoder weights\n","model_weights_dir = os.path.join(output_dir, f\"LDM_{SWITCH}_VAE_{LATENT_EMB_DIM}\")\n","os.makedirs(model_weights_dir, exist_ok=True)\n","\n","# define model_weights path including best weighs\n","MODEL_BEST_WEIGHTS_PATH = os.path.join(model_weights_dir, \"best_ldm.pt\")"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":1942664,"status":"ok","timestamp":1736237873101,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"PDQd68P-ZkV0","outputId":"44a9fbb7-ef9e-4bc3-d72e-261821dc78c7"},"outputs":[{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 19.74it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch:  1: loss:0.4017, mae:0.4681\n","[EPOCH: 1] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.09it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch:  2: loss:0.3046, mae:0.3934\n","[EPOCH: 2] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.30it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch:  3: loss:0.2727, mae:0.3664\n","[EPOCH: 3] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.22it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch:  4: loss:0.2517, mae:0.3483\n","[EPOCH: 4] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.24it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch:  5: loss:0.2332, mae:0.3319\n","[EPOCH: 5] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.52it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch:  6: loss:0.2186, mae:0.3185\n","[EPOCH: 6] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.40it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch:  7: loss:0.2076, mae:0.3091\n","[EPOCH: 7] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.18it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch:  8: loss:0.1973, mae:0.2997\n","[EPOCH: 8] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.13it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch:  9: loss:0.1889, mae:0.2915\n","[EPOCH: 9] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.19it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 10: loss:0.1823, mae:0.2856\n","[EPOCH: 10] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.20it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 11: loss:0.1754, mae:0.2790\n","[EPOCH: 11] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.14it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 12: loss:0.1705, mae:0.2750\n","[EPOCH: 12] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:16<00:00, 20.67it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 13: loss:0.1644, mae:0.2690\n","[EPOCH: 13] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.38it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 14: loss:0.1592, mae:0.2643\n","[EPOCH: 14] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.10it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 15: loss:0.1546, mae:0.2601\n","[EPOCH: 15] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.53it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 16: loss:0.1506, mae:0.2565\n","[EPOCH: 16] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.46it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 17: loss:0.1467, mae:0.2527\n","[EPOCH: 17] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.33it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 18: loss:0.1429, mae:0.2494\n","[EPOCH: 18] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.52it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 19: loss:0.1381, mae:0.2451\n","[EPOCH: 19] SAVE BEST MODEL!!\n"]},{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 350/350 [00:17<00:00, 20.57it/s]\n"]},{"name":"stdout","output_type":"stream","text":["Epoch: 20: loss:0.1359, mae:0.2429\n","[EPOCH: 20] SAVE BEST MODEL!!\n"]}],"source":["losses = []\n","best_loss = float(\"inf\")\n","\n","for e in range(epochs):\n","    epoch_loss = 0.0\n","    epoch_mae = 0.0\n","\n","    for i, data in enumerate(tqdm(train_loader)):\n","        x_0, x_t, eps, t, ctx, label = data\n","        x_t = x_t.to(device)\n","        eps = eps.to(device)\n","        t = t.to(device)\n","        ctx = ctx.to(device)\n","\n","        optimizer.zero_grad()\n","        eps_theta = model(x_t, t.reshape(-1,1).float(), ctx)\n","        loss = loss_func(eps_theta, eps)\n","        loss.backward()\n","        optimizer.step()\n","\n","        with torch.no_grad():\n","            epoch_loss += loss.item()\n","            epoch_mae += torch.nn.functional.l1_loss(eps_theta, eps)\n","\n","    epoch_loss /= len(train_loader)\n","    epoch_mae /= len(train_loader)\n","\n","    print(f\"Epoch: {e+1:2d}: loss:{epoch_loss:.4f}, mae:{epoch_mae:.4f}\")\n","\n","    if epoch_loss <= best_loss:\n","        best_loss = epoch_loss\n","        torch.save({\"ldm\": model.state_dict()}, MODEL_BEST_WEIGHTS_PATH)\n","        print(f\"[EPOCH: {e+1}] SAVE BEST MODEL!!\")\n","\n","    losses.append(epoch_loss)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":430},"executionInfo":{"elapsed":1088,"status":"ok","timestamp":1736237878466,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"IBOEcRqdZkV0","outputId":"489112a2-b21f-4f17-f637-b84037a674d2"},"outputs":[{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["plt.plot(losses, 'o-')\n","plt.xlabel('epochs')\n","plt.ylabel('loss')\n","plt.show()"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"k4F_2BiAZkV0"},"outputs":[],"source":["# model load\n","# MODEL_BEST_WEIGHTS_PATH\n","# 저장된 모델 상태를 불러옵니다.\n","model_state = torch.load(MODEL_BEST_WEIGHTS_PATH, weights_only=True)\n","\n","# 모델 상태를 현재 모델에 로드합니다.\n","model.load_state_dict(model_state['ldm'])\n","model.eval();"]},{"cell_type":"markdown","metadata":{"id":"BroUfLsi2ZaO"},"source":["### Sampling"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"akNTt2UkZkV0"},"outputs":[],"source":["alpha = MyDataset.alpha.to(device)\n","alpha_bar = MyDataset.alpha_bar.to(device)\n","beta = MyDataset.beta.to(device)\n","T = MyDataset.T"]},{"cell_type":"markdown","metadata":{"id":"FgZaC_Jl2ZaP"},"source":["잠재 변수와 모양이 같은 노이즈 32개를 준비합니다. 이 노이즈가 32개의 이미지로 변환될 텐데 8개씩 끊어서 `hero`, `side-facing`, `food`, `spell` 순으로 컨디션을 입력하겠습니다."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"LZ3ASXFkZkV3"},"outputs":[],"source":["# 샘플링 단계동안 생성된 이미지를 일정 간격마다 저장할 리스트를 준비\n","N = 32 # 모델에 입력할 샘플 개수\n","\n","# noise\n","x = torch.randn(size=(N, LATENT_EMB_DIM, LATENT_HEIGHT, LATENT_WIDTH)).to(device)\n","\n","# condition\n","ctx = torch.zeros(N, 5).to(device).float()\n","for i, t in enumerate([0, 4, 2, 3]):\n","    s = i + 7*i\n","    e = s + 8\n","    ctx[s:e, t] = 1."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":449},"executionInfo":{"elapsed":5424,"status":"ok","timestamp":1736238014405,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"6A6QOfjvZkV3","outputId":"74f92aee-81ba-47a5-a5b1-b5507b2c86ae"},"outputs":[{"name":"stderr","output_type":"stream","text":["100%|██████████████████████████████████████████████████████████████████████| 500/500 [00:05<00:00, 99.29it/s]\n"]}],"source":["intermediate = []\n","save_rate = 20\n","\n","with torch.no_grad():  # 그라디언트 추적 비활성화\n","    for t in tqdm(range(T, 0, -1)):\n","        if t > 1:\n","            z = torch.randn(size=(N, LATENT_EMB_DIM, LATENT_HEIGHT, LATENT_WIDTH)).to(device)\n","        else:\n","            z = torch.zeros((N, LATENT_EMB_DIM, LATENT_HEIGHT, LATENT_WIDTH)).to(device)\n","\n","        t_torch = torch.tensor([[t]]*N, dtype=torch.float32).to(device)\n","\n","        eps_theta = model(x, t_torch, ctx)\n","\n","        x = (1 / torch.sqrt(alpha[t])) * \\\n","            (x - ((1-alpha[t])/torch.sqrt(1-alpha_bar[t]))*eps_theta) + torch.sqrt(beta[t])*z\n","\n","        if t % save_rate == 0 or t == T or t < 8:\n","            intermediate.append(x)\n","\n","        # Clean up memory\n","        del z, t_torch, eps_theta\n","        torch.cuda.empty_cache()\n"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":100},"executionInfo":{"elapsed":6,"status":"ok","timestamp":1736238020460,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"qRu4NVs1ZkV4","outputId":"41a61bcc-ea3e-4d52-eb13-b56b13e91f18"},"outputs":[{"name":"stdout","output_type":"stream","text":["torch.Size([32, 3, 16, 16])\n","(16, 512, 3)\n"]},{"data":{"image/png":"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","text/plain":["<Figure size 640x480 with 1 Axes>"]},"metadata":{},"output_type":"display_data"}],"source":["predictions = vae.decode(x)\n","print(predictions.shape)\n","\n","pred = predictions.permute(2, 0, 3, 1).reshape(IMAGE_SIZE, -1, 3).cpu().detach().numpy().clip(0,1)\n","print(pred.shape) # (16, 512, 3) -> (16*4, 16*8, 3)\n","\n","plt.imshow(pred)\n","plt.show()"]},{"cell_type":"markdown","metadata":{"id":"WfRH_3i72ZaP"},"source":["노이즈 제거 과정에서 저장된 중간 단계 잠재 변수를 VAE로 모두 디코딩하고 이를 애니메이션과 gif파일로 구성합니다."]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":473,"status":"ok","timestamp":1736238023355,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"w3hGXiwcZkV4","outputId":"d958ad7a-7936-4216-d814-caa94cacd637"},"outputs":[{"data":{"text/plain":["(32, 32, 3, 16, 16)"]},"execution_count":74,"metadata":{},"output_type":"execute_result"}],"source":["# 노이즈 제거 과정에서 담아둔 단계별 잠재 변수를 단계별로 디코딩하고\n","# 아래쪽 애니메이션 만들 때 사용\n","intermediate_img = []\n","\n","for frame in intermediate:\n","    # 디코딩된 이미지의 모임 (32, 3, 16, 16)\n","    predictions = vae.decode(frame)\n","    intermediate_img.append(predictions.detach().cpu().numpy())\n","\n","# [(32, 3, 16, 16), ..., (32, 3, 16, 16)] => (32, 32, 3, 16, 16)\n","intermediate_img = np.stack(intermediate_img)\n","\n","# (frame, sample, C, H, W)\n","# 32단계에서 32개의 이미지를 저장\n","# Save 32 images at step 32\n","intermediate_img.shape\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"yx1pPFoQZkV4"},"outputs":[],"source":["def unorm(x):\n","    # unity norm. results in range of [0,1]\n","    # assume x (h,w,3)\n","    xmax = x.max((0,1))\n","    xmin = x.min((0,1))\n","\n","    return (x - xmin) / (xmax - xmin)\n","\n","def norm_all(store, n_t, n_s):\n","    # runs unity norm on all timesteps of all samples\n","    nstore = np.zeros_like(store)\n","\n","    for t in range(n_t): # 32 프레임에\n","        for s in range(n_s): # 32 샘플에 대해서\n","            # 모든 프레임에 모든 이미지를 [0,1]로 노멀라이즈\n","            nstore[t,s] = unorm(store[t,s])\n","\n","    return nstore\n","\n","def plot_sample(x_gen_store, n_sample, nrows, save_dir, fn,  w, save=False):\n","    # x_gen_store:(frame, sample, C, H, W)\n","    ncols = n_sample//nrows\n","\n","    # change to Numpy image format (h,w,channels) vs (channels,h,w)\n","    sx_gen_store = np.moveaxis(x_gen_store, 2, 4)\n","\n","    # unity norm to put in range [0,1] for np.imshow\n","    # nsx_gen_store: (32, 32, 16, 16, 3)\n","    nsx_gen_store = norm_all(sx_gen_store, sx_gen_store.shape[0], n_sample)\n","\n","    # create gif of images evolving over time, based on x_gen_store\n","    fig, axs = plt.subplots(nrows=nrows, ncols=ncols, sharex=True, sharey=True,figsize=(ncols,nrows))\n","\n","    def animate_diff(i, store):\n","        plots = []\n","\n","        for row in range(nrows):\n","            for col in range(ncols):\n","                sample_no = (row*ncols)+col\n","                axs[row, col].clear()\n","                axs[row, col].set_xticks([])\n","                axs[row, col].set_yticks([])\n","\n","                if sample_no % ncols == 0:\n","                    label = LABEL_NAMES[np.argmax(ctx.cpu().numpy(), axis=1)[sample_no]]\n","                    axs[row, col].set_ylabel(label, rotation=90, labelpad=10)\n","                plots.append( axs[row, col].imshow( store[ i, sample_no ] ) )\n","\n","        return plots\n","\n","    ani = FuncAnimation(fig, animate_diff, fargs=[nsx_gen_store],\n","                        interval=200, blit=False, repeat=True, frames=nsx_gen_store.shape[0])\n","    fig.suptitle(f\"Conditional generation by {SWITCH}\", fontsize=16)\n","\n","    plt.close()\n","\n","    if save:\n","        file_path = os.path.join(save_dir, f\"{fn}_{SWITCH}_w{w}.gif\")\n","        ani.save(file_path, dpi=100, writer=PillowWriter(fps=w))\n","        print('saved gif at ' + file_path)\n","\n","    return ani"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":37981,"status":"ok","timestamp":1736238065429,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"3QbArcf2ZkV4","outputId":"8d132674-7331-45ee-be5c-079d366fd633"},"outputs":[{"name":"stdout","output_type":"stream","text":["saved gif at assets\\LDM_QKV_VAE_4\\ani_QKV_w5.gif\n"]}],"source":["ani_ddpm = plot_sample(intermediate_img, 32, 4, model_weights_dir, \"ani\", 5, True)"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":500,"output_embedded_package_id":"1Z1dwoAX8adDqZNt5fh7674vlWUFJQFoG"},"executionInfo":{"elapsed":48688,"status":"ok","timestamp":1736238114115,"user":{"displayName":"조준우","userId":"07581913480846489655"},"user_tz":-540},"id":"ruxD2fovZkV4","outputId":"be1abed8-d47c-4276-e0a9-e1a46bf92453"},"outputs":[{"output_type":"display_data","data":{"text/plain":"Output hidden; open in https://colab.research.google.com to view."},"metadata":{}}],"source":["from IPython.display import HTML\n","\n","HTML(ani_ddpm.to_jshtml())"]},{"cell_type":"markdown","metadata":{"id":"Petkq6qI2ZaR"},"source":["지금까지 LDM 모델을 구체적으로 어떻게 구현하는지 알아봤습니다. 이 저장소를 통해 이미지 생성에서 노이즈 제거, 멀티 헤드 어텐션이 어떻게 작동하는지 이해하셨길 바랍니다. [en] So far, we have explored how to implement the LDM model in detail. Through this repository, I hope you have gained an understanding of how noise removal, image generation, and multi-head attention work."]},{"cell_type":"code","execution_count":null,"metadata":{"id":"srahjRtNRxjG"},"outputs":[],"source":[]}],"metadata":{"accelerator":"GPU","colab":{"gpuType":"T4","machine_shape":"hm","provenance":[]},"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.5"}},"nbformat":4,"nbformat_minor":0}