DomainB/recon_dataset.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "import torchvision\n",
    "import torch.optim as optim\n",
    "import matplotlib\n",
    "import matplotlib.pyplot as plt\n",
    "import torchvision.transforms as transforms\n",
    "from tqdm import tqdm\n",
    "from torchvision import datasets\n",
    "from torch.utils.data import DataLoader\n",
    "from torch import Tensor\n",
    "from torchvision.utils import save_image\n",
    "from torch.autograd import Variable\n",
    "import numpy as np\n",
    "import PIL\n",
    "import pandas as pd\n",
    "matplotlib.style.use('ggplot')\n",
    "torch.cuda.empty_cache()\n",
    "import os \n",
    "import random\n",
    "from typing import Type, Any, Callable, Union, List, Optional\n",
    "\n",
    "def set_seed(seed):\n",
    "    os.environ[\"PYTHONHASHSEED\"] = str(seed)\n",
    "    random.seed(seed)\n",
    "    np.random.seed(seed)\n",
    "    torch.manual_seed(seed)\n",
    "    torch.cuda.manual_seed_all(seed)\n",
    "    # cudnn.deterministic = True\n",
    "    # cudnn.benchmark = False\n",
    "\n",
    "set_seed(1234)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Dataset(object):\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def __len__(self):\n",
    "        raise NotImplementedError\n",
    "\n",
    "    def __add__(self, other):\n",
    "        return ConcatDataset([self, other])\n",
    "\n",
    "class DatasetMNIST(Dataset):\n",
    "    \n",
    "    def __init__(self, file_path, transform=None):\n",
    "        self.data = pd.read_csv(file_path)\n",
    "        self.transform = transform\n",
    "        \n",
    "    def __len__(self):\n",
    "        return len(self.data)\n",
    "    \n",
    "    def __getitem__(self, index):\n",
    "\n",
    "        image = self.data.iloc[index, 1:].values.astype(np.uint8).reshape((28, 28, 1))\n",
    "        label = self.data.iloc[index, 0]\n",
    "        \n",
    "        if self.transform is not None:\n",
    "            image = self.transform(image)\n",
    "            \n",
    "        return image, label\n",
    "\n",
    "\n",
    "def to_img(x):\n",
    "    x = x.clamp(0, 1)\n",
    "    x = x.view(x.size(0), 1, 64, 64)\n",
    "    return x\n",
    "\n",
    "class CvBlock(nn.Module):\n",
    "    \"\"\"(Conv2d => BN => ReLU) x 2\"\"\"\n",
    "\n",
    "    def __init__(self, in_ch, out_ch):\n",
    "        super(CvBlock, self).__init__()\n",
    "        self.convblock = nn.Sequential(\n",
    "            nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(out_ch),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(out_ch, out_ch, kernel_size=3, padding=1),\n",
    "            nn.BatchNorm2d(out_ch),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "        return self.convblock(x)\n",
    "\n",
    "\n",
    "class DownBlock(nn.Module):\n",
    "    \"\"\"Downscale + (Conv2d => BN => ReLU)*2\"\"\"\n",
    "\n",
    "    def __init__(self, in_ch, out_ch):\n",
    "        super(DownBlock, self).__init__()\n",
    "        self.convblock = nn.Sequential(\n",
    "            nn.Conv2d(in_ch, out_ch, kernel_size=3, padding=1, stride=2),\n",
    "            nn.BatchNorm2d(out_ch),\n",
    "            nn.ReLU(inplace=True),\n",
    "            CvBlock(out_ch, out_ch),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "      \n",
    "        return self.convblock(x)\n",
    "\n",
    "\n",
    "class UpBlock(nn.Module):\n",
    "    \"\"\"(Conv2d => BN => ReLU)*2 + Upscale\"\"\"\n",
    "\n",
    "    def __init__(self, in_ch, out_ch):\n",
    "        super(UpBlock, self).__init__()\n",
    "        self.convblock = nn.Sequential(\n",
    "            CvBlock(in_ch, in_ch),\n",
    "            nn.Conv2d(in_ch, out_ch * 4, kernel_size=3, padding=1),\n",
    "            nn.PixelShuffle(2),\n",
    "        )\n",
    "\n",
    "    def forward(self, x):\n",
    "\n",
    "        return self.convblock(x)\n",
    "\n",
    "\n",
    "class Reshape(nn.Module):\n",
    "    def __init__(self, *args):\n",
    "        super().__init__()\n",
    "        self.shape = args\n",
    "\n",
    "    def forward(self, x):\n",
    "        return x.view(self.shape)\n",
    "\n",
    "\n",
    "class VAE(nn.Module):\n",
    "    def __init__(self):\n",
    "        super(VAE, self).__init__()\n",
    "\n",
    "        self.encoder = nn.Sequential(\n",
    "            DownBlock(1, 32),\n",
    "            DownBlock(32, 64),\n",
    "            DownBlock(64, 128),\n",
    "            DownBlock(128, 256),\n",
    "            nn.Flatten(),\n",
    "        )\n",
    "        self.z_mean = nn.Linear(4096, 256)\n",
    "        self.z_var = nn.Linear(4096, 256)\n",
    "        self.z_up = nn.Linear(256, 4096)\n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.Linear(256,4096),\n",
    "            Reshape(-1, 256, 4, 4),\n",
    "            UpBlock(256, 128),\n",
    "            UpBlock(128, 64),\n",
    "            UpBlock(64, 32),\n",
    "            UpBlock(32, 1),\n",
    "        )\n",
    "\n",
    "    def encode(self, x):\n",
    "        h1 = self.encoder(x)\n",
    "    \n",
    "        return self.z_mean(h1), self.z_var(h1)\n",
    "\n",
    "    @staticmethod\n",
    "    def reparametrize(mu, logvar):\n",
    "        std = logvar.mul(0.5).exp_()\n",
    "        eps = torch.FloatTensor(std.size()).normal_()\n",
    "        eps = Variable(eps)\n",
    "        return eps.mul(std).add_(mu)\n",
    "\n",
    "    def decode(self, z):\n",
    "\n",
    "        h3 = self.decoder(z)\n",
    "        return F.sigmoid(h3)\n",
    "\n",
    "    def forward(self, x):\n",
    "        mu, logvar = self.encode(x)\n",
    "        # print(mu.shape, logvar.shape)\n",
    "        z = self.reparametrize(mu, logvar)\n",
    "        return self.decode(z), mu, logvar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "image_coder = VAE()\n",
    "image_coder.load_state_dict(torch.load('/home/ubuntu/Latent-Transfer/DomainB/overfit_model/cnn_vae_3000_lr4.pth'))\n",
    "image_coder.eval()\n",
    "\n",
    "transform = transforms.Compose([\n",
    "    transforms.ToPILImage(),\n",
    "    transforms.Resize((64,64)),\n",
    "    transforms.Grayscale(num_output_channels=1),\n",
    "    transforms.ToTensor(),\n",
    "])\n",
    "\n",
    "train_data = DatasetMNIST('/home/ubuntu/Latent-Transfer/DomainB/DomainB_dataset/sign_mnist_1s26c.csv', transform = transform)\n",
    "test_data = DatasetMNIST('/home/ubuntu/Latent-Transfer/DomainB/DomainB_dataset/sign_mnist_test.csv', transform = transform)\n",
    "\n",
    "batch_size = 1\n",
    "train_loader = DataLoader(\n",
    "    train_data,\n",
    "    batch_size=batch_size,\n",
    "    shuffle=True\n",
    ")\n",
    "\n",
    "test_loader = DataLoader(\n",
    "    test_data,\n",
    "    batch_size=batch_size,\n",
    "    shuffle=True\n",
    ")\n",
    "\n",
    "dataloader = train_loader"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "  0%|          | 0/24 [00:00<?, ?it/s]/home/ubuntu/miniconda3/envs/latent/lib/python3.7/site-packages/torch/nn/functional.py:1639: UserWarning: nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\n",
      "  warnings.warn(\"nn.functional.sigmoid is deprecated. Use torch.sigmoid instead.\")\n",
      "100%|██████████| 24/24 [00:01<00:00, 20.93it/s]\n"
     ]
    }
   ],
   "source": [
    "recon_img = []\n",
    "recon_label = []\n",
    "\n",
    "for batch_idx, data in enumerate(tqdm(dataloader)):\n",
    "    \n",
    "    img, label = data\n",
    "    img = Variable(img)\n",
    "\n",
    "    recon_batch, mu, logvar = image_coder(img)\n",
    "    save = to_img(recon_batch.cpu().data)\n",
    "\n",
    "    recon_img.append(recon_batch.detach().numpy())\n",
    "    recon_label.append(label.detach().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ri = np.asarray(recon_img)\n",
    "rl = np.asarray(recon_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((24, 1, 1, 64, 64), (24, 1))"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "ri.shape, rl.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.save('/home/ubuntu/Latent-Transfer/DomainB/overfit_model/recon_images_train', ri)\n",
    "np.save('/home/ubuntu/Latent-Transfer/DomainB/overfit_model/recon_labels_train', rl)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "interpreter": {
   "hash": "08089c1e34da0e306e70ecc592d166e715d3323c59c0e51c1fac58ee58ba508c"
  },
  "kernelspec": {
   "display_name": "Python 3.7.11 ('latent')",
   "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.7.11"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}