main.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# New ideas to test (optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**Part 1 / VAE training:**\n",
    "- Simple model setup, that takes a single parameter to control the capacity of encoder and decoder\n",
    "    - E.g. experiment with plain-vanilla VGG/AlexNet type net \n",
    "    - Play with dilated convolutions a bit for variety\n",
    "- Loss, 2 parts\n",
    "    - BCE / MSE loss part\n",
    "    - KL based part\n",
    "    - Optional ideas (but cool to test)\n",
    "        - Try SSIM loss as a part, instead of BCE / MSE\n",
    "        - Try automatic momentum-based dynamic loss weighting\n",
    "- Experiment with some skip connections, just for the sake of it\n",
    "- Play with some minor augmentations, just for the sake of it\n",
    "\n",
    "**Part 2**\n",
    "- Replace PCA with UMAP / T-SNE and see the difference"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Build a docker container (optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Essentially it just requires setting `pytorch=0.4.0`\n",
    "\n",
    "\n",
    "Otherwise my standard Dockerfile seems to be a fit\n",
    "\n",
    "If you will be using it, you can just replace my public key with yours (not necessary)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Dockerfile (optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```\n",
    "# add 7z tar and zip archivers\n",
    "FROM nvidia/cuda:9.0-cudnn7-devel\n",
    "\n",
    "# https://docs.docker.com/engine/examples/running_ssh_service/\n",
    "RUN apt-get update && apt-get install -y openssh-server\n",
    "RUN mkdir /var/run/sshd\n",
    "RUN echo 'root:Ubuntu@41' | chpasswd\n",
    "RUN sed -i 's/PermitRootLogin prohibit-password/PermitRootLogin yes/' /etc/ssh/sshd_config\n",
    "RUN sed -i 's/#PasswordAuthentication yes/PasswordAuthentication no/' /etc/ssh/sshd_config\n",
    "RUN mkdir ~/.ssh/\n",
    "RUN touch ~/.ssh/authorized_keys\n",
    "RUN echo 'ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAABAQDPlILkHRoLnwMS3JlNO94FAYChrW+jGXMxFK5eRmCcBtTJRrV7zyv5mqIBhyJQFiQOqeycttVQP/HTJ9XCwVY0/WK5b45Z6PmfY9PJ5uiLahTCLi8ayoqhDsIWTlWYL03dG7Oz0WEwWQ6BDmSbfS12GEzWQTLqNh7nwsmTXE5503bRtmTre69625gT8c+mgvBOoQfMN1XePxJ14j8h1dVB1Y0geRLJb7yYd4Dl6tnEb3PyGizNVaiVYeBBTx6N/8lvSVA+FYR9mOg3yzYrJ0Aqyj33Oi+jvPqZP16EUhjCukKQWH3IzS1pRvYPCXzPYwvMGvBa00f9GPDccE0eiawH atmyre@Everett' >> ~/.ssh/authorized_keys \n",
    "\n",
    "\n",
    "# SSH login fix. Otherwise user is kicked off after login\n",
    "RUN sed 's@session\\s*required\\s*pam_loginuid.so@session optional pam_loginuid.so@g' -i /etc/pam.d/sshd\n",
    "\n",
    "ENV NOTVISIBLE \"in users profile\"\n",
    "RUN echo \"export VISIBLE=now\" >> /etc/profile\n",
    "\n",
    "ENV CONDA_DIR /opt/conda\n",
    "ENV PATH $CONDA_DIR/bin:$PATH\n",
    "\n",
    "# writing env variables to /etc/profile as mentioned here https://docs.docker.com/engine/examples/running_ssh_service/#run-a-test_sshd-container\n",
    "RUN echo \"export CONDA_DIR=/opt/conda\" >> /etc/profile\n",
    "RUN echo \"export PATH=$CONDA_DIR/bin:$PATH\" >> /etc/profile\n",
    "\n",
    "RUN mkdir -p $CONDA_DIR && \\\n",
    "    echo export PATH=$CONDA_DIR/bin:'$PATH' > /etc/profile.d/conda.sh && \\\n",
    "    apt-get update && \\\n",
    "    apt-get install -y wget git libhdf5-dev g++ graphviz openmpi-bin nano && \\\n",
    "    wget --quiet https://repo.continuum.io/miniconda/Miniconda3-4.2.12-Linux-x86_64.sh && \\\n",
    "    echo \"c59b3dd3cad550ac7596e0d599b91e75d88826db132e4146030ef471bb434e9a *Miniconda3-4.2.12-Linux-x86_64.sh\" | sha256sum -c - && \\\n",
    "    /bin/bash /Miniconda3-4.2.12-Linux-x86_64.sh -f -b -p $CONDA_DIR && \\\n",
    "    ln /usr/lib/x86_64-linux-gnu/libcudnn.so /usr/local/cuda/lib64/libcudnn.so && \\\n",
    "    ln /usr/lib/x86_64-linux-gnu/libcudnn.so.7 /usr/local/cuda/lib64/libcudnn.so.7 && \\\n",
    "    ln /usr/include/cudnn.h /usr/local/cuda/include/cudnn.h  && \\\n",
    "    rm Miniconda3-4.2.12-Linux-x86_64.sh\n",
    "\n",
    "ENV NB_USER keras\n",
    "ENV NB_UID 1000\n",
    "\n",
    "RUN echo \"export NB_USER=keras\" >> /etc/profile\n",
    "RUN echo \"export NB_UID=1000\" >> /etc/profile\n",
    "\n",
    "RUN echo \"export LD_LIBRARY_PATH=/usr/local/cuda/lib64:/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH\" >> /etc/profile\n",
    "RUN echo \"export CPATH=/usr/include:/usr/include/x86_64-linux-gnu:/usr/local/cuda/include:$CPATH\" >> /etc/profile\n",
    "RUN echo \"export LIBRARY_PATH=/usr/local/cuda/lib64:/lib/x86_64-linux-gnu:$LIBRARY_PATH\" >> /etc/profile\n",
    "RUN echo \"export CUDA_HOME=/usr/local/cuda\" >> /etc/profile\n",
    "RUN echo \"export CPLUS_INCLUDE_PATH=$CPATH\" >> /etc/profile\n",
    "RUN echo \"export KERAS_BACKEND=tensorflow\" >> /etc/profile\n",
    "\n",
    "RUN useradd -m -s /bin/bash -N -u $NB_UID $NB_USER && \\\n",
    "    mkdir -p $CONDA_DIR && \\\n",
    "    chown keras $CONDA_DIR -R  \n",
    "\n",
    "USER keras\n",
    "\n",
    "RUN  mkdir -p /home/keras/notebook\n",
    "\n",
    "# Python\n",
    "ARG python_version=3.6\n",
    "\n",
    "RUN conda install -y python=${python_version} && \\\n",
    "    pip install --upgrade pip && \\\n",
    "    pip install tensorflow-gpu && \\\n",
    "    conda install Pillow scikit-learn notebook pandas matplotlib mkl nose pyyaml six h5py && \\\n",
    "    conda install theano pygpu bcolz && \\\n",
    "    pip install keras kaggle-cli lxml opencv-python requests scipy tqdm visdom && \\\n",
    "    conda install pytorch=0.4.0 cuda90 -c pytorch && \\\n",
    "    conda install torchvision -c pytorch && \\\n",
    "    pip install imgaug && \\\n",
    "    conda clean -yt\n",
    "\n",
    "ENV LD_LIBRARY_PATH /usr/local/cuda/lib64:/lib/x86_64-linux-gnu:$LD_LIBRARY_PATH\n",
    "ENV CPATH /usr/include:/usr/include/x86_64-linux-gnu:/usr/local/cuda/include:$CPATH\n",
    "ENV LIBRARY_PATH /usr/local/cuda/lib64:/lib/x86_64-linux-gnu:$LIBRARY_PATH\n",
    "ENV CUDA_HOME /usr/local/cuda\n",
    "ENV CPLUS_INCLUDE_PATH $CPATH\n",
    "ENV KERAS_BACKEND tensorflow\n",
    "\n",
    "WORKDIR /home/keras/notebook\n",
    "\n",
    "EXPOSE 8888 6006 22 8097\n",
    "\n",
    "CMD jupyter notebook --port=8888 --ip=0.0.0.0 --no-browser\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Using my dockerfile (optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-25T08:37:17.462310Z",
     "start_time": "2018-06-25T08:37:17.427974Z"
    },
    "hidden": true
   },
   "source": [
    "To build the docker image from the Dockerfile located in `dockerfile` please do:\n",
    "```\n",
    "cd dockerfile\n",
    "docker build -t oulu_docker .\n",
    "```\n",
    "\n",
    "Also please make sure that [nvidia-docker2](https://github.com/nvidia/nvidia-docker/wiki/Installation-(version-2.0)) and proper nvidia drivers are installed.\n",
    "\n",
    "To test the installation run\n",
    "```\n",
    "docker run --runtime=nvidia --rm nvidia/cuda nvidia-smi\n",
    "```\n",
    "\n",
    "Then launch the container as follows:\n",
    "```\n",
    "docker run --runtime=nvidia -e NVIDIA_VISIBLE_DEVICES=0 -it -v /your/folder/:/home/keras/notebook/your_folder -p 8888:8888 -p 6006:6006 --name oulu --shm-size 16G oulu_docker\n",
    "```\n",
    "\n",
    "Please note that w/o `--shm-size 16G` PyTorch dataloader classes will not work.\n",
    "The above command will start a container with a Jupyter notebook server available via port `8888`. \n",
    "Port `6006` is for tensorboard, if necessary.\n",
    "\n",
    "Then you can exec into the container like this. All the scripts were run as root, but they must also work under user `keras`\n",
    "```\n",
    "docker exec -it --user root REPLACE_WITH_CONTAINER_ID /bin/bash\n",
    "```\n",
    "or\n",
    "```\n",
    "docker exec -it --user keras REPLACE_WITH_CONTAINER_ID /bin/bash\n",
    "```\n",
    "\n",
    "To find out the container ID run\n",
    "```\n",
    " docker container ls\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Best viewing the notebooks (optional)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Jupyter notebook is best viewed using these extensions (installed with the below command, then to be turned on in the **Jupyter GUI**)\n",
    "\n",
    "```\n",
    "pip install git+https://github.com/ipython-contrib/jupyter_contrib_nbextensions\n",
    "# conda install html5lib==0.9999999\n",
    "jupyter contrib nbextension install --system\n",
    "```    \n",
    "Sometims there is a `html5lib` conflict.\n",
    "Excluded from the Dockerfile because of this conflict (sometimes occurs, sometimes not).\n",
    "![](extensions.png)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Prepare the CLI script"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Download data, write generator class"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-25T13:23:14.503513Z",
     "start_time": "2018-06-25T13:23:14.306768Z"
    },
    "code_folding": [
     4,
     23,
     47
    ],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def visualize_mnist(X, y, field_size=10):\n",
    "    FIELD_SIZE = field_size\n",
    "\n",
    "    ind = np.random.randint(0, X.shape[0], FIELD_SIZE*FIELD_SIZE)\n",
    "    X_vis = X[ind, :].reshape(FIELD_SIZE, FIELD_SIZE, 28, 28) \n",
    "    y_vis = y[ind].reshape(FIELD_SIZE, FIELD_SIZE)\n",
    "\n",
    "    plt.figure(figsize=(16, 16))\n",
    "\n",
    "    for i in range(FIELD_SIZE):\n",
    "        for j in range(FIELD_SIZE):\n",
    "            plt.subplot(FIELD_SIZE, FIELD_SIZE, i*FIELD_SIZE+j+1)\n",
    "            plt.imshow(X_vis[i, j, :], cmap=plt.cm.Greys)\n",
    "            plt.gca().xaxis.set_ticks([])\n",
    "            plt.gca().yaxis.set_ticks([])\n",
    "            plt.title(y_vis[i, j])\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "class Visualizer:\n",
    "    def __init__(self, size, title, xlabel, ylabel, max_epochs, min_val=None):\n",
    "        self.fig = plt.figure(figsize=size)\n",
    "        self.ax = plt.axes()\n",
    "        self.ax.set_xlabel(xlabel)\n",
    "        self.ax.set_ylabel(ylabel)\n",
    "        self.ax.set_title(title)\n",
    "        self.ax.set_xlim(1,max_epochs)\n",
    "        self.ax.grid()\n",
    "        self.min_val = min_val\n",
    "\n",
    "    def update_plot(self, fold_losses, labels):\n",
    "        if self.min_val is not None:\n",
    "            self.ax.set_ylim(0, fold_losses.max()+fold_losses.max()*0.1)\n",
    "        else:\n",
    "            self.ax.set_ylim(fold_losses.max()*0.8, fold_losses.max()+fold_losses.max()*0.1)\n",
    "\n",
    "        x = np.arange(1, fold_losses.shape[0]+1)\n",
    "\n",
    "        if self.ax.lines:\n",
    "            for i, line in enumerate(self.ax.lines):\n",
    "                line.set_xdata(x)\n",
    "                line.set_ydata(fold_losses[:, i])\n",
    "        else:\n",
    "            for i, label in enumerate(labels):\n",
    "                self.ax.plot(x, fold_losses[:, i], label=label)\n",
    "\n",
    "        self.fig.canvas.draw()\n",
    "        self.ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-25T13:18:28.540325Z",
     "start_time": "2018-06-25T13:18:27.861354Z"
    },
    "code_folding": [
     12,
     39,
     62,
     95
    ],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import cv2\n",
    "import time\n",
    "import random \n",
    "import numpy as np\n",
    "from PIL import Image\n",
    "import torch.utils.data as data\n",
    "from torchvision import transforms\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "\n",
    "cv2.setNumThreads(0)\n",
    "\n",
    "class FMNISTDataset(data.Dataset):\n",
    "    def __init__(self,\n",
    "                 num_folds = 5,\n",
    "                 fold = 0,\n",
    "                 mode = 'train',\n",
    "                 random_state = 42,\n",
    "                 use_augs = False,\n",
    "                ):\n",
    "        \n",
    "        self.X, self.y, self.X_test, self.y_test = self.get_fashion_mnist()\n",
    "        self.fold = fold            \n",
    "        self.num_folds = num_folds\n",
    "        self.mode = mode\n",
    "        self.random_state = random_state\n",
    "        self.mean = self.X.reshape(60000, 28, 28).mean()/255\n",
    "        self.std = self.X.reshape(60000, 28, 28).std()/255\n",
    "        self.use_augs = use_augs\n",
    "        \n",
    "        skf = StratifiedKFold(n_splits = self.num_folds,\n",
    "                              shuffle = True,\n",
    "                              random_state = self.random_state)\n",
    "        \n",
    "        f1, f2, f3, f4, f5 = skf.split(self.X,self.y)\n",
    "        \n",
    "        folds = [f1, f2, f3, f4, f5]\n",
    "        self.train_idx = folds[self.fold][0]\n",
    "        self.val_idx = folds[self.fold][1] \n",
    "    def get_fashion_mnist(self):\n",
    "        if not os.path.isfile('train-images-idx3-ubyte'):\n",
    "            os.system('wget http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-images-idx3-ubyte.gz')\n",
    "            os.system('wget http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/train-labels-idx1-ubyte.gz')\n",
    "            os.system('wget http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-images-idx3-ubyte.gz')\n",
    "            os.system('wget http://fashion-mnist.s3-website.eu-central-1.amazonaws.com/t10k-labels-idx1-ubyte.gz')\n",
    "            os.system('gunzip *.gz')\n",
    "\n",
    "        with open('train-images-idx3-ubyte', 'rb') as f:\n",
    "            X = np.frombuffer(f.read(), dtype=np.uint8, offset=16).copy()\n",
    "            X = X.reshape((60000, 28*28))\n",
    "\n",
    "        with open('train-labels-idx1-ubyte', 'rb') as f:\n",
    "            y = np.frombuffer(f.read(), dtype=np.uint8, offset=8)\n",
    "\n",
    "        with open('t10k-images-idx3-ubyte', 'rb') as f:\n",
    "            X_test = np.frombuffer(f.read(), dtype=np.uint8, offset=16).copy()\n",
    "            X_test = X_test.reshape((10000, 28*28))\n",
    "\n",
    "        with open('t10k-labels-idx1-ubyte', 'rb') as f:\n",
    "            y_test = np.frombuffer(f.read(), dtype=np.uint8, offset=8)\n",
    "\n",
    "        return X, y, X_test, y_test        \n",
    "    def __len__(self):\n",
    "        if self.mode == 'train':\n",
    "            return len(self.train_idx)\n",
    "        elif self.mode == 'val':\n",
    "            return len(self.val_idx)\n",
    "    def __getitem__(self, idx):\n",
    "        if self.mode == 'train':\n",
    "            return_tuple = (self.preprocess_img(Image.fromarray(self.X[self.train_idx[idx]].reshape(28, 28))),\n",
    "                            self.y[self.train_idx[idx]])\n",
    "        elif self.mode == 'val':\n",
    "            return_tuple = (self.preprocess_img(Image.fromarray(self.X[self.val_idx[idx]].reshape(28, 28))),\n",
    "                            self.y[self.val_idx[idx]])            \n",
    "        return return_tuple \n",
    "    def preprocess_img(self,\n",
    "                       img):\n",
    "        if self.use_augs == False:\n",
    "            preprocessing = transforms.Compose([\n",
    "                            transforms.CenterCrop(28),\n",
    "                            transforms.ToTensor(),\n",
    "                            transforms.Normalize(mean=[self.mean],\n",
    "                                                 std=[self.std]),\n",
    "                            ])            \n",
    "        else:\n",
    "            # do some naive augs\n",
    "            preprocessing = transforms.Compose([\n",
    "                            transforms.CenterCrop(28),\n",
    "                            transforms.RandomHorizontalFlip(p=0.25),\n",
    "                            transforms.RandomRotation(degrees=30),\n",
    "                            transforms.ToTensor(),\n",
    "                            transforms.Normalize(mean=[self.mean],\n",
    "                                                 std=[self.std]),\n",
    "                            ])  \n",
    "        return preprocessing(img).numpy()            \n",
    "    def reverse_normalize(tensor, mean, std):\n",
    "        '''reverese normalize to convert tensor -> PIL Image'''\n",
    "        tensor_copy = tensor.clone()\n",
    "        for t, m, s in zip(tensor_copy, mean, std):\n",
    "            t.div_(s).sub_(m)\n",
    "        return tensor_copy\n",
    "    def tensor2img(tensor, on_cuda=True):\n",
    "        tensor = reverse_normalize(tensor, REVERSE_MEAN, REVERSE_STD)\n",
    "        # clipping\n",
    "        tensor[tensor > 1] = 1\n",
    "        tensor[tensor < 0] = 0\n",
    "        tensor = tensor.squeeze(0)\n",
    "        if on_cuda:\n",
    "            tensor = tensor.cpu()\n",
    "        return transforms.ToPILImage()(tensor)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-25T13:18:29.004372Z",
     "start_time": "2018-06-25T13:18:28.757399Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "\n",
    "train_dataset = FMNISTDataset(random_state = 42,\n",
    "                              use_augs = True)\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    train_dataset,\n",
    "    batch_size=1000,        \n",
    "    shuffle=True,\n",
    "    num_workers=1,\n",
    "    pin_memory=False,\n",
    "    drop_last=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-25T11:02:26.913053Z",
     "start_time": "2018-06-25T11:02:26.903983Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([1000, 1, 28, 28]), torch.Size([1000]))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "input.shape, target.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-25T11:22:38.233966Z",
     "start_time": "2018-06-25T11:22:37.187878Z"
    },
    "code_folding": [],
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x1152 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i, (input, target) in enumerate(train_loader):\n",
    " \n",
    "    img = input[:,0,:,:].numpy()\n",
    "    img += -img.min()\n",
    "    img *= (1/img.max())\n",
    "\n",
    "    visualize_mnist(img,target.numpy(),field_size=5)\n",
    "    \n",
    "\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Write classes"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T16:12:26.981279Z",
     "start_time": "2018-06-27T16:12:26.964505Z"
    },
    "code_folding": [
     4,
     23
    ],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import os\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def visualize_mnist(X, y, field_size=10):\n",
    "    FIELD_SIZE = field_size\n",
    "\n",
    "    ind = np.random.randint(0, X.shape[0], FIELD_SIZE*FIELD_SIZE)\n",
    "    X_vis = X[ind, :].reshape(FIELD_SIZE, FIELD_SIZE, 28, 28) \n",
    "    y_vis = y[ind].reshape(FIELD_SIZE, FIELD_SIZE)\n",
    "\n",
    "    plt.figure(figsize=(16, 16))\n",
    "\n",
    "    for i in range(FIELD_SIZE):\n",
    "        for j in range(FIELD_SIZE):\n",
    "            plt.subplot(FIELD_SIZE, FIELD_SIZE, i*FIELD_SIZE+j+1)\n",
    "            plt.imshow(X_vis[i, j, :], cmap=plt.cm.Greys)\n",
    "            plt.gca().xaxis.set_ticks([])\n",
    "            plt.gca().yaxis.set_ticks([])\n",
    "            plt.title(y_vis[i, j])\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "\n",
    "class Visualizer:\n",
    "    def __init__(self, size, title, xlabel, ylabel, max_epochs, min_val=None):\n",
    "        self.fig = plt.figure(figsize=size)\n",
    "        self.ax = plt.axes()\n",
    "        self.ax.set_xlabel(xlabel)\n",
    "        self.ax.set_ylabel(ylabel)\n",
    "        self.ax.set_title(title)\n",
    "        self.ax.set_xlim(1,max_epochs)\n",
    "        self.ax.grid()\n",
    "        self.min_val = min_val\n",
    "\n",
    "    def update_plot(self, fold_losses, labels):\n",
    "        if self.min_val is not None:\n",
    "            self.ax.set_ylim(0, fold_losses.max()+fold_losses.max()*0.1)\n",
    "        else:\n",
    "            self.ax.set_ylim(fold_losses.max()*0.8, fold_losses.max()+fold_losses.max()*0.1)\n",
    "\n",
    "        x = np.arange(1, fold_losses.shape[0]+1)\n",
    "\n",
    "        if self.ax.lines:\n",
    "            for i, line in enumerate(self.ax.lines):\n",
    "                line.set_xdata(x)\n",
    "                line.set_ydata(fold_losses[:, i])\n",
    "        else:\n",
    "            for i, label in enumerate(labels):\n",
    "                self.ax.plot(x, fold_losses[:, i], label=label)\n",
    "\n",
    "        self.fig.canvas.draw()\n",
    "        self.ax.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T16:12:27.785822Z",
     "start_time": "2018-06-27T16:12:27.513628Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from FMNISTDataset import FMNISTDataset\n",
    "\n",
    "train_dataset = FMNISTDataset(random_state = 42,\n",
    "                              use_augs = True)\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    train_dataset,\n",
    "    batch_size=1000,        \n",
    "    shuffle=True,\n",
    "    num_workers=1,\n",
    "    pin_memory=False,\n",
    "    drop_last=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T16:12:30.915715Z",
     "start_time": "2018-06-27T16:12:30.024580Z"
    },
    "hidden": true,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x1152 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "for i, (input, target) in enumerate(train_loader):\n",
    " \n",
    "    img = input[:,0,:,:].numpy()\n",
    "    img += -img.min()\n",
    "    img *= (1/img.max())\n",
    "\n",
    "    visualize_mnist(img,target.numpy(),field_size=5)\n",
    "    \n",
    "\n",
    "    break"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T16:18:17.059960Z",
     "start_time": "2018-06-27T16:18:16.998988Z"
    },
    "code_folding": [
     4,
     29,
     56,
     156,
     262,
     335
    ],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "\n",
    "class EncoderBlock(nn.Module):\n",
    "    def __init__(self,\n",
    "                 in_,\n",
    "                 out,\n",
    "                 padding=1,\n",
    "                 dilation=1,\n",
    "                 stride=1,\n",
    "                 activation=nn.ReLU(inplace=True),\n",
    "                 kernel_size=3):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.conv = nn.Conv2d(in_,\n",
    "                     out,\n",
    "                     kernel_size,\n",
    "                     padding=padding,\n",
    "                     dilation=dilation,\n",
    "                     stride=stride)\n",
    "        self.activation = activation\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv(x)\n",
    "        x = self.activation(x)\n",
    "        print(x.shape)\n",
    "        return x\n",
    "     \n",
    "class DecoderBlock(nn.Module):\n",
    "    def __init__(self,\n",
    "                 in_channels,\n",
    "                 out_channels,\n",
    "                 kernel_size=4,\n",
    "                 padding=1,\n",
    "                 dilation=1,\n",
    "                 stride=2,\n",
    "                 activation=nn.ReLU(inplace=True)\n",
    "                ):\n",
    "\n",
    "        super(DecoderBlock, self).__init__()\n",
    "\n",
    "        self.block = nn.Sequential(\n",
    "            nn.ConvTranspose2d(in_channels,\n",
    "                               out_channels,\n",
    "                               kernel_size=kernel_size,\n",
    "                               stride=stride,\n",
    "                               padding=padding,\n",
    "                               dilation=dilation),\n",
    "            activation\n",
    "        )\n",
    "    def forward(self, x):\n",
    "        x = self.block(x)\n",
    "        print(x.shape)\n",
    "        return x \n",
    "    \n",
    "class VAEView(nn.Module):\n",
    "    def __init__(self,\n",
    "                 filters           =[1, 6, 12, 24],\n",
    "                 dilations         =[1, 1, 1],\n",
    "                 paddings          =[1, 1, 1],\n",
    "                 strides           =[2, 2, 2],\n",
    "                 decoder_kernels   =[4, 4, 3],\n",
    "                 decoder_paddings  =[1, 1, 1], \n",
    "                 decoder_strides   =[2, 2, 2],\n",
    "                 latent_space_size = 10): \n",
    "        super().__init__()\n",
    "\n",
    "        self.filters = filters\n",
    "        modules = []\n",
    "        decoder_modules = []\n",
    "        \n",
    "        for i in range(0,len(filters)-1):\n",
    "            modules = self.add_conv_block(modules,\n",
    "                                          EncoderBlock,\n",
    "                                          filters[i],\n",
    "                                          filters[i+1],\n",
    "                                          dilations[i],\n",
    "                                          paddings[i],\n",
    "                                          strides[i])\n",
    "            \n",
    "            decoder_modules = self.add_conv_block(decoder_modules,\n",
    "                                          DecoderBlock,\n",
    "                                          filters[i+1],\n",
    "                                          filters[i],\n",
    "                                          dilations[i],\n",
    "                                          decoder_paddings[i],\n",
    "                                          decoder_strides[i],\n",
    "                                          decoder_kernels[i])\n",
    "            \n",
    "        # make sure the weights are shared\n",
    "        self.encoder = nn.Sequential(*modules) \n",
    "        \n",
    "        self.mu_encoder = nn.Conv2d(4*4*filters[-1],latent_space_size, kernel_size=3, stride=1, padding=1)\n",
    "        self.logvar_encoder = nn.Conv2d(4*4*filters[-1],latent_space_size, kernel_size=3,  stride=1, padding=1)        \n",
    "\n",
    "        self.decoder_transition = EncoderBlock(latent_space_size,4*4*filters[-1])\n",
    "        self.decoder = nn.Sequential(*reversed(decoder_modules))\n",
    "        \n",
    "        print('Total model parameters {}'.format(self.count_parameters()))\n",
    "        assert self.count_parameters() < 120000        \n",
    "            \n",
    "    def encode(self,x):\n",
    "        x = self.encoder(x)\n",
    "        x = x.view(x.shape[0],-1,1,1)\n",
    "        \n",
    "        print(x.shape)\n",
    "\n",
    "        mu = self.mu_encoder(x)\n",
    "        logvar = self.logvar_encoder(x)\n",
    "        \n",
    "        return mu,logvar\n",
    "\n",
    "    def decode(self, z):\n",
    "        z = self.decoder_transition(z)\n",
    "        z = z.view(-1,self.filters[-1],4,4)\n",
    "        z = self.decoder(z)\n",
    "        return F.sigmoid(z)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        mu, logvar = self.encode(x)\n",
    "        # print(mu.shape,logvar.shape)\n",
    "        z = self.reparameterize(mu, logvar)\n",
    "        return self.decode(z), mu, logvar\n",
    "\n",
    "    def count_parameters(self):\n",
    "        return sum(p.numel() for p in self.parameters() if p.requires_grad)\n",
    "\n",
    "    def add_conv_block(self,\n",
    "                       modules,\n",
    "                       block,\n",
    "                       filters_in,\n",
    "                       filters_out,\n",
    "                       dilation,\n",
    "                       padding,\n",
    "                       stride,\n",
    "                       kernel_size=3\n",
    "                       ):\n",
    "       \n",
    "        modules.append(block(filters_in,\n",
    "                             filters_out,\n",
    "                             padding=padding,\n",
    "                             dilation=dilation,\n",
    "                             stride=stride,\n",
    "                             kernel_size=kernel_size))\n",
    "        \n",
    "        return modules\n",
    "    \n",
    "    def reparameterize(self, mu, logvar):\n",
    "        if self.training:\n",
    "            std = torch.exp(0.5*logvar)\n",
    "            eps = torch.randn_like(std)\n",
    "            return eps.mul(std).add_(mu)\n",
    "        else:\n",
    "            return mu\n",
    "        \n",
    "class VAE1N(nn.Module):\n",
    "    def __init__(self,\n",
    "                 filters           =[1, 6, 12, 24],\n",
    "                 dilations         =[1, 1, 1],\n",
    "                 paddings          =[1, 1, 1],\n",
    "                 strides           =[2, 2, 2],\n",
    "                 decoder_kernels   =[4, 4, 3],\n",
    "                 decoder_paddings  =[1, 1, 1], \n",
    "                 decoder_strides   =[2, 2, 2],\n",
    "                 latent_space_size = 10): \n",
    "        super().__init__()\n",
    "\n",
    "        self.filters = filters\n",
    "        modules = []\n",
    "        decoder_modules = []\n",
    "        \n",
    "        for i in range(0,len(filters)-1):\n",
    "            modules = self.add_conv_block(modules,\n",
    "                                          EncoderBlock,\n",
    "                                          filters[i],\n",
    "                                          filters[i+1],\n",
    "                                          dilations[i],\n",
    "                                          paddings[i],\n",
    "                                          strides[i])\n",
    "            \n",
    "            decoder_modules = self.add_conv_block(decoder_modules,\n",
    "                                          DecoderBlock,\n",
    "                                          filters[i+1],\n",
    "                                          filters[i],\n",
    "                                          dilations[i],\n",
    "                                          decoder_paddings[i],\n",
    "                                          decoder_strides[i],\n",
    "                                          decoder_kernels[i])\n",
    "            \n",
    "        # make sure the weights are shared\n",
    "        self.encoder = nn.Sequential(*modules) \n",
    "        \n",
    "        self.mu_encoder = nn.Conv1d(1,latent_space_size, kernel_size=(4*4*filters[-1]), stride=1, padding=0)\n",
    "        self.logvar_encoder = nn.Conv1d(1,latent_space_size, kernel_size=(4*4*filters[-1]),  stride=1, padding=0)     \n",
    "\n",
    "        self.decoder_transition = nn.Sequential(\n",
    "            nn.ConvTranspose1d(latent_space_size,1, kernel_size=(4*4*filters[-1]),  stride=1, padding=0),\n",
    "            nn.ReLU(inplace=True)\n",
    "        )\n",
    "        self.decoder = nn.Sequential(*reversed(decoder_modules))\n",
    "        \n",
    "        print('Total model parameters {}'.format(self.count_parameters()))\n",
    "        assert self.count_parameters() < 120000        \n",
    "            \n",
    "    def encode(self,x):\n",
    "        x = self.encoder(x)\n",
    "        x = x.view(x.shape[0],1,-1)\n",
    "        \n",
    "        print(x.shape)\n",
    "\n",
    "        mu = self.mu_encoder(x)\n",
    "        logvar = self.logvar_encoder(x)\n",
    "        \n",
    "        print(mu.shape)\n",
    "        print(logvar.shape)\n",
    "        \n",
    "        return mu,logvar\n",
    "\n",
    "    def decode(self, z):\n",
    "        z = self.decoder_transition(z)\n",
    "        z = z.view(-1,self.filters[-1],4,4)\n",
    "        z = self.decoder(z)\n",
    "        return F.sigmoid(z)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        mu, logvar = self.encode(x)\n",
    "        # print(mu.shape,logvar.shape)\n",
    "        z = self.reparameterize(mu, logvar)\n",
    "        return self.decode(z), mu, logvar\n",
    "\n",
    "    def count_parameters(self):\n",
    "        return sum(p.numel() for p in self.parameters() if p.requires_grad)\n",
    "\n",
    "    def add_conv_block(self,\n",
    "                       modules,\n",
    "                       block,\n",
    "                       filters_in,\n",
    "                       filters_out,\n",
    "                       dilation,\n",
    "                       padding,\n",
    "                       stride,\n",
    "                       kernel_size=3\n",
    "                       ):\n",
    "       \n",
    "        modules.append(block(filters_in,\n",
    "                             filters_out,\n",
    "                             padding=padding,\n",
    "                             dilation=dilation,\n",
    "                             stride=stride,\n",
    "                             kernel_size=kernel_size))\n",
    "        \n",
    "        return modules\n",
    "    \n",
    "    def reparameterize(self, mu, logvar):\n",
    "        if self.training:\n",
    "            std = torch.exp(0.5*logvar)\n",
    "            eps = torch.randn_like(std)\n",
    "            return eps.mul(std).add_(mu)\n",
    "        else:\n",
    "            return mu        \n",
    "        \n",
    "class VAESimplifiedFC(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        # make sure the weights are shared\n",
    "        self.encoder = nn.Sequential(\n",
    "            nn.Conv2d(1,4,3,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(4,8,3,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(8,16,3,stride=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(16,32,3,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(32,64,3,stride=2),\n",
    "            nn.ReLU(inplace=True),            \n",
    "        ) \n",
    "        self.mu_encoder = nn.Sequential(\n",
    "            nn.Linear(64*4*4, 10)          \n",
    "        ) \n",
    "        self.logvar_encoder = nn.Sequential(\n",
    "            nn.Linear(64*4*4, 10)\n",
    "        )       \n",
    "        self.linear_decoder = nn.Sequential(\n",
    "            nn.Linear(10, 64*4*4),\n",
    "            nn.ReLU(inplace=True),\n",
    "        )       \n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.ConvTranspose2d(64,32,4,stride=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d(32,16,4,stride=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d(16,8,4,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d(8,4,4,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d(4,1,3,stride=1, padding=(1, 1)),\n",
    "            nn.ReLU(inplace=True),              \n",
    "        ) \n",
    "        \n",
    "        print('Total model parameters {}'.format(self.count_parameters()))\n",
    "        assert self.count_parameters() < 120000        \n",
    "            \n",
    "    def encode(self,x):\n",
    "        x = self.encoder(x)\n",
    "        x = x.view(-1,64*4*4)\n",
    "        mu = self.mu_encoder(x)\n",
    "        logvar = self.logvar_encoder(x)\n",
    "        return mu,logvar\n",
    "\n",
    "    def decode(self, z):\n",
    "        z = self.linear_decoder(z)\n",
    "        z = z.view(-1,64,4,4)\n",
    "        z = self.decoder(z)\n",
    "        return F.sigmoid(z)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        mu, logvar = self.encode(x)\n",
    "        # print(mu.shape,logvar.shape)\n",
    "        z = self.reparameterize(mu, logvar)\n",
    "        return self.decode(z), mu, logvar\n",
    "\n",
    "    def count_parameters(self):\n",
    "        return sum(p.numel() for p in self.parameters() if p.requires_grad)\n",
    "    \n",
    "    def reparameterize(self, mu, logvar):\n",
    "        if self.training:\n",
    "            std = torch.exp(0.5*logvar)\n",
    "            eps = torch.randn_like(std)\n",
    "            return eps.mul(std).add_(mu)\n",
    "        else:\n",
    "            return mu        \n",
    "\n",
    "class VAESimplified(nn.Module):\n",
    "    def __init__(self):\n",
    "        super().__init__()\n",
    "        \n",
    "        # make sure the weights are shared\n",
    "        self.encoder = nn.Sequential(\n",
    "            nn.Conv2d(1,4,3,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(4,8,3,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(8,16,3,stride=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(16,32,3,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.Conv2d(32,64,3,stride=2),\n",
    "            nn.ReLU(inplace=True),            \n",
    "        ) \n",
    "        self.mu_encoder = nn.Sequential(\n",
    "            nn.Conv2d(64,10,3,stride=2),\n",
    "            nn.ReLU(inplace=True),            \n",
    "        ) \n",
    "        self.logvar_encoder = nn.Sequential(\n",
    "            nn.Conv2d(64,10,3,stride=2),\n",
    "            nn.ReLU(inplace=True),          \n",
    "        )       \n",
    "\n",
    "        self.decoder = nn.Sequential(\n",
    "            nn.ConvTranspose2d(10,64,4,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d(64,32,4,stride=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d(32,16,4,stride=2),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d(16,8,4,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d(8,4,4,stride=1),\n",
    "            nn.ReLU(inplace=True),\n",
    "            nn.ConvTranspose2d(4,1,3,stride=1, padding=(1, 1)),\n",
    "            nn.ReLU(inplace=True),              \n",
    "        ) \n",
    "        \n",
    "        print('Total model parameters {}'.format(self.count_parameters()))\n",
    "        assert self.count_parameters() < 120000        \n",
    "            \n",
    "    def encode(self,x):\n",
    "        x = self.encoder(x)\n",
    "        mu = self.mu_encoder(x)\n",
    "        logvar = self.logvar_encoder(x)\n",
    "        return mu,logvar\n",
    "\n",
    "    def decode(self, z):\n",
    "        z = self.decoder(z)\n",
    "        return F.sigmoid(z)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        mu, logvar = self.encode(x)\n",
    "        # print(mu.shape,logvar.shape)\n",
    "        z = self.reparameterize(mu, logvar)\n",
    "        return self.decode(z), mu, logvar\n",
    "\n",
    "    def count_parameters(self):\n",
    "        return sum(p.numel() for p in self.parameters() if p.requires_grad)\n",
    "    \n",
    "    def reparameterize(self, mu, logvar):\n",
    "        if self.training:\n",
    "            std = torch.exp(0.5*logvar)\n",
    "            eps = torch.randn_like(std)\n",
    "            return eps.mul(std).add_(mu)\n",
    "        else:\n",
    "            return mu        \n",
    "        \n",
    "class VAEBaselineConv(nn.Module):\n",
    "    def __init__(self,\n",
    "                 latent_space_size=10):\n",
    "        super(VAEBaselineConv, self).__init__()\n",
    "        self.fc1 = nn.Conv2d(1,32, kernel_size=(28,28), stride=1, padding=0)\n",
    "        self.fc21 = nn.Conv2d(32,latent_space_size, kernel_size=(1,1), stride=1, padding=0)\n",
    "        self.fc22 = nn.Conv2d(32,latent_space_size, kernel_size=(1,1), stride=1, padding=0)\n",
    "        \n",
    "        self.fc3 = nn.ConvTranspose2d(latent_space_size,118, kernel_size=(1,1),  stride=1, padding=0)\n",
    "        self.fc4 = nn.ConvTranspose2d(118,1, kernel_size=(28,28),  stride=1, padding=0)\n",
    "        \n",
    "        print('Total model parameters {}'.format(self.count_parameters()))\n",
    "        assert self.count_parameters() < 120000    \n",
    "        \n",
    "    def encode(self, x):\n",
    "        h1 = F.relu(self.fc1(x))\n",
    "        \n",
    "        return self.fc21(h1), self.fc22(h1)\n",
    "\n",
    "    def reparameterize(self, mu, logvar):\n",
    "        if self.training:\n",
    "            std = torch.exp(0.5*logvar)\n",
    "            eps = torch.randn_like(std)\n",
    "            return eps.mul(std).add_(mu)\n",
    "        else:\n",
    "            return mu\n",
    "\n",
    "    def decode(self, z):\n",
    "        h3 = F.relu(self.fc3(z))\n",
    "        return F.sigmoid(self.fc4(h3))\n",
    "\n",
    "    def forward(self, x):\n",
    "        mu, logvar = self.encode(x)\n",
    "        print(mu.shape,logvar.shape)\n",
    "        z = self.reparameterize(mu, logvar)\n",
    "        return self.decode(z), mu, logvar\n",
    "    \n",
    "    def count_parameters(self):\n",
    "        return sum(p.numel() for p in self.parameters() if p.requires_grad)         "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T16:18:18.623045Z",
     "start_time": "2018-06-27T16:18:18.585229Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total model parameters 119591\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 10, 1, 1]) torch.Size([1000, 10, 1, 1])\n",
      "torch.Size([1000, 1, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "model = VAEBaselineConv(latent_space_size=10)\n",
    "\n",
    "# print(model)\n",
    "print(input.shape)\n",
    "out, mu, logvar = model(input)\n",
    "print(out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T13:45:02.722029Z",
     "start_time": "2018-06-27T13:45:02.155048Z"
    },
    "hidden": true,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total model parameters 100021\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 1, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "model = VAESimplifiedFC()\n",
    "\n",
    "# print(model)\n",
    "print(input.shape)\n",
    "out, mu, logvar = model(input)\n",
    "print(out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T13:32:17.454483Z",
     "start_time": "2018-06-27T13:32:17.283985Z"
    },
    "code_folding": [],
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 16, 32, 64]\n",
      "Total model parameters 80966\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 16, 14, 14])\n",
      "torch.Size([1000, 32, 7, 7])\n",
      "torch.Size([1000, 64, 4, 4])\n",
      "torch.Size([1000, 1, 1024])\n",
      "torch.Size([1000, 10, 1])\n",
      "torch.Size([1000, 10, 1])\n",
      "torch.Size([1000, 32, 7, 7])\n",
      "torch.Size([1000, 16, 14, 14])\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 1, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "multiplier = 4\n",
    "filter_list = [1,\n",
    "               int(multiplier*4),\n",
    "               int(multiplier*8),\n",
    "               int(multiplier*16),\n",
    "              ]\n",
    "print(filter_list)\n",
    "\n",
    "model = VAE1N(filters       =filter_list,\n",
    "            dilations         =[1, 1, 1],\n",
    "            paddings          =[1, 1, 1],\n",
    "            strides           =[2, 2, 2],\n",
    "            decoder_kernels   =[4, 4, 3],\n",
    "            decoder_paddings  =[1, 1, 1], \n",
    "            decoder_strides   =[2, 2, 2],\n",
    "            latent_space_size = 10 )\n",
    "\n",
    "# print(model)\n",
    "print(input.shape)\n",
    "out, mu, logvar = model(input)\n",
    "print(out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T11:59:53.013002Z",
     "start_time": "2018-06-27T11:59:52.258204Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 8, 8, 16, 16, 32, 32, 10]\n",
      "Total model parameters 60869\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 8, 28, 28])\n",
      "torch.Size([1000, 8, 14, 14])\n",
      "torch.Size([1000, 16, 14, 14])\n",
      "torch.Size([1000, 16, 7, 7])\n",
      "torch.Size([1000, 32, 7, 7])\n",
      "torch.Size([1000, 32, 4, 4])\n",
      "torch.Size([1000, 10, 4, 4])\n",
      "torch.Size([1000, 10, 4, 4])\n",
      "torch.Size([1000, 32, 7, 7])\n",
      "torch.Size([1000, 32, 10, 10])\n",
      "torch.Size([1000, 16, 13, 13])\n",
      "torch.Size([1000, 16, 28, 28])\n",
      "torch.Size([1000, 8, 31, 31])\n",
      "torch.Size([1000, 8, 34, 34])\n",
      "torch.Size([1000, 1, 34, 34])\n",
      "torch.Size([1000, 1, 34, 34])\n"
     ]
    }
   ],
   "source": [
    "from VAE import VAE\n",
    "\n",
    "multiplier = 1\n",
    "filter_list = [1,\n",
    "               int(multiplier*8), int(multiplier*8),\n",
    "               int(multiplier*16), int(multiplier*16),\n",
    "               int(multiplier*32), int(multiplier*32),\n",
    "               10]\n",
    "print(filter_list)\n",
    "\n",
    "model = VAE(filters          =filter_list,\n",
    "            dilations        =[1, 1, 1, 1, 1, 1, 1],\n",
    "            paddings         =[1, 1, 1, 1, 1, 1, 1],\n",
    "            strides          =[1, 2, 1, 2, 1, 2, 1],\n",
    "            decoder_kernels  =[3, 4, 4, 4, 4, 4, 4],\n",
    "            decoder_paddings =[1, 0, 0, 0, 0, 0, 0], \n",
    "            decoder_strides  =[1, 1, 1, 2, 1, 1, 1],\n",
    "            split_filter = 1)\n",
    "\n",
    "# print(model)\n",
    "print(input.shape)\n",
    "out, mu, logvar = model(input)\n",
    "print(out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T11:55:20.263186Z",
     "start_time": "2018-06-27T11:55:19.748042Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 8, 16, 32, 64, 10]\n",
      "Total model parameters 90101\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 4, 26, 26])\n",
      "torch.Size([1000, 8, 24, 24])\n",
      "torch.Size([1000, 16, 11, 11])\n",
      "torch.Size([1000, 32, 9, 9])\n",
      "torch.Size([1000, 64, 4, 4])\n",
      "torch.Size([1000, 10, 1, 1])\n",
      "torch.Size([1000, 10, 1, 1])\n",
      "torch.Size([1000, 64, 4, 4])\n",
      "torch.Size([1000, 32, 10, 10])\n",
      "torch.Size([1000, 16, 22, 22])\n",
      "torch.Size([1000, 8, 25, 25])\n",
      "torch.Size([1000, 4, 28, 28])\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 1, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "from VAE import VAE\n",
    "\n",
    "multiplier = 1\n",
    "filter_list = [1, int(multiplier*4), int(multiplier*8), int(multiplier*16), int(multiplier*32), int(multiplier*64), 10]\n",
    "print(filter_list)\n",
    "\n",
    "model = VAE(filters          =filter_list,\n",
    "            dilations        =[1, 1, 1, 1, 1, 1],\n",
    "            paddings         =[0, 0, 0, 0, 0, 0],\n",
    "            strides          =[1, 1, 2, 1, 2, 2],\n",
    "            decoder_kernels  =[3, 4, 4, 4, 4, 4],\n",
    "            decoder_paddings =[1, 0, 0, 0, 0, 0], \n",
    "            decoder_strides  =[1, 1, 1, 2, 2, 1],\n",
    "            split_filter = 1)\n",
    "\n",
    "# print(model)\n",
    "print(input.shape)\n",
    "out, mu, logvar = model(input)\n",
    "print(out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T08:01:05.341486Z",
     "start_time": "2018-06-27T08:01:04.933567Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 8, 16, 32, 64, 10]\n",
      "Total model parameters 90101\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 4, 26, 26])\n",
      "torch.Size([1000, 8, 24, 24])\n",
      "torch.Size([1000, 16, 11, 11])\n",
      "torch.Size([1000, 32, 9, 9])\n",
      "torch.Size([1000, 64, 4, 4])\n",
      "torch.Size([1000, 10, 1, 1])\n",
      "torch.Size([1000, 10, 1, 1])\n",
      "torch.Size([1000, 64, 4, 4])\n",
      "torch.Size([1000, 32, 10, 10])\n",
      "torch.Size([1000, 16, 22, 22])\n",
      "torch.Size([1000, 8, 25, 25])\n",
      "torch.Size([1000, 4, 28, 28])\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 1, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "from VAE import VAE\n",
    "\n",
    "multiplier = 1\n",
    "filter_list = [1, int(multiplier*4), int(multiplier*8), int(multiplier*16), int(multiplier*32), int(multiplier*64), 10]\n",
    "print(filter_list)\n",
    "\n",
    "model = VAE(filters          =filter_list,\n",
    "            dilations        =[1, 1, 1, 1, 1, 1],\n",
    "            paddings         =[0, 0, 0, 0, 0, 0],\n",
    "            strides          =[1, 1, 2, 1, 2, 2],\n",
    "            decoder_kernels  =[3, 4, 4, 4, 4, 4],\n",
    "            decoder_paddings =[1, 0, 0, 0, 0, 0], \n",
    "            decoder_strides  =[1, 1, 1, 2, 2, 1],\n",
    "            split_filter = 1)\n",
    "\n",
    "# print(model)\n",
    "print(input.shape)\n",
    "out, mu, logvar = model(input)\n",
    "print(out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T07:54:08.076932Z",
     "start_time": "2018-06-27T07:54:08.073990Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([1000, 10, 1, 1]), torch.Size([1000, 10, 1, 1]))"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mu.shape,logvar.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 191,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T11:06:28.024301Z",
     "start_time": "2018-06-26T11:06:27.028555Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total model parameters 20187\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 10, 9, 9]) torch.Size([1000, 10, 9, 9])\n",
      "torch.Size([1000, 1, 26, 26])\n"
     ]
    }
   ],
   "source": [
    "multiplier = 2\n",
    "filter_list = [1, multiplier*2, multiplier*16, multiplier*8, 10]\n",
    "\n",
    "model = VAE(filters          =filter_list,\n",
    "            dilations        =[1, 1, 1, 1],\n",
    "            paddings         =[0, 0, 0, 0],\n",
    "            strides          =[1, 1, 2, 1],\n",
    "            decoder_kernels  =[3, 4, 4, 4],\n",
    "            decoder_paddings =[1, 0, 0, 0], \n",
    "            decoder_strides  =[1, 1, 1, 2])\n",
    "\n",
    "# print(model)\n",
    "print(input.shape)\n",
    "out, mu, logvar = model(input)\n",
    "print(out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T06:08:32.507253Z",
     "start_time": "2018-06-27T06:08:32.503967Z"
    },
    "hidden": true,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VAE(\n",
       "  (encoder): Sequential(\n",
       "    (0): EncoderBlock(\n",
       "      (conv): Conv2d(1, 4, kernel_size=(3, 3), stride=(1, 1))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "    (1): EncoderBlock(\n",
       "      (conv): Conv2d(4, 16, kernel_size=(3, 3), stride=(1, 1))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "    (2): EncoderBlock(\n",
       "      (conv): Conv2d(16, 32, kernel_size=(3, 3), stride=(2, 2))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "  )\n",
       "  (mu_encoder): Sequential(\n",
       "    (0): EncoderBlock(\n",
       "      (conv): Conv2d(32, 16, kernel_size=(3, 3), stride=(1, 1))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "    (1): EncoderBlock(\n",
       "      (conv): Conv2d(16, 12, kernel_size=(3, 3), stride=(2, 2))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "    (2): EncoderBlock(\n",
       "      (conv): Conv2d(12, 10, kernel_size=(3, 3), stride=(2, 2))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "  )\n",
       "  (logvar_encoder): Sequential(\n",
       "    (0): EncoderBlock(\n",
       "      (conv): Conv2d(32, 16, kernel_size=(3, 3), stride=(1, 1))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "    (1): EncoderBlock(\n",
       "      (conv): Conv2d(16, 12, kernel_size=(3, 3), stride=(2, 2))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "    (2): EncoderBlock(\n",
       "      (conv): Conv2d(12, 10, kernel_size=(3, 3), stride=(2, 2))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "  )\n",
       "  (decoder): Sequential(\n",
       "    (0): DecoderBlock(\n",
       "      (block): Sequential(\n",
       "        (0): ConvTranspose2d(10, 12, kernel_size=(4, 4), stride=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "    )\n",
       "    (1): DecoderBlock(\n",
       "      (block): Sequential(\n",
       "        (0): ConvTranspose2d(12, 16, kernel_size=(4, 4), stride=(2, 2))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "    )\n",
       "    (2): DecoderBlock(\n",
       "      (block): Sequential(\n",
       "        (0): ConvTranspose2d(16, 32, kernel_size=(4, 4), stride=(2, 2))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "    )\n",
       "    (3): DecoderBlock(\n",
       "      (block): Sequential(\n",
       "        (0): ConvTranspose2d(32, 16, kernel_size=(4, 4), stride=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "    )\n",
       "    (4): DecoderBlock(\n",
       "      (block): Sequential(\n",
       "        (0): ConvTranspose2d(16, 4, kernel_size=(4, 4), stride=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "    )\n",
       "    (5): DecoderBlock(\n",
       "      (block): Sequential(\n",
       "        (0): ConvTranspose2d(4, 1, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "        (1): ReLU(inplace)\n",
       "      )\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-27T06:10:59.226922Z",
     "start_time": "2018-06-27T06:10:59.102239Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.image.AxesImage at 0x7fd6e3e6ba20>"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.imshow(out[0,0].detach().numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T18:55:39.980612Z",
     "start_time": "2018-06-26T18:55:39.109002Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1, 4, 16, 32, 16, 12, 10]\n",
      "Total model parameters 35243\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 10, 1, 1]) torch.Size([1000, 10, 1, 1])\n",
      "torch.Size([1000, 1, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "multiplier = 2\n",
    "filter_list = [1, int(multiplier*2), int(multiplier*8), int(multiplier*16), int(multiplier*8), int(multiplier*6), 10]\n",
    "print(filter_list)\n",
    "\n",
    "model = VAE(filters          =filter_list,\n",
    "            dilations        =[1, 1, 1, 1, 1, 1],\n",
    "            paddings         =[0, 0, 0, 0, 0, 0],\n",
    "            strides          =[1, 1, 2, 1, 2, 2],\n",
    "            decoder_kernels  =[3, 4, 4, 4, 4, 4],\n",
    "            decoder_paddings =[1, 0, 0, 0, 0, 0], \n",
    "            decoder_strides  =[1, 1, 1, 2, 2, 1])\n",
    "\n",
    "# print(model)\n",
    "print(input.shape)\n",
    "out, mu, logvar = model(input)\n",
    "print(out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 188,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T11:04:55.598631Z",
     "start_time": "2018-06-26T11:04:54.872837Z"
    },
    "hidden": true,
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total model parameters 39531\n",
      "torch.Size([1000, 1, 28, 28])\n",
      "torch.Size([1000, 10, 1, 1]) torch.Size([1000, 10, 1, 1])\n",
      "torch.Size([1000, 1, 28, 28])\n"
     ]
    }
   ],
   "source": [
    "model = VAE(filters          =[1, 8, 16, 32, 16, 16, 10],\n",
    "            dilations        =[1, 1, 1, 1, 1, 1],\n",
    "            paddings         =[0, 0, 0, 0, 0, 0],\n",
    "            strides          =[1, 1, 2, 1, 2, 2],\n",
    "            decoder_kernels  =[3, 4, 4, 4, 4, 4],\n",
    "            decoder_paddings =[1, 0, 0, 0, 0, 0], \n",
    "            decoder_strides  =[1, 1, 1, 2, 2, 1])\n",
    "\n",
    "# print(model)\n",
    "print(input.shape)\n",
    "out, mu, logvar = model(input)\n",
    "print(out.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T09:59:07.877079Z",
     "start_time": "2018-06-26T09:59:07.873806Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1562"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "count_parameters(model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T09:59:00.000355Z",
     "start_time": "2018-06-26T09:58:59.997215Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-25T13:25:55.753781Z",
     "start_time": "2018-06-25T13:25:55.750895Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "VAE(\n",
       "  (conv_blocks): Sequential(\n",
       "    (0): ConvRelu(\n",
       "      (conv): Conv2d(1, 2, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "    (1): ConvRelu(\n",
       "      (conv): Conv2d(2, 4, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "    (2): ConvRelu(\n",
       "      (conv): Conv2d(4, 8, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
       "      (activation): ReLU(inplace)\n",
       "    )\n",
       "  )\n",
       ")"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T18:55:11.509773Z",
     "start_time": "2018-06-26T18:55:11.483891Z"
    },
    "code_folding": [
     4,
     28,
     29,
     53
    ],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch import nn\n",
    "from torch.nn import functional as F\n",
    "\n",
    "class EncoderBlock(nn.Module):\n",
    "    def __init__(self,\n",
    "                 in_,\n",
    "                 out,\n",
    "                 padding=1,\n",
    "                 dilation=1,\n",
    "                 stride=1,\n",
    "                 activation=nn.ReLU(inplace=True),\n",
    "                 kernel_size=3):\n",
    "        super().__init__()\n",
    "        \n",
    "        self.conv = nn.Conv2d(in_,\n",
    "                     out,\n",
    "                     kernel_size,\n",
    "                     padding=padding,\n",
    "                     dilation=dilation,\n",
    "                     stride=stride)\n",
    "        self.activation = activation\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = self.conv(x)\n",
    "        x = self.activation(x)\n",
    "        return x\n",
    "     \n",
    "class DecoderBlock(nn.Module):\n",
    "    def __init__(self,\n",
    "                 in_channels,\n",
    "                 out_channels,\n",
    "                 kernel_size=4,\n",
    "                 padding=1,\n",
    "                 dilation=0,\n",
    "                 stride=2,\n",
    "                 activation=nn.ReLU(inplace=True)\n",
    "                ):\n",
    "\n",
    "        super(DecoderBlock, self).__init__()\n",
    "\n",
    "        self.block = nn.Sequential(\n",
    "            nn.ConvTranspose2d(in_channels,\n",
    "                               out_channels,\n",
    "                               kernel_size=kernel_size,\n",
    "                               stride=stride,\n",
    "                               padding=padding,\n",
    "                               dilation=dilation),\n",
    "            activation\n",
    "        )\n",
    "    def forward(self, x):\n",
    "        return self.block(x) \n",
    "    \n",
    "class VAE(nn.Module):\n",
    "    def __init__(self,\n",
    "                 use_skip_connections=False,\n",
    "                 filters          =[1, 16, 32, 64, 32, 16, 10],\n",
    "                 dilations        =[1, 1, 1, 1, 1, 1],\n",
    "                 paddings         =[0, 0, 0, 0, 0, 0],\n",
    "                 strides          =[1, 1, 2, 1, 2, 2],\n",
    "                 decoder_kernels  =[3, 4, 4, 4, 4, 4],\n",
    "                 decoder_paddings =[1, 0, 0, 0, 0, 0],\n",
    "                 decoder_strides  =[1, 1, 1, 2, 2, 1]):\n",
    "        super().__init__()\n",
    "        \n",
    "        modules = []\n",
    "        decoder_modules = []\n",
    "        \n",
    "        for i in range(0,len(filters)-1):\n",
    "            modules = self.add_conv_block(modules,\n",
    "                                          EncoderBlock,\n",
    "                                          filters[i],\n",
    "                                          filters[i+1],\n",
    "                                          dilations[i],\n",
    "                                          paddings[i],\n",
    "                                          strides[i])\n",
    "            \n",
    "            decoder_modules = self.add_conv_block(decoder_modules,\n",
    "                                          DecoderBlock,\n",
    "                                          filters[i+1],\n",
    "                                          filters[i],\n",
    "                                          dilations[i],\n",
    "                                          decoder_paddings[i],\n",
    "                                          decoder_strides[i],\n",
    "                                          decoder_kernels[i])\n",
    "        \n",
    "        # make sure the weights are shared\n",
    "        self.encoder = nn.Sequential(*modules[:-3]) \n",
    "        self.mu_encoder = nn.Sequential(*modules[-3:])\n",
    "        self.logvar_encoder = nn.Sequential(*modules[-3:])        \n",
    "\n",
    "        self.decoder = nn.Sequential(*reversed(decoder_modules))\n",
    "        \n",
    "        print('Total model parameters {}'.format(self.count_parameters()))\n",
    "        assert self.count_parameters() < 120000        \n",
    "            \n",
    "    def encode(self,x):\n",
    "        x = self.encoder(x)\n",
    "        mu = self.mu_encoder(x)\n",
    "        logvar = self.logvar_encoder(x)\n",
    "        return mu,logvar\n",
    "\n",
    "    def decode(self, z):\n",
    "        z = self.decoder(z)\n",
    "        # usually having sigmoid inside of the PyTorch model is bad taste\n",
    "        # but in this case it is more reasonable\n",
    "        return F.sigmoid(z)\n",
    "        \n",
    "    def forward(self, x):\n",
    "        mu, logvar = self.encode(x)\n",
    "        print(mu.shape,logvar.shape)\n",
    "        z = self.reparameterize(mu, logvar)\n",
    "        return self.decode(z), mu, logvar\n",
    "    \n",
    "    def count_parameters(self):\n",
    "        return sum(p.numel() for p in self.parameters() if p.requires_grad)\n",
    "\n",
    "    def add_conv_block(self,\n",
    "                       modules,\n",
    "                       block,\n",
    "                       filters_in,\n",
    "                       filters_out,\n",
    "                       dilation,\n",
    "                       padding,\n",
    "                       stride,\n",
    "                       kernel_size=3\n",
    "                       ):\n",
    "       \n",
    "        modules.append(block(filters_in,\n",
    "                             filters_out,\n",
    "                             padding=padding,\n",
    "                             dilation=dilation,\n",
    "                             stride=stride,\n",
    "                             kernel_size=kernel_size))\n",
    "        \n",
    "        return modules\n",
    "    \n",
    "    def reparameterize(self, mu, logvar):\n",
    "        if self.training:\n",
    "            std = torch.exp(0.5*logvar)\n",
    "            eps = torch.randn_like(std)\n",
    "            return eps.mul(std).add_(mu)\n",
    "        else:\n",
    "            return mu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 270,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T13:03:04.310421Z",
     "start_time": "2018-06-26T13:03:04.262774Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.7356)\n",
      "tensor(0.7320)\n",
      "tensor(1.00000e-03 *\n",
      "       3.6563)\n"
     ]
    }
   ],
   "source": [
    "criterion = VAELoss(use_running_mean=False,\n",
    "                    image_loss_type='bce',\n",
    "                    image_loss_weight=1,\n",
    "                    kl_loss_weight=1,\n",
    "                    ssim_window_size=5)\n",
    "\n",
    "loss,image_loss,kl_loss = criterion(out,\n",
    "                                    input,\n",
    "                                    mu,\n",
    "                                    logvar)\n",
    "\n",
    "print(loss)\n",
    "print(image_loss)\n",
    "print(kl_loss)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 268,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T13:02:50.563398Z",
     "start_time": "2018-06-26T13:02:50.559231Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "tensor(0.1945)\n",
      "tensor(0.1908)\n",
      "tensor(1.00000e-03 *\n",
      "       3.6563)\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 254,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T12:55:59.859288Z",
     "start_time": "2018-06-26T12:55:59.856458Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(torch.Size([1000, 1, 28, 28]),\n",
       " torch.Size([1000, 1, 28, 28]),\n",
       " torch.Size([1000, 10, 1, 1]),\n",
       " torch.Size([1000, 10, 1, 1]))"
      ]
     },
     "execution_count": 254,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "out.shape,input.shape,mu.shape,logvar.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 252,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T12:55:52.206895Z",
     "start_time": "2018-06-26T12:55:52.201609Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([]) torch.Size([])\n",
      "tensor(1.00000e+05 *\n",
      "       1.4962)\n",
      "tensor(36.5628)\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 250,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T12:55:27.278369Z",
     "start_time": "2018-06-26T12:55:27.273245Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor(1.00000e+05 *\n",
       "       5.7392)"
      ]
     },
     "execution_count": 250,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 264,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-26T13:02:07.279478Z",
     "start_time": "2018-06-26T13:02:07.263337Z"
    },
    "code_folding": [
     5
    ],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.nn.functional as F\n",
    "from pytorch_ssim import SSIM as SSIMLoss\n",
    "\n",
    "class VAELoss(nn.Module):\n",
    "    def __init__(self,\n",
    "                 use_running_mean=False,\n",
    "                 image_loss_type='bce',# 'bce','mse' or ssim\n",
    "                 image_loss_weight=1,\n",
    "                 kl_loss_weight=1,\n",
    "                 ssim_window_size=5,\n",
    "                 eps=1e-10,\n",
    "                 gamma=0.9\n",
    "                 ):\n",
    "        super().__init__()\n",
    "\n",
    "        if image_loss_type=='bce':\n",
    "            self.image_loss = nn.BCELoss(size_average=True)\n",
    "        elif image_loss_type=='mse':\n",
    "            self.image_loss = nn.MSELoss(size_average=True)\n",
    "        elif image_loss_type=='ssim':\n",
    "            self.image_loss = SSIMLoss(window_size = ssim_window_size, size_average = True)\n",
    "            \n",
    "        self.image_loss_type = image_loss_type\n",
    "        self.use_running_mean = use_running_mean            \n",
    "        self.image_loss_weight = image_loss_weight\n",
    "        self.kl_loss_weight = kl_loss_weight\n",
    "        self.eps = eps\n",
    "        self.gamma = gamma \n",
    "        \n",
    "        if self.use_running_mean == True:\n",
    "            self.register_buffer('running_image_loss', torch.zeros(1))\n",
    "            self.register_buffer('running_kl_loss', torch.zeros(1))\n",
    "            self.reset_parameters()\n",
    "\n",
    "    def reset_parameters(self):\n",
    "        self.running_image_loss.zero_()        \n",
    "        self.running_kl_loss.zero_()            \n",
    "\n",
    "    def forward(self, \n",
    "                outputs,\n",
    "                targets,\n",
    "                mu,\n",
    "                logvar):\n",
    "        \n",
    "        # inputs and targets are assumed to be BxCxWxH\n",
    "        assert len(outputs.shape) == len(targets.shape)\n",
    "        # assert that B, W and H are the same\n",
    "        assert outputs.size(0) == targets.size(0)\n",
    "        assert outputs.size(2) == targets.size(2)\n",
    "        assert outputs.size(3) == targets.size(3)\n",
    "        \n",
    "        assert mu.size(1) == 10\n",
    "        assert logvar.size(1) == 10\n",
    "        assert mu.size(2) == 1\n",
    "        assert logvar.size(2) == 1\n",
    "        assert mu.size(3) == 1\n",
    "        assert logvar.size(3) == 1    \n",
    "        \n",
    "        image_loss = self.image_loss(outputs, targets)\n",
    "        kl_loss = -0.5 * torch.mean(1 + logvar - mu.pow(2) - logvar.exp())\n",
    "        \n",
    "        if self.use_running_mean == False:\n",
    "            imw = self.image_loss_weight\n",
    "            kmw = self.kl_loss_weight\n",
    "        else:\n",
    "            self.running_image_loss = self.running_image_loss * self.gamma + image_loss.data * (1 - self.gamma)        \n",
    "            self.running_kl_loss = self.running_kl_loss * self.gamma + kl_loss.data * (1 - self.gamma)\n",
    "\n",
    "            im = float(self.running_image_loss)\n",
    "            km = float(self.running_kl_loss)\n",
    "\n",
    "            imw = 1 - im / (im + km)\n",
    "            kmw = 1 - km / (im + km)\n",
    "                \n",
    "        loss = image_loss * imw + kl_loss * kmw\n",
    "        \n",
    "        return loss,image_loss,kl_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "torch.mean"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# Reconstruction + KL divergence losses summed over all elements and batch\n",
    "def loss_function(recon_x, x, mu, logvar):\n",
    "    BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784), size_average=False)\n",
    "    # see Appendix B from VAE paper:\n",
    "    # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\n",
    "    # https://arxiv.org/abs/1312.6114\n",
    "    # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n",
    "    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n",
    "    return BCE + KLD"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Baseline code"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "code_folding": [
     41
    ],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from __future__ import print_function\n",
    "import argparse\n",
    "import torch\n",
    "import torch.utils.data\n",
    "from torch import nn, optim\n",
    "from torch.nn import functional as F\n",
    "from torchvision import datasets, transforms\n",
    "from torchvision.utils import save_image\n",
    "\n",
    "\n",
    "\n",
    "parser = argparse.ArgumentParser(description='VAE MNIST Example')\n",
    "parser.add_argument('--batch-size', type=int, default=128, metavar='N',\n",
    "                    help='input batch size for training (default: 128)')\n",
    "parser.add_argument('--epochs', type=int, default=10, metavar='N',\n",
    "                    help='number of epochs to train (default: 10)')\n",
    "parser.add_argument('--no-cuda', action='store_true', default=False,\n",
    "                    help='enables CUDA training')\n",
    "parser.add_argument('--seed', type=int, default=1, metavar='S',\n",
    "                    help='random seed (default: 1)')\n",
    "parser.add_argument('--log-interval', type=int, default=10, metavar='N',\n",
    "                    help='how many batches to wait before logging training status')\n",
    "args = parser.parse_args()\n",
    "args.cuda = not args.no_cuda and torch.cuda.is_available()\n",
    "\n",
    "torch.manual_seed(args.seed)\n",
    "\n",
    "\n",
    "device = torch.device(\"cuda\" if args.cuda else \"cpu\")\n",
    "\n",
    "kwargs = {'num_workers': 1, 'pin_memory': True} if args.cuda else {}\n",
    "\n",
    "train_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST('../data', train=True, download=True,\n",
    "                   transform=transforms.ToTensor()),\n",
    "    batch_size=args.batch_size, shuffle=True, **kwargs)\n",
    "\n",
    "test_loader = torch.utils.data.DataLoader(\n",
    "    datasets.MNIST('../data', train=False, transform=transforms.ToTensor()),\n",
    "    batch_size=args.batch_size, shuffle=True, **kwargs)\n",
    "\n",
    "class VAE(nn.Module):\n",
    "\n",
    "    def __init__(self):\n",
    "        super(VAE, self).__init__()\n",
    "        self.fc1 = nn.Linear(784, 400)\n",
    "        self.fc21 = nn.Linear(400, 20)\n",
    "        self.fc22 = nn.Linear(400, 20)\n",
    "        self.fc3 = nn.Linear(20, 400)\n",
    "        self.fc4 = nn.Linear(400, 784)\n",
    "\n",
    "    def encode(self, x):\n",
    "        h1 = F.relu(self.fc1(x))\n",
    "        return self.fc21(h1), self.fc22(h1)\n",
    "\n",
    "    def reparameterize(self, mu, logvar):\n",
    "        if self.training:\n",
    "            std = torch.exp(0.5*logvar)\n",
    "            eps = torch.randn_like(std)\n",
    "            return eps.mul(std).add_(mu)\n",
    "        else:\n",
    "            return mu\n",
    "\n",
    "    def decode(self, z):\n",
    "        h3 = F.relu(self.fc3(z))\n",
    "        return F.sigmoid(self.fc4(h3))\n",
    "\n",
    "    def forward(self, x):\n",
    "        mu, logvar = self.encode(x.view(-1, 784))\n",
    "        z = self.reparameterize(mu, logvar)\n",
    "        return self.decode(z), mu, logvar\n",
    "\n",
    "model = VAE().to(device)\n",
    "optimizer = optim.Adam(model.parameters(), lr=1e-3)\n",
    "\n",
    "\n",
    "# Reconstruction + KL divergence losses summed over all elements and batch\n",
    "def loss_function(recon_x, x, mu, logvar):\n",
    "    BCE = F.binary_cross_entropy(recon_x, x.view(-1, 784), size_average=False)\n",
    "    # see Appendix B from VAE paper:\n",
    "    # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\n",
    "    # https://arxiv.org/abs/1312.6114\n",
    "    # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n",
    "    KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n",
    "    return BCE + KLD\n",
    "\n",
    "\n",
    "def train(epoch):\n",
    "    model.train()\n",
    "    train_loss = 0\n",
    "    \n",
    "    for batch_idx, (data, _) in enumerate(train_loader):\n",
    "        data = data.to(device)\n",
    "        optimizer.zero_grad()\n",
    "        recon_batch, mu, logvar = model(data)\n",
    "        loss = loss_function(recon_batch, data, mu, logvar)\n",
    "        loss.backward()\n",
    "        train_loss += loss.item()\n",
    "        optimizer.step()\n",
    "\n",
    "        if batch_idx % args.log_interval == 0:\n",
    "            print('Train Epoch: {} [{}/{} ({:.0f}%)]\\tLoss: {:.6f}'.format(\n",
    "                epoch, batch_idx * len(data), len(train_loader.dataset),\n",
    "                100. * batch_idx / len(train_loader),\n",
    "                loss.item() / len(data)))\n",
    "\n",
    "    print('====> Epoch: {} Average loss: {:.4f}'.format(\n",
    "          epoch, train_loss / len(train_loader.dataset)))\n",
    "\n",
    "def test(epoch):\n",
    "    model.eval()\n",
    "    test_loss = 0\n",
    "\n",
    "    with torch.no_grad():\n",
    "        for i, (data, _) in enumerate(test_loader):\n",
    "            data = data.to(device)\n",
    "            recon_batch, mu, logvar = model(data)\n",
    "            test_loss += loss_function(recon_batch, data, mu, logvar).item()\n",
    "\n",
    "            if i == 0:\n",
    "                n = min(data.size(0), 8)\n",
    "                comparison = torch.cat([data[:n],\n",
    "                                      recon_batch.view(args.batch_size, 1, 28, 28)[:n]])\n",
    "                save_image(comparison.cpu(),\n",
    "                         'results/reconstruction_' + str(epoch) + '.png', nrow=n)\n",
    "\n",
    "    test_loss /= len(test_loader.dataset)\n",
    "    print('====> Test set loss: {:.4f}'.format(test_loss))\n",
    "\n",
    "\n",
    "for epoch in range(1, args.epochs + 1):\n",
    "    train(epoch)\n",
    "    test(epoch)\n",
    "\n",
    "    \"\"\"\n",
    "    with torch.no_grad():\n",
    "        sample = torch.randn(64, 20).to(device)\n",
    "        sample = model.decode(sample).cpu()\n",
    "        save_image(sample.view(64, 1, 28, 28),\n",
    "                   'results/sample_' + str(epoch) + '.png')\n",
    "    \"\"\""
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Training the VAE"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**The best model can be trained as follows**\n",
    "\n",
    "```\n",
    "python3 train.py \\\n",
    "\t--epochs 30 --batch-size 512 --seed 42 \\\n",
    "\t--model_type fc_conv --dataset_type fmnist --latent_space_size 10 \\\n",
    "\t--do_augs False \\\n",
    "\t--lr 1e-3 --m1 40 --m2 50 \\\n",
    "\t--optimizer adam \\\n",
    "\t--do_running_mean False --img_loss_weight 1.0 --kl_loss_weight 1.0 \\\n",
    "\t--image_loss_type bce --ssim_window_size 5 \\\n",
    "\t--print-freq 10 \\\n",
    "\t--lognumber fmnist_fc_conv_l10_rebalance_no_norm \\\n",
    "\t--tensorboard True --tensorboard_images True \\\n",
    "```\n",
    "\n",
    "If you launch this code, the copy of `FMNIST` dataset will be dowloaded automatically.\n",
    "\n",
    "Suggested alternative values for the flags for playing with them:\n",
    "- `dataset_type` - can be set to `mnist` and `fmnist`. In each case will download the necessary dataset\n",
    "- `latent_space_size` - will affect the latent space in combination with `model_type` `fc_conv` or `fc`. Other model types do not work properly\n",
    "- `m1` and `m2` control lr decay, but it did not really help here\n",
    "- `image_loss_type` can be set to `bce`, `mse` or `ssim`. In practice `bce` works best. `mse` is worse. I suppose that proper scaling is required to make it work with `ssim` (it does not train now)\n",
    "- `tensorboard`  and `tensorboard_images` can also be set to `False`. But they just write logs, so you may just not bother\n",
    "\n",
    "These flags are optional `--tensorboard True --tensorboard_images True`, in order to use them, you have to \n",
    "- install tensorboard (installs with tensorflow)\n",
    "- launch tensorboard with the following command `tensorboard --logdir='path/to/tb_logs' --port=6006`\n",
    "\n",
    "You can also resume from the best checkpoint using these flags:\n",
    "```\n",
    "python3 train.py \\\n",
    "\t--resume weights/fmnist_fc_conv_l10_rebalance_no_norm_best.pth.tar \\\n",
    "\t--epochs 60 --batch-size 512 --seed 42 \\\n",
    "\t--model_type fc_conv --dataset_type fmnist --latent_space_size 10 \\\n",
    "\t--do_augs False \\\n",
    "\t--lr 1e-3 --m1 50 --m2 100 \\\n",
    "\t--optimizer adam \\\n",
    "\t--do_running_mean False --img_loss_weight 1.0 --kl_loss_weight 1.0 \\\n",
    "\t--image_loss_type bce --ssim_window_size 5 \\\n",
    "\t--print-freq 10 \\\n",
    "\t--lognumber fmnist_resume \\\n",
    "\t--tensorboard True --tensorboard_images True \\\n",
    "```\n",
    "\n",
    "The best reconstructions are supposed to look like this (top row - original images, bottow row - reconstructions):\n",
    "![](reconstructions.png)\n",
    "\n",
    "**Brief ablation analysis of the results**\n",
    "\n",
    "**✓ What worked**\n",
    "1. Using BCE loss + KLD loss\n",
    "2. Converting a plain FC model into a conv model in the most straight-forward fashion possible, i.e. replacing this\n",
    "```\n",
    "        self.fc1 = nn.Linear(784, 400)\n",
    "        self.fc21 = nn.Linear(400, latent_space_size)\n",
    "        self.fc22 = nn.Linear(400, latent_space_size)\n",
    "        self.fc3 = nn.Linear(latent_space_size, 400)\n",
    "        self.fc4 = nn.Linear(400, 784)\n",
    "```        \n",
    "with this\n",
    "```\n",
    "        self.fc1 = nn.Conv2d(1,32, kernel_size=(28,28), stride=1, padding=0)\n",
    "        self.fc21 = nn.Conv2d(32,latent_space_size, kernel_size=(1,1), stride=1, padding=0)\n",
    "        self.fc22 = nn.Conv2d(32,latent_space_size, kernel_size=(1,1), stride=1, padding=0)\n",
    "        \n",
    "        self.fc3 = nn.ConvTranspose2d(latent_space_size,118, kernel_size=(1,1),  stride=1, padding=0)\n",
    "        self.fc4 = nn.ConvTranspose2d(118,1, kernel_size=(28,28),  stride=1, padding=0)\n",
    "```        \n",
    "3. Using `SSIM` as visualization metric. It correlates awesomely with perceived visual similarity of the image and its reconstruction\n",
    "\n",
    "\n",
    "**✗ What did not work**\n",
    "1. Extracting `mean` and `std` from images - removing this feature boosted SSIM on FMNIST 4-5x\n",
    "2. Doing any simple augmentations (unsurprisingly - it adds complexity)\n",
    "3. Any architectures beyond the most obvious ones:\n",
    "    - UNet inspired architectures (my speculation - this is because image size is very small, and very global features work best, i.e. feature extraction cascade is overkill)\n",
    "    - I tried various combinations of convolution weights, all of them did not work\n",
    "    - 1xN convolutions\n",
    "4. `MSE` loss performed poorly, `SSIM` loss did not work at all\n",
    "5. LR decay, as well as any LR besides `1e-3` (with adam) does not really help\n",
    "6. Increasing latent space to `20` or `100` does not really change much\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Comparing VAE / PCA / UMAP"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T07:51:57.009186Z",
     "start_time": "2018-06-28T07:51:57.006754Z"
    },
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "## Sampler function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:29:57.680275Z",
     "start_time": "2018-06-28T13:29:56.119810Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((100, 784), (100,))"
      ]
     },
     "execution_count": 1,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from FMNISTDataset import FMNISTDataset\n",
    "fmnist = FMNISTDataset(random_state = 42,\n",
    "                       use_augs = False)\n",
    "X_sample,y_sample = fmnist.stratified_sample(10)\n",
    "X_sample.shape,y_sample.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:29:59.261457Z",
     "start_time": "2018-06-28T13:29:58.563967Z"
    },
    "code_folding": [
     3
    ],
    "hidden": true,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1152x1152 with 25 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "def visualize_mnist(X, y, field_size=10):\n",
    "    FIELD_SIZE = field_size\n",
    "\n",
    "    ind = np.random.randint(0, X.shape[0], FIELD_SIZE*FIELD_SIZE)\n",
    "    X_vis = X[ind, :].reshape(FIELD_SIZE, FIELD_SIZE, 28, 28) \n",
    "    y_vis = y[ind].reshape(FIELD_SIZE, FIELD_SIZE)\n",
    "\n",
    "    plt.figure(figsize=(16, 16))\n",
    "\n",
    "    for i in range(FIELD_SIZE):\n",
    "        for j in range(FIELD_SIZE):\n",
    "            plt.subplot(FIELD_SIZE, FIELD_SIZE, i*FIELD_SIZE+j+1)\n",
    "            plt.imshow(X_vis[i, j, :], cmap=plt.cm.Greys)\n",
    "            plt.gca().xaxis.set_ticks([])\n",
    "            plt.gca().yaxis.set_ticks([])\n",
    "            plt.title(y_vis[i, j])\n",
    "    plt.tight_layout()\n",
    "    plt.show()\n",
    "    \n",
    "visualize_mnist(X_sample,y_sample,field_size=5)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T08:50:17.768211Z",
     "start_time": "2018-06-28T08:50:17.766175Z"
    },
    "hidden": true
   },
   "source": [
    "## Task 2.2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Visualize data and produce embeddings"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:30:02.497660Z",
     "start_time": "2018-06-28T13:30:01.651893Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "from FMNISTDataset import FMNISTDataset\n",
    "fmnist = FMNISTDataset(random_state = 42,\n",
    "                       use_augs = False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:30:02.502836Z",
     "start_time": "2018-06-28T13:30:02.499281Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((60000, 784), (60000,))"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X = fmnist.X\n",
    "y = fmnist.y\n",
    "X.shape,y.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T08:59:49.139468Z",
     "start_time": "2018-06-28T08:59:49.136406Z"
    },
    "hidden": true
   },
   "source": [
    "If you want to try UMAP, just\n",
    "```\n",
    "conda install -c conda-forge umap-learn\n",
    "```\n",
    "If you want to try datashader, just \n",
    "```\n",
    "conda install datashader\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:30:06.210413Z",
     "start_time": "2018-06-28T13:30:05.574288Z"
    },
    "code_folding": [
     4
    ],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# https://github.com/lmcinnes/umap\n",
    "import umap   \n",
    "from sklearn.decomposition import PCA\n",
    "\n",
    "def project_features(n_components,\n",
    "                     method):\n",
    "    if method == 'pca':\n",
    "        pca = PCA(n_components=n_components)\n",
    "        pca.fit(X)\n",
    "        print('PCA explained ratio {}'.format(sum(pca.explained_variance_ratio_))) \n",
    "        X_transformed = pca.transform(X)\n",
    "        return X_transformed,pca\n",
    "    elif method == 'umap':\n",
    "        umap_ = umap.UMAP(\n",
    "            n_neighbors=5,\n",
    "            n_components=n_components,\n",
    "            min_dist=0.1,\n",
    "            metric='euclidean',\n",
    "            init='random'\n",
    "        )\n",
    "        X_transformed = umap_.fit_transform(X)\n",
    "        return X_transformed,umap_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:30:11.882832Z",
     "start_time": "2018-06-28T13:30:06.811392Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PCA explained ratio 0.4679453789952793\n",
      "Time to run 2 PCA: 2.67220401763916\n",
      "PCA explained ratio 0.7199082694865548\n",
      "Time to run 10 PCA: 5.068034410476685\n"
     ]
    }
   ],
   "source": [
    "import time\n",
    "start_time = time.time()\n",
    "\n",
    "X_transformed_pca_2,pca = project_features(2,'pca')\n",
    "print('Time to run 2 PCA: {}'.format( time.time() - start_time))\n",
    "\n",
    "X_transformed_pca_10,pca = project_features(10,'pca')\n",
    "print('Time to run 10 PCA: {}'.format( time.time() - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:32:29.233563Z",
     "start_time": "2018-06-28T13:30:11.884059Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Time to run 2 UMAP: 70.59682059288025\n",
      "Time to run 10 UMAP: 142.4183316230774\n"
     ]
    }
   ],
   "source": [
    "X_transformed_umap_2,umap_ = project_features(2,'umap')\n",
    "print('Time to run 2 UMAP: {}'.format( time.time() - start_time))\n",
    "X_transformed_umap_10,umap_ = project_features(10,'umap')\n",
    "print('Time to run 10 UMAP: {}'.format( time.time() - start_time))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:32:29.238111Z",
     "start_time": "2018-06-28T13:32:29.235006Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((60000, 2), (60000, 10))"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_transformed_pca_2.shape,X_transformed_pca_10.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:32:29.448584Z",
     "start_time": "2018-06-28T13:32:29.239376Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df_pca = pd.DataFrame()\n",
    "df_pca['pca1'] = X_transformed_pca_2[:,0]\n",
    "df_pca['pca2'] = X_transformed_pca_2[:,1]\n",
    "df_pca['cat']  = y\n",
    "df_pca['cat']  = df_pca['cat'].astype(\"category\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:32:29.458034Z",
     "start_time": "2018-06-28T13:32:29.449973Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_umap = pd.DataFrame()\n",
    "df_umap['umap1'] = X_transformed_umap_2[:,0]\n",
    "df_umap['umap2'] = X_transformed_umap_2[:,1]\n",
    "df_umap['cat']  = y\n",
    "df_umap['cat']  = df_umap['cat'].astype(\"category\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:32:30.546717Z",
     "start_time": "2018-06-28T13:32:29.459250Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table style=\"width:100%; text-align: center\"><tbody><tr style=\"background-color:white\"><td style=\"text-align: center\"><b>PCA</b><br><br><img style=\"margin: auto; border:1px solid\" src='data:image/png;base64,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'/></td><td style=\"text-align: center\"><b>UMAP</b><br><br><img style=\"margin: auto; border:1px solid\" src='data:image/png;base64,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'/></td></tr></tbody></table>"
      ],
      "text/plain": [
       "<datashader.transfer_functions.Images at 0x7fee528ef208>"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# following this tutorial \n",
    "# http://datashader.org/getting_started/2_Pipeline.html\n",
    "import datashader as ds\n",
    "import datashader.transfer_functions as tf\n",
    "\n",
    "canvas = ds.Canvas(plot_width=400, plot_height=400, \n",
    "                   x_range=(-2000,2000), y_range=(-2000,2000), \n",
    "                   x_axis_type='linear', y_axis_type='linear')\n",
    "aggc = canvas.points(df_pca, 'pca1', 'pca2', ds.count_cat('cat'))\n",
    "\n",
    "canvas = ds.Canvas(plot_width=400, plot_height=400, \n",
    "                   x_range=(-11,11), y_range=(-11,11), \n",
    "                   x_axis_type='linear', y_axis_type='linear')\n",
    "aggc_umap = canvas.points(df_umap, 'umap1', 'umap2', ds.count_cat('cat'))\n",
    "\n",
    "tf.Images(tf.shade(aggc, name=\"PCA\"),\n",
    "          tf.shade(aggc_umap, name=\"UMAP\"))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### Bench KNN"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:38:34.039109Z",
     "start_time": "2018-06-28T13:38:34.031501Z"
    },
    "code_folding": [
     5,
     23
    ],
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import random \n",
    "from sklearn.neighbors import KNeighborsClassifier\n",
    "from sklearn.model_selection import StratifiedKFold\n",
    "\n",
    "def stratified_sample(X,\n",
    "                      y,\n",
    "                      images_per_class):\n",
    "\n",
    "    all_targets = list(y)\n",
    "    samples = []\n",
    "    targets = []\n",
    "\n",
    "    for target_value in set(all_targets):\n",
    "        indices = [i for i, e in enumerate(all_targets) if e == target_value]\n",
    "        random.shuffle(indices)\n",
    "        # produce max images_per_class\n",
    "        indices = indices[:images_per_class]\n",
    "        samples.append(X[np.asarray(indices)])\n",
    "        targets.append(y[np.asarray(indices)])\n",
    "\n",
    "    return np.vstack(samples),np.vstack(targets).reshape(-1)\n",
    "\n",
    "def bench_knn(X,y,\n",
    "              samples_per_class = [50, 100, 500, 1000, 3000],\n",
    "              n_neighbours = [1,5,10,25,50]):\n",
    "    \n",
    "    stat_df = pd.DataFrame(columns=['samples_per_class','n_neighbours','accuracy'])\n",
    "\n",
    "    for samples in samples_per_class:\n",
    "        for neighbours in n_neighbours:\n",
    "\n",
    "            X_,y_ =  stratified_sample(X,y,samples)\n",
    "\n",
    "            skf = StratifiedKFold(n_splits = 5,\n",
    "                                  shuffle = True,\n",
    "                                  random_state = 42)\n",
    "\n",
    "            f1, f2, f3, f4, f5 = skf.split(X_,y_)\n",
    "            folds = [f1, f2, f3, f4, f5]\n",
    "\n",
    "            accuracies = []\n",
    "\n",
    "            for fold in folds:\n",
    "                train_idx = fold[0]\n",
    "                val_idx = fold[1] \n",
    "\n",
    "                knn_params = {'n_neighbors':neighbours,\n",
    "                     'weights':'distance',\n",
    "                     'n_jobs':6}\n",
    "\n",
    "                knn = KNeighborsClassifier(**knn_params)\n",
    "                knn.fit(X_[train_idx], y_[train_idx]) \n",
    "                accuracy = knn.score(X_[val_idx],y_[val_idx])\n",
    "                accuracies.append(accuracy)\n",
    "\n",
    "            # this is NOT a proper way to measure this!\n",
    "            # ideally you should go for some variation of ROC AUC score\n",
    "            mean_accuracy = sum(accuracies)/len(accuracies)\n",
    "            stat_df = stat_df.append(pd.DataFrame(columns=['samples_per_class','n_neighbours','accuracy'],data=[[samples,neighbours,mean_accuracy]]))\n",
    "        \n",
    "    return stat_df"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T11:00:35.205912Z",
     "start_time": "2018-06-28T11:00:32.103698Z"
    },
    "hidden": true,
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "!pip install seaborn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:37:45.994388Z",
     "start_time": "2018-06-28T13:37:45.969245Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:39:00.264572Z",
     "start_time": "2018-06-28T13:38:40.358548Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 461x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# try benching with 10 dimensional data with PCA\n",
    "stat_df = bench_knn(X_transformed_pca_10,y)\n",
    "g = sns.lmplot(x=\"n_neighbours\", y=\"accuracy\", hue=\"samples_per_class\", data=stat_df, fit_reg=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:40:16.623019Z",
     "start_time": "2018-06-28T13:40:16.615897Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>samples_per_class</th>\n",
       "      <th>n_neighbours</th>\n",
       "      <th>accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>1</td>\n",
       "      <td>0.7476</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>5</td>\n",
       "      <td>0.7766</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>10</td>\n",
       "      <td>0.7724</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>25</td>\n",
       "      <td>0.7746</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>50</td>\n",
       "      <td>0.7494</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  samples_per_class n_neighbours  accuracy\n",
       "0               500            1    0.7476\n",
       "0               500            5    0.7766\n",
       "0               500           10    0.7724\n",
       "0               500           25    0.7746\n",
       "0               500           50    0.7494"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stat_df[stat_df.samples_per_class==500]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:40:50.617597Z",
     "start_time": "2018-06-28T13:40:34.249491Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 461x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# try benching with 10 dimensional data with UMAP\n",
    "stat_df = bench_knn(X_transformed_umap_10,y)\n",
    "g = sns.lmplot(x=\"n_neighbours\", y=\"accuracy\", hue=\"samples_per_class\", data=stat_df, fit_reg=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:40:58.613958Z",
     "start_time": "2018-06-28T13:40:58.607299Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>samples_per_class</th>\n",
       "      <th>n_neighbours</th>\n",
       "      <th>accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>1</td>\n",
       "      <td>0.7604</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>5</td>\n",
       "      <td>0.7974</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>10</td>\n",
       "      <td>0.8064</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>25</td>\n",
       "      <td>0.7990</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>50</td>\n",
       "      <td>0.7946</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  samples_per_class n_neighbours  accuracy\n",
       "0               500            1    0.7604\n",
       "0               500            5    0.7974\n",
       "0               500           10    0.8064\n",
       "0               500           25    0.7990\n",
       "0               500           50    0.7946"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stat_df[stat_df.samples_per_class==500]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:41:26.418706Z",
     "start_time": "2018-06-28T13:41:25.991507Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.7693\n"
     ]
    }
   ],
   "source": [
    "# Report the accuracy on the test set (the one remained untouched)\n",
    "knn_params = {'n_neighbors':5,\n",
    "     'weights':'uniform',\n",
    "     'n_jobs':6}\n",
    "\n",
    "X_,y_ =  stratified_sample(X_transformed_pca_10,y,500)\n",
    "X_test, y_test = fmnist.X_test, fmnist.y_test\n",
    "X_test_transformed = pca.transform(X_test)\n",
    "\n",
    "knn = KNeighborsClassifier(**knn_params)\n",
    "knn.fit(X_, y_) \n",
    "accuracy = knn.score(X_test_transformed,y_test)\n",
    "print(accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "UMAP API does not contain the same transform function, that can be applied after fit.\n",
    "https://github.com/lmcinnes/umap/issues/55"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "## Task 2.3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:00.022862Z",
     "start_time": "2018-06-28T13:42:59.036499Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((60000, 784), (60000,))"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from FMNISTDataset import FMNISTDataset\n",
    "fmnist = FMNISTDataset(random_state = 42,\n",
    "                       use_augs = False)\n",
    "X = fmnist.X\n",
    "y = fmnist.y\n",
    "X.shape,y.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:01.836386Z",
     "start_time": "2018-06-28T13:43:01.614656Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "ls: cannot access 'laht': No such file or directory\r\n",
      "weights/fmnist_fc_conv_l10_rebalance_no_norm_best.pth.tar\r\n",
      "weights/fmnist_fc_conv_l10_rebalance_no_norm_checkpoint.pth.tar\r\n"
     ]
    }
   ],
   "source": [
    "!ls laht weights/fmnist_fc_conv_l10_rebalance_no_norm_*"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:12.837653Z",
     "start_time": "2018-06-28T13:43:06.974443Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Total model parameters 119591\n",
      "=> loading checkpoint 'weights/fmnist_fc_conv_l10_rebalance_no_norm_best.pth.tar'\n",
      "=> loaded checkpoint (epoch 30)\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "import torch.nn as nn\n",
    "import torch.utils.data\n",
    "from torch.nn import Sigmoid\n",
    "from VAE import VAEBaselineConv\n",
    "from FMNISTDataset import FMNISTDataset\n",
    "\n",
    "cuda = True\n",
    "device = torch.device(\"cuda\" if cuda else \"cpu\")\n",
    "kwargs = {'num_workers': 0, 'pin_memory': True} if cuda else {}\n",
    "\n",
    "model = VAEBaselineConv(latent_space_size=10).to(device)\n",
    "\n",
    "resume = 'weights/fmnist_fc_conv_l10_rebalance_no_norm_best.pth.tar'\n",
    "print(\"=> loading checkpoint '{}'\".format(resume))\n",
    "checkpoint = torch.load(resume)\n",
    "model.load_state_dict(checkpoint['state_dict'])\n",
    "print(\"=> loaded checkpoint (epoch {})\".format(checkpoint['epoch']))\n",
    "\n",
    "\n",
    "eval_train_dataset = FMNISTDataset(mode = 'eval_train',\n",
    "                                   random_state = 42,\n",
    "                                   use_augs = False)\n",
    "\n",
    "eval_test_dataset = FMNISTDataset(mode = 'eval_test',\n",
    "                                   random_state = 42,\n",
    "                                   use_augs = False)\n",
    "\n",
    "eval_train_loader = torch.utils.data.DataLoader(\n",
    "    eval_train_dataset,\n",
    "    batch_size=512,        \n",
    "    shuffle=False,\n",
    "    drop_last=False,\n",
    "    **kwargs)            \n",
    "\n",
    "eval_test_loader = torch.utils.data.DataLoader(\n",
    "    eval_test_dataset,\n",
    "    batch_size=512,        \n",
    "    shuffle=False,\n",
    "    drop_last=False,\n",
    "    **kwargs)    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:19.263033Z",
     "start_time": "2018-06-28T13:43:14.704766Z"
    },
    "code_folding": [],
    "hidden": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 118/118 [00:04<00:00, 25.93it/s]\n"
     ]
    }
   ],
   "source": [
    "import tqdm\n",
    "\n",
    "train_vae_embeddings = []\n",
    "train_y_values = []\n",
    "test_vae_embeddings = []\n",
    "\n",
    "# collect embeddings for the train dataset\n",
    "with tqdm.tqdm(total=len(eval_train_loader)) as pbar:\n",
    "    with torch.no_grad():\n",
    "        for i, (input, target) in enumerate(eval_train_loader):\n",
    "            input = input.float().to(device)\n",
    "            out, mu, logvar = model(input)\n",
    "            \n",
    "            train_vae_embeddings.append(mu.cpu().numpy().reshape(-1,10))\n",
    "            train_y_values.append(target.cpu().numpy())\n",
    "            pbar.update(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:34.593360Z",
     "start_time": "2018-06-28T13:43:33.822104Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 20/20 [00:00<00:00, 26.08it/s]\n"
     ]
    }
   ],
   "source": [
    "# collect embeddings for the train dataset\n",
    "with tqdm.tqdm(total=len(eval_test_loader)) as pbar:\n",
    "    with torch.no_grad():\n",
    "        for i, (input, target) in enumerate(eval_test_loader):\n",
    "            input = input.float().to(device)\n",
    "            out, mu, logvar = model(input)\n",
    "            test_vae_embeddings.append(mu.cpu().numpy().reshape(-1,10))\n",
    "            pbar.update(1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:37.842754Z",
     "start_time": "2018-06-28T13:43:37.838661Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(60000,)"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "train_y_values = np.concatenate(train_y_values)\n",
    "train_y_values.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:39.624152Z",
     "start_time": "2018-06-28T13:43:39.622092Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "# check that generators worked correctly \n",
    "assert (train_y_values==y).all()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:40.794930Z",
     "start_time": "2018-06-28T13:43:40.791573Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "train_vae_embeddings = np.concatenate(train_vae_embeddings)\n",
    "test_vae_embeddings = np.concatenate(test_vae_embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:42.356182Z",
     "start_time": "2018-06-28T13:43:42.353204Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "((60000, 10), (10000, 10))"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "train_vae_embeddings.shape,test_vae_embeddings.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:44.870668Z",
     "start_time": "2018-06-28T13:43:44.822420Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "PCA explained ratio 0.41148026287555695\n"
     ]
    }
   ],
   "source": [
    "from sklearn.decomposition import PCA\n",
    "pca = PCA(n_components=2)\n",
    "pca.fit(train_vae_embeddings)\n",
    "print('PCA explained ratio {}'.format(sum(pca.explained_variance_ratio_))) \n",
    "train_vae_embeddings_pca_2 = pca.transform(train_vae_embeddings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:46.042293Z",
     "start_time": "2018-06-28T13:43:46.032965Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "df_pca = pd.DataFrame()\n",
    "df_pca['pca1'] = train_vae_embeddings_pca_2[:,0]\n",
    "df_pca['pca2'] = train_vae_embeddings_pca_2[:,1]\n",
    "df_pca['cat']  = y\n",
    "df_pca['cat']  = df_pca['cat'].astype(\"category\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:43:48.101387Z",
     "start_time": "2018-06-28T13:43:47.792275Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<table style=\"width:100%; text-align: center\"><tbody><tr style=\"background-color:white\"><td style=\"text-align: center\"><b>VAE</b><br><br><img style=\"margin: auto; border:1px solid\" src='data:image/png;base64,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'/></td></tr></tbody></table>"
      ],
      "text/plain": [
       "<datashader.transfer_functions.Images at 0x7fee78f34c50>"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# following this tutorial \n",
    "# http://datashader.org/getting_started/2_Pipeline.html\n",
    "import datashader as ds\n",
    "import datashader.transfer_functions as tf\n",
    "\n",
    "canvas = ds.Canvas(plot_width=400, plot_height=400, \n",
    "                   x_range=(-4,4), y_range=(-4,4), \n",
    "                   x_axis_type='linear', y_axis_type='linear')\n",
    "aggc = canvas.points(df_pca, 'pca1', 'pca2', ds.count_cat('cat'))\n",
    "\n",
    "tf.Images(tf.shade(aggc, name=\"VAE\"))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:19:03.027540Z",
     "start_time": "2018-06-28T13:19:02.667036Z"
    },
    "hidden": true
   },
   "source": [
    "Let's compare the embeddings\n",
    "![](compare.png)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:44:21.527958Z",
     "start_time": "2018-06-28T13:43:59.513066Z"
    },
    "hidden": true
   },
   "outputs": [],
   "source": [
    "stat_df = bench_knn(train_vae_embeddings,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:44:21.538487Z",
     "start_time": "2018-06-28T13:44:21.529672Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>samples_per_class</th>\n",
       "      <th>n_neighbours</th>\n",
       "      <th>accuracy</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>1</td>\n",
       "      <td>0.7890</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>5</td>\n",
       "      <td>0.8028</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>10</td>\n",
       "      <td>0.8076</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>25</td>\n",
       "      <td>0.8062</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>500</td>\n",
       "      <td>50</td>\n",
       "      <td>0.7966</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  samples_per_class n_neighbours  accuracy\n",
       "0               500            1    0.7890\n",
       "0               500            5    0.8028\n",
       "0               500           10    0.8076\n",
       "0               500           25    0.8062\n",
       "0               500           50    0.7966"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "stat_df[stat_df.samples_per_class==500]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:44:21.786424Z",
     "start_time": "2018-06-28T13:44:21.540017Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAbwAAAFgCAYAAADATMyLAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMi4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvhp/UCwAAIABJREFUeJzt3Xt8VOW1N/DfmksyAZIAISSQkAuSC0kAlRyqHECqB4QCClJbqPYIWKWl9nhtq7ViRWv1RXu02lqqBX19q4hKFW8gUm4KtgYFTELCzQQSSAiQC5dc5rLeP2ZiJyHghMwwM9m/7+eTz2Q/e8/ea8MkK8/ez36WqCqIiIi6O1OwAyAiIroQmPCIiMgQmPCIiMgQmPCIiMgQmPCIiMgQmPCIiMgQmPCIiMgQmPCIiMgQmPCIiMgQLMEOwF8mTZqkq1evDnYYRGQ8EuwAyDfdpod39OjRYIdAREQhrNskPCIionNhwiMiIkNgwiMiIkNgwiMiIkNgwiMiIkNgwiMiIkNgwiMiIkNgwiMiIkNgwiMiIkNgwiMiIkNgwiMiIkPoNpNHE/mqvPAovvjwABqONSEmzoZLJqYgNa9fsMMiogBjD48MpbzwKDYt341T9S2I7GHBqfoWbFq+G+WFnHycqLtjwiND+eLDAzCZTbBGmiEisEaaYTKb8MWHB4IdGhEFGBMeGUrDsSZYItp+7C0RJjQcawpSRER0oTDhkaHExNngaHG1aXO0uBATZwtSRER0oTDhkaFcMjEFLqcL9mYnVBX2ZidcThcumZgS7NCIKMCY8MhQUvP6YdysTPSMjUDzaQd6xkZg3KxMjtIkMgA+lkCGk5rXjwmO+HiKATHhhTH+wBKdn9bHU0xmU5vHU8bNAn+GujFe0gxTfJ6M6Pzx8RRjYsILU/yBJTp/fDzFmJjwwhR/YInOHx9PMSYmvDDFH1ii88fHU4yJCS9M8QeW6Pzx8RRjElUNdgx+kZ+frwUFBcEOA8CFGz3JUZpEIUGCHQD5hgnPz7yHO1siTHC0uOByuvjXI1H3xYQXJnhJ0884epKIKDQx4fkZR08SEYUmJjw/4+hJIqLQxITnZxw9SUQUmpjw/IzDnYmIQhMnjw4AzsZPRBR6AtrDE5FJIlIqIntF5N4O1qeIyHoR+UJEdorIdzztE0Rkm4h86Xm9MpBxEhFR9xewHp6ImAH8EcAEABUAPhORVapa7LXZrwGsUNXnRCQHwPsA0gAcBTBNVQ+JSB6ANQCSAhUrERF1f4Hs4Y0CsFdV96tqC4DlAK5tt40CiPF8HwvgEACo6heqesjTXgTAJiKRAYyViIi6uUAmvCQAB72WK3BmL+03AG4UkQq4e3c/62A/MwF8oarN7VeIyK0iUiAiBTU1Nf6JmoiIuqVAJryOpttpP4/ZbAAvqmoygO8AeFlEvo5JRHIBPA5gfkcHUNW/qGq+qubHx8f7KWwiIuqOApnwKgAM8lpOhueSpZebAawAAFXdCsAGoB8AiEgygL8D+G9V3RfAOImIyAACmfA+A5AhIukiEgFgFoBV7bY5AOAqABCRoXAnvBoR6Q3gPQD3qeonAYyRiIgMImAJT1UdAG6De4TlLrhHYxaJyCIRucaz2d0AbhGRHQBeBTBH3eUbbgMwBMADIrLd89U/ULESEVH3x/JARERdw/JAYYJTixERkSEw4RERkSEw4RERkSEw4RERkSEw4RERkSGwPFAYO7FpE47/dSnsFRWwJiej783zED1uXLDDIiIKSezhhakTmzahetHDcNTUwBQbC0dNDaoXPYwTmzYFOzQiopDEhBemjv91KSQiAqaoKIiI+zUiAsf/ujTYoRERhSQmvDBlr6iA2Gxt2sRmg72iIkgRERGFNia8MGVNToY2NbVp06YmWJOTgxQREVFoY8ILgBObNqH8pjnYe9V/ofymOQG5r9b35nnQlha4Ghuhqu7Xlhb0vXme349FRNQdMOH52YUaTBI9bhwSFj4AS3w8XPX1sMTHI2HhAxylSUR0Fpw82s/Kb5rjTnZRUV+3uRobYYmPR+pLLwYvMCIKFE4eHSbYw/MzDiYhIgpNTHh+xsEkREShiQnPzziYhIgoNDHh+RkHkxARhSbOpRkA0ePGMcEREYUY9vCIiMgQmPCIiMgQeEmTDIdllYiMiT08MhSWVSIyLiY8MhSWVSIyLiY8MhTOhENkXEx4ZCicCYfIuJjwyFA4Ew6RcXGUZhjbXLEZLxa9iMqTlUjqlYQ5uXMwNnlssMMKadHjxgELH+AoTSIDYnmgMLW5YjMe/eejsJqtsJltaHI2we6041ff+hWTHtGFxfJAYYKXNMPUi0Uvwmq2IsriHm0YZYmC1WzFi0UvBjs0IqKQxIQXpipPVsJmbjva0Ga2ofJkZZAiIiIKbbyHF6aSeiWhprEGUZZ/V1ZvcjYhqVdSEKMKD7z3SQBn3DEi9vDC1JzcObA77Wh0uEcbNjoaYXfaMSd3TrBDC2mt9z5rGmsQExGDmsYaPPrPR7G5YnOwQ6MLiDPuGBMTXpgamzwWv/rWrxAfFY+GlgbER8VzwIoPeO+TAM64Y1S8pBnGxiaPZYLrpMqTlYiJiGnTxnufxmOvqIApNrZNG2fc6f7YwyNDSeqVhCZn25lWeO/TeDjjjjEx4ZGh8N4nAZxxx6iY8MhQeO+TAPeMOwkLH4AlPh6u+npY4uORsPABjtLs5jjTChFR13CmlTDBHh4RERkCR2kGAB9sJiIKPezh+RkfbCYiCk1MeH7GB5uJiEITE56fcVJnIqLQxITnZ3ywmYgoNDHh+RkfbCYiCk1MeH7GB5uJiEITH0sIAE7qTEQUegLawxORSSJSKiJ7ReTeDtaniMh6EflCRHaKyHe81t3neV+piFwdyDiJiKj7C1gPT0TMAP4IYAKACgCficgqVS322uzXAFao6nMikgPgfQBpnu9nAcgFMBDARyKSqarOQMVLRETdWyB7eKMA7FXV/araAmA5gGvbbaMAWouTxQI45Pn+WgDLVbVZVb8CsNezPyIiovMSyISXBOCg13KFp83bbwDcKCIVcPfuftaJ90JEbhWRAhEpqKmp8VfcRETUDQUy4XU0g3j70gyzAbyoqskAvgPgZREx+fheqOpfVDVfVfPj4+O7HDAREXVfgRylWQFgkNdyMv59ybLVzQAmAYCqbhURG4B+Pr6XiIjIZ4Hs4X0GIENE0kUkAu5BKKvabXMAwFUAICJDAdgA1Hi2myUikSKSDiADwL8CGCsREXVzAevhqapDRG4DsAaAGcBSVS0SkUUAClR1FYC7ATwvInfCfclyjror0haJyAoAxQAcAH7KEZpERNQVrHhORNQ1rHgeJjjTChEZEgs1Gw/n0iQiw2GhZmNiwiMiw2GhZmNiwiMiw2GhZmNiwiMiw2GhZmNiwiMiw2GhZmNiwiMiw2GhZmPiYwlEZEgs1Gw87OEREZEhMOEREZEhMOEREZEhMOEREZEhMOEREZEhMOEREZEhMOEREZEhMOEREZEhMOEREZEhMOEREZEhMOEREZEhcC5NIqIu2rZtW3+LxfICgDywIxFsLgCFDofjRyNHjjzivYIJj4ioiywWywuJiYlD4+Pja00mkwY7HiNzuVxSU1OTU1VV9QKAa7zX8S8RIqKuy4uPj29gsgs+k8mk8fHx9XD3ttswfA9vc8VmvFj0IipPViKpVxLm5M5hyRAi6iwTk13o8PxfnNGhM3TC21yxGc+/9wqGlI/F0MbeOB1Vh+fLXgGmgEmPiKibMfQlzTfXrcGwkgmwNUfDYW2GrTkaw0om4M11a4IdGhGRz0aNGpW1adOmHsGOo7PuuuuugQsXLky4UMczdMLrXXIR1OSCy+IABHBZHFCTC71LLgp2aEREYcfhcAQ7hHMydMKLaY6Dw2Rv0+Yw2RHTHBekiIiou2hoaDCNHz9+SFZWVk5GRkbu888/3+eee+4ZkJeXNzQjIyN39uzZqS6XC4C7h3bzzTcPys/Pzxo8eHDuxo0be0ycOPGi1NTUvP/5n/8ZCAClpaUR6enpudddd11aZmZmzqRJkwafOHHijN/hK1eujLn44ouzc3Jyhk6ePHlwfX29CQAWLFiQdNFFF+VmZmbm3Hrrrclni3vmzJlpP/jBD1JGjhyZlZaWlvfqq6/GAu5kNn/+/OS8vLyhmZmZOYsXL+4HAO+++270t771rcxp06alZ2Vl5Z5tv88++2xcZmZmTlZWVs706dPT269/8skn++Xl5Q3NysrKufrqqy9qPbelS5f2ycjIyM3KysrJz8/PAoCCggLbsGHDhmZnZ+dkZmbmfPnll5G+/J8YOuH1jY+GyWmGS10AFC51weQ0o298dLBDI6Iwt3LlypjExER7aWlp8Z49e4quu+66hp///OdHCgsLd+3Zs6eosbHRtHz58tjW7SMiIlwFBQWlc+fOrbn++uuHPP/88wdKSkqKXnvttX5VVVVmACgrK7P9+Mc/rtm9e3dxdHS0a/HixfHexzx8+LDl0UcfHbBp06bdxcXFuy699NLTDz/8cEJ1dbX5/fff77Nnz56i3bt3Fz/66KOHzxX7wYMHI//1r3+VvvPOO3vuuOOO1NOnT8tTTz3VLzY21llYWLhrx44du1566aX4kpKSCADYuXNnz8WLF1fu27evqKP9FRQU2J544okBGzdu3F1aWlq8ZMmSA+23ueGGG2oLCwt3lZaWFmdlZTX+4Q9/6AcAjz322IAPP/xwd2lpafHq1av3AsAzzzwTv2DBguqSkpLinTt37kpPT2/x5f/E0Anv29OGIS6iHyJckXA6XYhwRSIuoh++PW1YsEMjojB36aWXNm7evDnmJz/5SdLq1at7xcXFOT/44IPo4cOHZ2dmZuZs2bIlurCwMKp1+xkzZtQBwIgRIxqHDBnSmJqaao+KitJBgwY179+/PwIAEhMTWyZOnHgKAH74wx8e27JlSy/vY27YsKHnvn37bKNGjcrOzs7OWb58edyBAwci+vbt64yMjHTNmjUr9aWXXurdq1cv17linzlz5nGz2Yxhw4Y1Dxo0qHn79u22jz76KGbFihVx2dnZOZdccsnQ2tpaS3FxsQ0Ahg8ffio7O/usSWfNmjUx06ZNqx0wYIADABISEpztt9m2bVvUyJEjszIzM3PefPPNuKKiIhsA5Ofnn7zhhhvSnnzyyX6tl0wvv/zyU08++eSA+++/P3HPnj0RvXr18mmErKETXmpeP0y8cTiGDEzDoMg0DBmYhok3DkdqXr9gh0ZEYW748OHNn3/+efGwYcMa77///qR77rlnwN133526cuXKfbt37y6+8cYbjzY1NX39O9hmsykAmEwmREZGfv0L3GQyweFwCACISJtjtF9WVYwZM6ahpKSkuKSkpHjfvn1FK1asKLdardi+ffuumTNn1r311lu9x48fn3Gu2Ds6jqrKk08+eaB135WVlV9ed911DQDQo0ePcyZQVYWInDMp3XrrrenPPvvsgd27dxf/8pe/PNTc3GwCgFdeeeXAI488cujgwYMRF198cW5VVZX5xz/+8fG33357b1RUlGvy5MmZq1at8umynKETHuBOetPvuhT//dvRmH7XpUx2ROQXZWVl1ujoaNeCBQuO33HHHdXbt2/vAQCJiYmO+vp60zvvvNOns/s8fPhwxEcffdQTAF555ZW+o0ePPum9fvz48acKCgp6FRYWRgLAiRMnTDt37oysr683HT9+3Pz973+//s9//vPBXbt2nXNE58qVK/s4nU4UFRVFHjx4MHLEiBFNEyZMqH/uuefim5ubBQB27twZ2dDQ4FMOmTRpUsOqVav6tl6ara6uNrff5vTp06aUlBR7c3OzLF++vG9re1FRUeSVV1556qmnnjrUp08fx/79+yOKi4sjhg4d2vzrX//6yMSJE+u2b98e1X5/HTH0c3hERIGybdu2qPvuuy/ZZDLBYrHon/70p/I33nijd05OTm5ycnLLiBEjTnV2n4MHD25aunRp3IIFC1LT09Ob77nnnhrv9QMHDnQsWbKkbNasWYNbWloEAB588MHK2NhY19SpU4e0JqtHHnnk4LmOM2TIkOZRo0ZlHTt2zPrUU0+V9+jRQ++8886jZWVlkcOGDRuqqtK3b1/7+++/v8+XuPPz85vuvvvuw2PHjs02mUyal5d3+s033yzz3ubee+89NGrUqKFJSUktQ4cOPX3y5EkzANx5553JZWVlkaoqY8aMabjssssa77///sTXX389zmKxaHx8vP13v/vdIV/iENVvvvQpIm8CWArgA1U9Z9c1WPLz87WgoCDYYRCR8ciOHTvKRowYcTSQByktLY2YOnVqxp49ezocGOIvM2fOTJs6dWr93LlzawN5nEDbsWNHvxEjRqR5t/l6SfM5AD8AsEdEHhORbH8HR0REFEg+XdJU1Y8AfCQisQBmA1grIgcBPA/g/6mq/Zw7ICKiLsnKymrxZ+/ul7/8ZeLbb7/d17vt2muvPd7+UmNnVFVVmcePH5/Vvn3Dhg2liYmJZ4zMvNB8uqQJACISB+BGAD8EcAjA3wCMATBMVccHKkBf8ZImEQXJBbmkSZ3T0SVNn3p4IrISQDaAlwFMU9XWhxZfExFmGSIiCnm+jtJ8VlX/0dEKVc33YzxEREQB4euglaEi0rt1QUT6iMiCAMVERETkd74mvFtUta51QVVrAdwSmJCIiCgUJCUlDcvMzMzJzs7OycvLGwq4HxofPXp0Rmpqat7o0aMzampqzniIPFT5mvBM4jXXjIiYAUQEJiQiIgoVGzdu3F1SUlJcWFi4CwAefPDBAePHjz9RXl5eOH78+BMLFy5MDHaMvvL1Ht4aACtE5M8AFMCPAawOWFREROSz93Yeinl+81eJh+sbIwfERjXfMja9asrwgQ2BONbq1at7b9y4sRQA5s+ff+yKK67IAlAZiGP5m689vF8C+AeAnwD4KYB1AH4RqKCIiMg37+08FPPwe7tSjp1stkZHWhzHTjZbH35vV8p7Ow/F+GP/V111VUZubu7QJ554oh8AHDt2zJKammoHgNTUVPvx48fDZopKXx88d8E928pzgQ2HiIg64/nNXyVaTaI2q9kFADar2QW70/T85q8Su9rL++STT0rS0tLslZWVliuvvDIzNze3yT9RB4dPPTwRyRCRN0SkWET2t34FOjgiIjq3w/WNkZEWU5s5jiMtJtfh+kafqoCfS1pamh0AkpKSHFOmTKnbunVrz7i4OEd5ebkVAMrLy619+/Z1dPU4F4qvlzSXwd27cwD4NoD/C/dD6GHvxKZNKL9pDvZe9V8ov2kOTmzaFOyQiIh8NiA2qrnZ4Wrzu7zZ4TINiI1q7sp+GxoaTLW1tabW79evXx8zfPjwxquvvrpuyZIlcQCwZMmSuEmTJtWde0+hw9eEF6Wq6+CeiqxcVX8D4MpvepOITBKRUhHZKyL3drD+f0Vku+drt4jUea37PyJSJCK7ROQP3qNE/eXEpk2oXvQwHDU1MMXGwlFTg+pFDzPpEVHYuGVsepXdpdJkd5pUFU12p8nuUrllbHpVV/ZbUVFhueyyy7KzsrJyLr300qETJ06s++53v9vw0EMPHV6/fn1Mampq3vr162Meeuihw9+8t9Dg683GJhExwV0t4Ta4R+T0P9cbPI8u/BHABAAVAD4TkVWqWty6jare6bX9zwBc4vl+NID/BDDcs/pjAFcA2OBjvD45/telkIgImKLctQMlKgouT3v0uHH+PBQRUUB47tMd8PcozZycnJbS0tLi9u2JiYnOrVu37u7KvoPF14R3B4AeAP4HwMNwX9a86RveMwrAXlXdDwAishzAtQDO+Af0mA3gQc/3CsAG97N+AsAKoNrHWH1mr6iAKTa2TZvYbLBXVPj7UEREATNl+MCGQD2G0J184yVNT0/te6p6UlUrVHWuqs5U1U+/4a1JALyr6lZ42jo6RiqAdLgffYCqbgWwHsBhz9caVd31jWfTSdbkZGhT20FH2tQEa3Kyvw9FRERB9o0JT1WdAEaexz20jrY/Wy2iWQDe8BwLIjIEwFAAyXAnyStF5IxrjCJyq4gUiEhBTU1N+9XfqO/N86AtLXA1NkJV3a8tLeh787xO74uIiEKbr4NWvgDwtoj8UESua/36hvdUABjktZwMdx29jswC8KrX8gwAn3p6lScBfADgsvZvUtW/qGq+qubHx8f7eCr/Fj1uHBIWPgBLfDxc9fWwxMcjYeEDvH9HRNQN+XoPry+AY2g7MlMBrDzHez4DkCEi6XAPcpkF4AftNxKRLAB9AGz1aj4A4BYR+R3cPcUrADzlY6ydEj1uHBMcEZEB+DrTytzO7lhVHZ4RnWsAmAEsVdUiEVkEoEBVV3k2nQ1gubYtvf4G3Mn1S7gT62pVfaezMRAREbXyteL5MnRw/01Vz3mzS1XfB/B+u7aF7ZZ/08H7nADm+xIbERH53/XXX5+2bt262Li4OMeePXuKAHdpoBkzZgyurKyMTEpKan777bf3x8fHO10uF+bNmzfoH//4R6zNZnMtXbq0bMyYMaeDfQ7t+XoP710A73m+1gGIAXAyUEEREVFwzZs37+iqVav2eLedrTTQ66+/Hrt//35bWVlZ4XPPPVe+YMGClOBEfW6+XtJ803tZRF4F8FFAIiIios4p+nsMtjybiIbKSMQkNWP0bVXIndGl5/ImT558srS0tE3d07OVBnr77bd733DDDcdMJhOuuuqqUw0NDZby8nJra1WFUOFrD6+9DAAhmcGJiAyl6O8xWP2rFJyqsSIyxoFTNVas/lUKiv7ul/JA3s5WGujw4cPWtLS0ltbtBgwY0NI6wXQo8bVawgkRaWj9AvAO3DXyiIgomLY8mwizVWGNckEEsEa5YLYqtjx7wSqRtx1z6BaA6Y+7zNdLmtGBDoSIiM5DQ2UkImPaluix2FxoqOxyeaD2WksDpaam2r1LAw0cONBeVlb29eXPw4cPR6SkpITU5UzA9x7eDBGJ9VruLSLTAxcWERH5JCapGY6mtr/LHU0mxCR1qTxQR85WGuiaa66p+9vf/hbncrmwbt26ntHR0c5Qu38H+P7g+YOq+vfWBVWtE5EHAbwVmLCIiMgno2+rwupfpQAwwWJzwdFkgtMuGH1bl8oDTZs2Lf3TTz+Nrq2ttSQkJAy/9957Dz300EOHZ8yYcVFqamq/gQMHtrz11lv7AOB73/te/XvvvRebmpqaFxUV5XrhhRfK/HFq/uZrwuuoJ+jre4mIKFDcozEP+HuU5jvvvPNVR+0dlQYymUx4+eWXD3TleBeCr0mrQER+D3d9OwXwMwDbAhYVERH5LndGQ1cTnBH4+ljCzwC0AHgNwAoAjQB+GqigiIiI/M3XUZqnANwb4FiIiIgCxtdRmmtFpLfXch8RWRO4sIiIiPzL10ua/VS1rnVBVWsB9A9MSERERP7na8JzicjXU4mJSBrOXr2ciIgo5Pia8O4H8LGIvCwiLwPYCOC+wIVFRETBlpSUNCwzMzMnOzs7Jy8vbyjgLhE0evTojNTU1LzRo0dn1NTUmAHA5XJhzpw5g1JSUvIyMzNzPv744x7Bjf5MPiU8VV0NIB9AKdwjNe+Ge6QmERF1Yxs3btxdUlJSXFhYuAsI7xJBvhaA/RGA2wEkA9gO4DIAW+GuSk5EREG0pmxNzEtFLyVWn66OTOiR0HxT7k1VV6ddHZDn8sK5RJCvlzRvB/AfAMpV9dsALgFQE7CoiAJp91rgxanAU8Pcr7vXBjsiovO2pmxNzOLPFqccbzpu7WXt5TjedNy6+LPFKWvK1vilPNBVV12VkZubO/SJJ57oB4R3iSBfZ1ppUtUmEYGIRKpqiYhkBTQyokDYvRb44B7AFAHY+gAnqt3LeALInBDs6Ig67aWilxItJovaLDYXANgsNleTo8n0UtFLiV3t5X3yySclaWlp9srKSsuVV16ZmZub23S2bcOhRJCvPbwKz3N4bwFYKyJvAzgUuLCIAmTL0+5kF9EDEHG/miLc7URhqPp0dWSkOdLl3RZpjnRVn67ucnmgtLQ0OwAkJSU5pkyZUrd169aerSWCACDcSgT5OmhlhqrWqepvADwA4K8AWB6Iwk9dOWCNattmjQLqQn7eW6IOJfRIaG52Nrf5Xd7sbDYl9EjoUnmghoYGU21tran1+/Xr18cMHz68MZxLBHW64oGqbgxEIEQXRO9U92XMCK8R0/ZGoHfIDSgj8slNuTdVLf5scUqTo8kUaY50NTubTQ6XQ27KvalL5YEqKiosM2bMGAIATqdTZs6ceey73/1uw5gxY06Fa4kglvghYxl9u/ueXQvcPTt7I+BqcbcThSHPfboD/h6lmZOT01JaWlrcvj0xMdEZriWCmPDIWDInAHjCfc+u7oC7Zzf6dg5YobB2ddrVDYF6DKE7YcIj48mcwARHZEC+jtIkIiIKa0x4RERkCEx4RERkCEx4RERkCEx4RER0huuvvz6tb9++IzIyMnJb286nNNAzzzwTl5qampeampr3zDPPxAXjXFox4RER0RnmzZt3dNWqVXu82zpbGqi6utr8+OOPD/zXv/61q6CgYNfjjz8+sDVJBgMTHhFRmKv/YHXMV9/7fuaecVcM++p738+s/2B1lyslTJ48+WR8fLzDu2316tW958+ffwxwlwb64IMP+gDA2UoDvfXWW7Hjxo1rSEhIcMbHxzvHjRvXsHLlytiuxna++BweEVEYq/9gdcyRxx5LgdWqEh3tcBw/bj3y2GMpAA7ETp7k14fRO1saqLKy0pqcnPx1e1JSUktlZWXQSgaxh0dEFMaOL1uWCKtVTTabS0RgstlcsFr1+LJliRcqhrOVBgq1kkFMeEREYcxRVRUpkW3LA0lkpMtRVdXl8kDtdbY0UHJysr2iouLr9srKyoiBAwcGrYICEx4RURizJCY2a3Pb8kDa3GyyJCZ2qTxQRzpbGmj69On1GzdujKmpqTHX1NSYN27cGDN9+vR6f8flK97DIyIKY33nzq068thjKS7AJJGRLm1uNsFul75z53apPNC0adPSP/300+ja2lpLQkLC8HvvvffQQw89dLgzpYESEhKcP//5zw+NHDlyKAD84he/OJSQkODs8kmfJ+noGmtdONN5AAATQUlEQVQ4ys/P14KCgmCHQUTGIzt27CgbMWLE0WAFUP/B6pjjy5YlOqqqIi2Jic19586t8veAlXCzY8eOfiNGjEjzbmMPj4gozMVOntRg9ATnC97DIyIiQ2DCIyIiQ2DCIyIiQ2DCIyIiQ2DCIyIiQ2DCIyKiM5w+fVqGDRs2NCsrK2fIkCG5d95550AAKCkpiRg+fHh2ampq3pQpUwY3NTUJADQ2NsqUKVMGp6Sk5A0fPjy7tLT06xlW7rvvvsSUlJS8tLS0vDfffLPLE1ufLyY8IiI6g81m048//ri0tLS0uKioqHjdunUx69at63nXXXcl33bbbdXl5eWFsbGxjqeffrofADz99NP9YmNjHQcOHCi87bbbqu+6665kANi2bZtt5cqVfUtLS4tWr169+4477khxOBznPniAMOEREYW5PduqY15/rCDzxV9+POz1xwoy92yr7nIvymQyITY21gUALS0t4nA4RESwdevW6Llz59YCwLx584698847vQHg3Xff7T1v3rxjADB37tzaLVu2RLtcLrzxxhu9r7vuuuNRUVGanZ3dkpqa2rxhw4aeXY3vvM4pkDsXkUkiUioie0Xk3g7W/6+IbPd87RaROq91KSLyoYjsEpFiEUkLZKxEROFoz7bqmE9e35vSdKLFGhFlcTSdaLF+8vreFH8kPYfDgezs7JyEhIQRV1xxRcPQoUObo6OjnVaru8JPWlpaS3V1dQQAVFdXR6Snp7cAgNVqRa9evZzV1dWWysrKiEGDBn1dImjgwIEtBw8ejOjwgAEWsIQnImYAfwQwGUAOgNkikuO9jareqaoXq+rFAJ4BsNJr9f8FsFhVhwIYBeBIoGIlIgpX29ceTDSbRS0RZpeIwBJhdpnNotvXHuxyeSCLxYKSkpLiAwcO7Pz888977tixw9Z+GxFR4KwlgvRs7V2N7XwEsoc3CsBeVd2vqi0AlgO49hzbzwbwKgB4EqNFVdcCgKqeVNXTAYyViCgsnaptijRbTW3KA5mtJtepuia/lQfq16+fc8yYMSc++eSTnidOnDDb7e4KP2VlZRH9+/e3A0BiYmLLV199FQEAdrsdJ0+eNPfv39+ZnJzcpkd36NChiOTk5KCUCApkwksCcNBrucLTdgYRSQWQDuAfnqZMAHUislJEvhCRxZ4eY/v33SoiBSJSUFNT4+fwiYhCX88+tman3dXmd7nT7jL17G3rUnmgQ4cOWY4ePWoGgJMnT8qGDRticnJymi677LITy5Yt6wMAS5cujZs6dWodAEyZMqVu6dKlcQCwbNmyPpdffvkJk8mEmTNn1q1cubJvY2OjlJSURJSVldnGjx9/qiuxna9ATh7dUVnbs3VjZwF4Q1Vby0ZYAIwFcAmAAwBeAzAHwF/b7Ez1LwD+ArirJXQ9ZCKi8HLxhEFVn7y+NwUtTpPZanI57S6T06ly8YRBXSoPdPDgQeucOXPSnU4nVFWuvfba47Nnz64fMWJE4/e///2LHnnkkaTc3NzTt99++1EAuP3224/OnDkzPSUlJS82Ntb52muv7QOA/Pz8punTpx/PzMzMNZvN+P3vf19usQSnbkHAygOJyOUAfqOqV3uW7wMAVf1dB9t+AeCnqrrFs3wZgMdUdbxn+YcALlPVn57teCwPRERBEvTyQHu2VcdsX3sw8VRdU2TP3rbmiycMqsoYmWDo6gkXujzQZwAyRCQdQCXcvbgftN9IRLIA9AGwtd17+4hIvKrWALgSALMZEVEHMkYmNBg9wfkiYPfwVNUB4DYAawDsArBCVYtEZJGIXOO16WwAy72H8ngubd4DYJ2IfAn35dHnAxUrERF1fwG9kKqq7wN4v13bwnbLvznLe9cCGB6w4IiIyFBY8ZyIjGn3WmDL00BdOdA7FRh9O5A54Xz35nK5XGIymTh4LgS4XC4B4GrfzqnFiMh4dq8FPrgHOFEN2Pq4Xz+4x91+fgprampiPb9oKYhcLpfU1NTEAihsv449PCIyni1PA6YIIKKHezmiB9DiaT+PXp7D4fhRVVXVC1VVVXlgRyLYXAAKHQ7Hj9qvYMIjIuOpK3f37LxZo4C6A+e1u5EjRx4BcM03bkhBxb9EiMh4eqcC9sa2bfZGoHdKcOKhC4IJLxB2rwVenAo8Ncz9ev73BYgoEEbfDrhagJbTgKr71dXibqduiwnP3/x/M5yI/C1zAjD5CSA6AWiqc79OfqIrozQpDPAenr/5+WY4EQVI5gT+TBoMe3j+VlfuvvntrQs3w4mIyD+Y8PyNN8OJiEISE56/8WY4EVFIYsLztwt5M5yjQYmIfBawengXmuHq4bWOBjVFuO8R2hvdPUmONCO60DidWJhgDy9cbXkapxxm7G9QlFSfxP4GxSmH2T0alIiIzsCEF6Yaa77CwZMKu9MFs0lgd7pw8KSisearYIdGRBSSmPDC1D57HGxohkncV1NMIrChGfvscUGOjIgoNDHhhallOg2R4kSkNgGqiNQmRIoTy3RasEMjIgpJTHhh6lD8WDwdcStqTX0RjZOoNfXF0xG34lD82GCHRkQUkji1WJiaP24wFq5qxGdRIxFlNaPR7oTdqVg0bnCwQyMiCkns4YWp8dn9seiaXPSPtqG+0Y7+0TYsuiYX47P7Bzs0IqKQxB5eGBuf3Z8JjojIR+zhERGRITDhERGRITDhERGRITDhERGRITDhERGRITDhERGRIfCxhN1r3RUG6srd1cpH387yOkRE3ZCxe3itNeVOVAO2Pu7XD+5hIVUiom7I2Alvy9PuAqoRPQAR96spgjXliIi6IWMnvLpyd7Vwb9YooO5AcOIhIqKAMXbC650K2Bvbttkbgd4pwYmHiIgCxtgJb/TtgKsFaDkNqLpfXS3udiIi6laMnfAyJwCTnwCiE4CmOvfr5Cc4SpOIqBviYwmZE5jgiIgMwNg9PCIiMgz28AJgQ8kRLNm0HwdrT2NQnx6YP24w69YREQUZe3h+tqHkCBauKsKRE03oHWXFkRNNWLiqCBtKjgQ7NCIiQ2PC87Mlm/bDahb0iLBAxP1qNQuWbNof7NCIiAyNCc/PDtaeRpTV3KYtympGRe3pIEVEREQAE57fDerTA412Z5u2RrsTyX16BCkiIiICmPD8bv64wbA7FadbHFB1v9qdivnjBgc7NCIiQ2PC87Px2f2x6Jpc9I+2ob7Rjv7RNiy6JpejNImIgoyPJQTA+Oz+THBERCGGPTwiIjIEJjwiIjIEJjwiIjKEgCY8EZkkIqUisldE7u1g/f+KyHbP124RqWu3PkZEKkXk2UDGSURE3V/ABq2IiBnAHwFMAFAB4DMRWaWqxa3bqOqdXtv/DMAl7XbzMICNgYqRiIiMI5A9vFEA9qrqflVtAbAcwLXn2H42gFdbF0RkJIAEAB8GMEYiIjKIQCa8JAAHvZYrPG1nEJFUAOkA/uFZNgF4EsDPz3UAEblVRApEpKCmpsYvQRMRUfcUyIQnHbTpWbadBeANVW2dk2sBgPdV9eBZtnfvTPUvqpqvqvnx8fFdCJWIiLq7QD54XgFgkNdyMoBDZ9l2FoCfei1fDmCsiCwA0AtAhIicVNUzBr4QERH5IpAJ7zMAGSKSDqAS7qT2g/YbiUgWgD4Atra2qeoNXuvnAMhnsiMioq4I2CVNVXUAuA3AGgC7AKxQ1SIRWSQi13htOhvAclU92+VOIiKiLpPukmfy8/O1oKAg2GEQkfF0NF6BQhBnWiEiIkNgwiMiIkNgwiMiIkNgwiMiIkNgwiMiIkNgwiMiIkNgwiMiIkMI5EwrRCFpQ8kRLNm0HwdrT2NQnx6YP24wxmf3D3ZYdIHxc2A87OGRoWwoOYKFq4pw5EQTekdZceREExauKsKGkiPBDo0uIH4OjIkJjwxlyab9sJoFPSIsEHG/Ws2CJZv2Bzs0uoD4OTAmJjwylIO1pxFlNbdpi7KaUVF7OkgRUTDwc2BMTHhkKIP69ECj3dmmrdHuRHKfHkGKiIKBnwNjYsIjQ5k/bjDsTsXpFgdU3a92p2L+uMHBDo0uIH4OjIkJjwxlfHZ/LLomF/2jbahvtKN/tA2Lrsnl6DyD4efAmFgeiIioa1geKEywh0dERIbAhEdERIbAhEdERIbAhEdERIZg+Lk0OZ8eEZExGLqHx/n0iIiMw9AJj/PpEREZh6ETHufTIyIyDkMnPM6nR0RkHIZOeJxPj4jIOAyd8DifHhGRcRj+sYTx2f2Z4IiIDMDQPTwiIjIOJjwiIjIEJjwiIjIEJjwiIjIEJjwiIjIEJjwiIjIEJjwiIjIEJjwiIjIEJjwiIjIEUdVgx+AXIlIDoNzHzfsBOBrAcC40nk9o4/mEtq6ez1FVneSvYChwuk3C6wwRKVDV/GDH4S88n9DG8wlt3e186Ox4SZOIiAyBCY+IiAzBqAnvL8EOwM94PqGN5xPautv50FkY8h4eEREZj1F7eEREZDBMeEREZAiGS3giMklESkVkr4jcG+x4OktElorIEREp9GrrKyJrRWSP57VPMGP0lYgMEpH1IrJLRIpE5HZPe7iej01E/iUiOzzn85CnPV1E/uk5n9dEJCLYsXaGiJhF5AsRedezHLbnIyJlIvKliGwXkQJPW1h+3qjzDJXwRMQM4I8AJgPIATBbRHKCG1WnvQig/UOu9wJYp6oZANZ5lsOBA8DdqjoUwGUAfur5/wjX82kGcKWqjgBwMYBJInIZgMcB/K/nfGoB3BzEGM/H7QB2eS2H+/l8W1Uv9nr2Llw/b9RJhkp4AEYB2Kuq+1W1BcByANcGOaZOUdVNAI63a74WwEue718CMP2CBnWeVPWwqn7u+f4E3L9UkxC+56OqetKzaPV8KYArAbzhaQ+b8wEAEUkGMAXAC55lQRifz1mE5eeNOs9oCS8JwEGv5QpPW7hLUNXDgDuJAOgf5Hg6TUTSAFwC4J8I4/PxXP7bDuAIgLUA9gGoU1WHZ5Nw+8w9BeAXAFye5TiE9/kogA9FZJuI3OppC9vPG3WOJdgBXGDSQRufywgyEekF4E0Ad6hqg7sTEZ5U1QngYhHpDeDvAIZ2tNmFjer8iMhUAEdUdZuIjG9t7mDTsDgfj/9U1UMi0h/AWhEpCXZAdOEYrYdXAWCQ13IygENBisWfqkVkAAB4Xo8EOR6fiYgV7mT3N1Vd6WkO2/Nppap1ADbAfW+yt4i0/nEZTp+5/wRwjYiUwX35/0q4e3zhej5Q1UOe1yNw/0EyCt3g80a+MVrC+wxAhmeUWQSAWQBWBTkmf1gF4CbP9zcBeDuIsfjMcz/orwB2qervvVaF6/nEe3p2EJEoAP8F933J9QC+69ksbM5HVe9T1WRVTYP7Z+UfqnoDwvR8RKSniES3fg9gIoBChOnnjTrPcDOtiMh34P4r1Qxgqar+NsghdYqIvApgPNwlTaoBPAjgLQArAKQAOADgelVtP7Al5IjIGACbAXyJf98j+hXc9/HC8XyGwz3owQz3H5MrVHWRiAyGu4fUF8AXAG5U1ebgRdp5nkua96jq1HA9H0/cf/csWgC8oqq/FZE4hOHnjTrPcAmPiIiMyWiXNImIyKCY8IiIyBCY8IiIyBCY8IiIyBCY8IiIyBCY8IiIyBCY8KhbE5GBIvKGD9udPEv7iyLy3Y7WEVF4YcKjbk1VD6lqyCUsT6kqIrqAmPAo6EQkzVME9nlP4dQPPVNzdbTtBhF53FNodbeIjPW0m0VksYh8JiI7RWS+174LPd/3EJEVnvWveYqY5nvt+7ee4q2fikiC12H/S0Q2e4431bOtTUSWeYqJfiEi3/a0zxGRZ732+W7rxMsiclJEFonIPwFcLiKPiUixJ54n/PqPSkRnYMKjUJEB4I+qmgugDsDMc2xrUdVRAO6Ae2o1wF2EtF5V/wPAfwC4RUTS271vAYBaVR0O4GEAI73W9QTwqad46yYAt3itSwNwBdx14f4sIjYAPwUAVR0GYDaAlzzt59ITQKGqfgtAMYAZAHI98TzyDe8loi5iwqNQ8ZWqbvd8vw3uJHM2KzvYbiKA//bUovsn3HXbMtq9bwzcc0BCVQsB7PRa1wLg3bMcf4WqulR1D4D9ALI9+3rZs68SAOUAMr/hHJ1wV4YAgAYATQBeEJHrAJz+hvcSURcx4VGo8J582Ilz12ps7mA7AfAzVb3Y85Wuqh+2e9+5Cu3Z9d8Ty7Y/fvsJZ/Uc+3Kg7c+Vd6+vyVMvD54CqqPgToDTAaw+R2xE5AdMeNRdrAHwE099PYhIpqcEjLePAXzPsz4HwDAf9329iJhE5CIAgwGUwn3Z84bWY8E9034pgDK4C8CaRGQQ3EntDJ6it7Gq+j7cl2Yv9vVEiej8GK3iOXVfL8B9GfJzT529Grh7Tt7+BPe9tp1wl7XZCaDeh32XAtgIIAHAj1W1SUT+BPf9vC/h7tXNUdVmEfkEwFdwlzwqBPD5WfYZDeBtz30/AXCnz2dKROeF5YHIMDyPAlg9CesiAOsAZKpqS5BDI6ILgD08MpIeANZ7LnsKgJ8w2REZB3t4FJJE5I8A/rNd89OquiwY8RBR+GPCIyIiQ+AoTSIiMgQmPCIiMgQmPCIiMgQmPCIiMoT/D2sWIhOTLDm0AAAAAElFTkSuQmCC\n",
      "text/plain": [
       "<Figure size 461x360 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import seaborn as sns\n",
    "g = sns.lmplot(x=\"n_neighbours\", y=\"accuracy\", hue=\"samples_per_class\", data=stat_df, fit_reg=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T14:10:25.521270Z",
     "start_time": "2018-06-28T14:10:25.133539Z"
    },
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8016\n"
     ]
    }
   ],
   "source": [
    "# Report the accuracy on the test set (the one remained untouched)\n",
    "knn_params = {'n_neighbors':10,\n",
    "     'weights':'uniform',\n",
    "     'n_jobs':6}\n",
    "\n",
    "X_,y_ =  stratified_sample(train_vae_embeddings,y,500)\n",
    "X_test, y_test = fmnist.X_test, fmnist.y_test\n",
    "\n",
    "knn = KNeighborsClassifier(**knn_params)\n",
    "knn.fit(X_, y_) \n",
    "accuracy = knn.score(test_vae_embeddings,y_test)\n",
    "print(accuracy)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "# Conclusions\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "It seems that VAE was better both on train/val as well as on the test dataset.\n",
    "\n",
    "\n",
    "Notably on train/val dataset its accuracy was similar to UMAP - also a non-linear method.\n",
    "I belive that the reason for that is non-linearity of CNNs and UMAP - they can learn more complex dependencies.\n",
    "\n",
    "\n",
    "\n",
    "Also it is interesting to note that:\n",
    "- VAEs seem to have fullfilled their task - the learned embedding seems to have no huge holes - there is a continuous path between the majority of the classes and they seem separable (compare to UMAP visually - there is a lot of blank space there)\n",
    "- As for the blank space, I have not tested it, but it is interesting what may lay there =)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "ExecuteTime": {
     "end_time": "2018-06-28T13:53:04.797657Z",
     "start_time": "2018-06-28T13:53:04.792815Z"
    },
    "hidden": true
   },
   "source": [
    "I see several different ways of improvement:\n",
    "1. **Computational** - play with:\n",
    "    - Ensembling / folding / blending. Although this method is superficial, it mostly always works with CNNS;\n",
    "    - Increase network's capacity, e.g. lift 120k param limit;\n",
    "    - Try combining different methods (PCA, CNNs, UMAP - think about a meta-architecture to combine these three);\n",
    "    \n",
    "    \n",
    "2. **Architecture** - I did not explicitly look for new VAE papers, as they seem to be more focused on math, instead of concrete architectures and know-hows (and the domain - fmnist - seems to be really \"simple\") - but improving a CNN architecture is definetely a way, even though all my naive experiments failed more or less;\n",
    "\n",
    "\n",
    "3. **Conditioning** - I read some papers on cGANs and CycleGANs. The idea is, that if in this case we have some a priori information about the class of the object (i.e. a shoe) this information will be somehow encoded into the CNN, when traning. If we pass this information somehow to the CNN (e.g. learn a separate distribution for each class / separate network for each class) - then the CNN's capacity will be used to refine the encoding, instead of classifying the objects;"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "!!!\n",
    "\n",
    "**Caveat** - I have not really seen people effectively using VAEs on Imagenet scale tasks or any difficult domains\n",
    "\n",
    "!!!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.5.4"
  },
  "toc": {
   "nav_menu": {},
   "number_sections": true,
   "sideBar": true,
   "skip_h1_title": false,
   "title_cell": "Table of Contents",
   "title_sidebar": "Contents",
   "toc_cell": false,
   "toc_position": {
    "height": "calc(100% - 180px)",
    "left": "10px",
    "top": "150px",
    "width": "213px"
   },
   "toc_section_display": true,
   "toc_window_display": true
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}