KVQ-VAE.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "b9bb0fbc-5031-45ea-aa9e-24abe6e40715",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os\n",
    "os.environ['CUDA_VISIBLE_DEVICES'] = '1'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6fcd0ff9-63ea-43bd-9752-8bb10945573e",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/root/anaconda3/envs/pytorch/lib/python3.9/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n",
      "  from .autonotebook import tqdm as notebook_tqdm\n"
     ]
    }
   ],
   "source": [
    "from src.efficient_kan import KAN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "8bf01677-5b8a-42db-9ba9-4adf02aa9df0",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.optim as optim\n",
    "import torchvision\n",
    "import torchvision.transforms as transforms\n",
    "from torch.utils.data import DataLoader\n",
    "from torch.utils.data import Dataset\n",
    "import torch.nn.functional as F\n",
    "from tqdm import tqdm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "86d40206-fd5c-41dc-bbe0-7689fd5be909",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "id": "94912aa5-ca56-4a82-bc5e-7594f2bceea1",
   "metadata": {},
   "outputs": [],
   "source": [
    "config = {}\n",
    "config['input_dim'] = 1024*16\n",
    "config['batch_size'] = 64\n",
    "config['hidden_layers'] = [1024, 256]\n",
    "config['lr'] = 1e-3\n",
    "config['gamma'] = 0.9\n",
    "config['period'] = 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "3702b51b-4027-44c9-af39-4886b8da8d6c",
   "metadata": {},
   "outputs": [],
   "source": [
    "class kae_dataset(Dataset):\n",
    "    def __init__(self, num_data=100, input_dim=128):\n",
    "        super(kae_dataset, self).__init__()\n",
    "        self.num_data = num_data\n",
    "        self.target = []\n",
    "        for i in range(num_data):\n",
    "            scale = random.random()\n",
    "            phase_left = random.random() + 0.1\n",
    "            phase_right = random.random() + 0.1\n",
    "            x=np.arange(-phase_left*2*np.pi*config['period'],phase_right*2*np.pi*config['period'],(phase_right*2*np.pi+phase_left*2*np.pi)*config['period']/input_dim)\n",
    "            x=x.reshape(len(x),1)\n",
    "            y=scale * np.sin(x)\n",
    "            self.target.append(y)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        target = torch.from_numpy(self.target[index]).squeeze().unsqueeze(0).to(torch.float32)\n",
    "        return target\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self.target)\n",
    "\n",
    "trainset = kae_dataset(10000, config['input_dim'])\n",
    "valset = kae_dataset(100, config['input_dim'])\n",
    "trainloader = DataLoader(trainset, batch_size=config['batch_size'], shuffle=True)\n",
    "valloader = DataLoader(valset, batch_size=config['batch_size'], shuffle=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "2cddd415-6004-408a-b0d8-82c0453ed139",
   "metadata": {},
   "outputs": [],
   "source": [
    "class VectorQuantizer(nn.Module):\n",
    "    \"\"\"\n",
    "    Reference:\n",
    "    [1] https://github.com/deepmind/sonnet/blob/v2/sonnet/src/nets/vqvae.py\n",
    "    \"\"\"\n",
    "    def __init__(self,\n",
    "                 num_embeddings: int,\n",
    "                 embedding_dim: int,\n",
    "                 beta: float = 0.25):\n",
    "        super(VectorQuantizer, self).__init__()\n",
    "        self.K = num_embeddings\n",
    "        self.D = embedding_dim\n",
    "        self.beta = beta\n",
    "\n",
    "        self.embedding = nn.Embedding(self.K, self.D)\n",
    "        self.embedding.weight.data.uniform_(-1 / self.K, 1 / self.K)\n",
    "\n",
    "    def forward(self, latents):\n",
    "        # Compute L2 distance between latents and embedding weights\n",
    "        dist = torch.sum(latents ** 2, dim=1, keepdim=True) + \\\n",
    "               torch.sum(self.embedding.weight ** 2, dim=1) - \\\n",
    "               2 * torch.matmul(latents, self.embedding.weight.t())  # [BHW x K]\n",
    "\n",
    "        # Get the encoding that has the min distance\n",
    "        encoding_inds = torch.argmin(dist, dim=1).unsqueeze(1)  # [BHW, 1]\n",
    "\n",
    "        # Convert to one-hot encodings\n",
    "        device = latents.device\n",
    "        encoding_one_hot = torch.zeros(encoding_inds.size(0), self.K, device=device)\n",
    "        encoding_one_hot.scatter_(1, encoding_inds, 1)  # [BHW x K]\n",
    "\n",
    "        # Quantize the latents\n",
    "        quantized_latents = torch.matmul(encoding_one_hot, self.embedding.weight)  # [BHW, D]\n",
    "\n",
    "        # Compute the VQ Losses\n",
    "        commitment_loss = F.mse_loss(quantized_latents.detach(), latents)\n",
    "        embedding_loss = F.mse_loss(quantized_latents, latents.detach())\n",
    "\n",
    "        vq_loss = commitment_loss * self.beta + embedding_loss\n",
    "\n",
    "        # Add the residue back to the latents\n",
    "        quantized_latents = latents + (quantized_latents - latents).detach()\n",
    "\n",
    "        return quantized_latents, vq_loss  # [B x D x H x W]\n",
    "        \n",
    "class KVQ_VAE(torch.nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        layers_hidden,\n",
    "        input_dim,\n",
    "        K,\n",
    "        beta,\n",
    "    ):\n",
    "        super(KVQ_VAE, self).__init__()\n",
    "        self.layers_hidden = layers_hidden\n",
    "        self.input_dim = input_dim\n",
    "        self.K = K\n",
    "        self.beta = beta\n",
    "        self.encoder = KAN([input_dim, layers_hidden[0], layers_hidden[1]])\n",
    "        self.VQ = VectorQuantizer(self.K, layers_hidden[1], beta=self.beta)\n",
    "        self.decoder = KAN([layers_hidden[1], layers_hidden[0], input_dim])\n",
    "\n",
    "    def encode(self, input):\n",
    "        posterior_dist = self.encoder(input)\n",
    "\n",
    "        # Split the result into miu and sigma components\n",
    "        # of the latent Gaussian distribution\n",
    "\n",
    "        return posterior_dist\n",
    "\n",
    "    def decode(self, z):\n",
    "        priori_dist = self.decoder(z)\n",
    "        return priori_dist\n",
    "\n",
    "    def forward(self, input, **kwargs):\n",
    "        encoding = self.encode(input)\n",
    "        quantized_inputs, vq_loss = self.VQ(encoding)\n",
    "        return [self.decode(quantized_inputs), vq_loss]\n",
    "\n",
    "    def loss_function(self,\n",
    "                      input, \n",
    "                      ouput, \n",
    "                      vq_loss):\n",
    "\n",
    "        recons_loss = F.mse_loss(ouput, input)\n",
    "\n",
    "        loss = recons_loss + 10*vq_loss\n",
    "        return {'loss': loss,\n",
    "                'Reconstruction_Loss': recons_loss,\n",
    "                'VQ_Loss':vq_loss}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "d8f638a2-b178-443d-a807-49264b9a0eb4",
   "metadata": {},
   "outputs": [],
   "source": [
    "# Define model\n",
    "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
    "model = KVQ_VAE(layers_hidden=config['hidden_layers'], input_dim=config['input_dim'], K=1024, beta=20)\n",
    "model.to(device)\n",
    "# Define optimizer\n",
    "optimizer = optim.AdamW(model.parameters(), lr=config['lr'], weight_decay=1e-4)\n",
    "# Define learning rate scheduler\n",
    "scheduler = optim.lr_scheduler.ExponentialLR(optimizer, gamma=config['gamma'])\n",
    "\n",
    "# Define loss\n",
    "criterion = nn.MSELoss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "d87706c4-ef8e-44b0-976d-73812a5fb475",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 157/157 [00:08<00:00, 19.21it/s, loss=0.0976, lr=0.001, recon_loss=0.0749, vq_loss=0.00228]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Val Loss: 0.10498609393835068\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 157/157 [00:08<00:00, 19.58it/s, loss=0.0386, lr=0.0009, recon_loss=0.0313, vq_loss=0.000737]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 2, Val Loss: 0.051583174616098404\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 157/157 [00:07<00:00, 19.84it/s, loss=0.0305, lr=0.00081, recon_loss=0.017, vq_loss=0.00135]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 3, Val Loss: 0.04014810919761658\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 157/157 [00:07<00:00, 19.71it/s, loss=0.0226, lr=0.000729, recon_loss=0.0131, vq_loss=0.000951]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 4, Val Loss: 0.03453323617577553\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 157/157 [00:07<00:00, 20.23it/s, loss=0.0283, lr=0.000656, recon_loss=0.0154, vq_loss=0.00129] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 5, Val Loss: 0.034112850204110146\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 157/157 [00:07<00:00, 20.23it/s, loss=0.0348, lr=0.00059, recon_loss=0.0186, vq_loss=0.00162]\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 6, Val Loss: 0.03113653976470232\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 157/157 [00:07<00:00, 20.01it/s, loss=0.0243, lr=0.000531, recon_loss=0.0123, vq_loss=0.0012]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 7, Val Loss: 0.03292657807469368\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 157/157 [00:07<00:00, 19.66it/s, loss=0.0233, lr=0.000478, recon_loss=0.0118, vq_loss=0.00115] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 8, Val Loss: 0.031142178922891617\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 157/157 [00:07<00:00, 20.08it/s, loss=0.0221, lr=0.00043, recon_loss=0.0117, vq_loss=0.00105] \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 9, Val Loss: 0.031238263472914696\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 157/157 [00:07<00:00, 20.22it/s, loss=0.0267, lr=0.000387, recon_loss=0.0148, vq_loss=0.00118]  \n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 10, Val Loss: 0.03166843205690384\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(10):\n",
    "    # Train\n",
    "    model.train()\n",
    "    with tqdm(trainloader) as pbar:\n",
    "        for i, targets in enumerate(pbar):\n",
    "            targets = targets.view(-1, config['input_dim']).to(device)\n",
    "            optimizer.zero_grad()\n",
    "            output, vq_loss = model(targets)\n",
    "            loss = model.loss_function(output, targets, vq_loss)\n",
    "            loss['loss'].backward()\n",
    "            optimizer.step()\n",
    "            pbar.set_postfix(loss=loss['loss'].item(), recon_loss=loss['Reconstruction_Loss'].item(), vq_loss=loss['VQ_Loss'].item(), lr=optimizer.param_groups[0]['lr'])\n",
    "\n",
    "    # Validation\n",
    "    model.eval()\n",
    "    val_loss = 0\n",
    "    with torch.no_grad():\n",
    "        for targets in valloader:\n",
    "            targets = targets.view(-1, config['input_dim']).to(device)\n",
    "            output, vq_loss = model(targets)\n",
    "            loss = model.loss_function(output, targets, vq_loss)\n",
    "            val_loss += loss['loss'].item()\n",
    "            \n",
    "    val_loss /= len(valloader)\n",
    "\n",
    "    # Update learning rate\n",
    "    scheduler.step()\n",
    "\n",
    "    print(\n",
    "        f\"Epoch {epoch + 1}, Val Loss: {val_loss}\"\n",
    "    )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "7d4d7d53-f9af-4ce9-82a8-6eb4c363e9f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "78df437c-ba35-4d42-856c-6ff90bf61bd7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "idx = 20\n",
    "pred = model(trainset[idx].to(device))[0].detach().cpu().numpy()[0]\n",
    "x = np.linspace(0, config['input_dim'], config['input_dim'])\n",
    "plt.plot(x, pred, label='recon_signal')\n",
    "plt.plot(x, trainset[idx][0], label='ori_signal')\n",
    "plt.xlabel('x')\n",
    "plt.ylabel('KVAE(x)')\n",
    "plt.title('KVAE')\n",
    "plt.legend()\n",
    "plt.savefig('assets/recon_signal.jpg')\n",
    "plt.show()"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.15"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}