hw3 part2&3

Author: Victor Yurchenko

homework03/homework03_part2_autoencoders_basic.ipynb

@@ -0,0 +1,279 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Original paper: https://arxiv.org/abs/1806.00035"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 0. Read real and generated images#"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "import math\n",
+    "import numpy as np\n",
+    "import matplotlib.pyplot as plt\n",
+    "import matplotlib.lines as mlines\n",
+    "import matplotlib"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "CHANNEL_NUM = 3\n",
+    "PICTURE_SIZE = 36\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "class ParticleDataset():\n",
+    "    def __init__(self, file):\n",
+    "        self.data = np.load(file)\n",
+    "        self.image = self.data['Pictures'].reshape(-1, CHANNEL_NUM*PICTURE_SIZE*PICTURE_SIZE)\n",
+    "\n",
+    "    def __len__(self):\n",
+    "        return len(self.image)\n",
+    "\n",
+    "    def __getitem__(self, i):\n",
+    "        return {\n",
+    "            \"Pictures\": self.image[i],\n",
+    "        }"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "real_data = ParticleDataset('real.npz')\n",
+    "vae_data = ParticleDataset('vae.npz')\n",
+    "gan_data = ParticleDataset11('gan.npz')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Make sure that the values of real and generated data are of the same order - it is important for cooperative binarizing"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "print (np.min(real.image), np.max(real.image))\n",
+    "print (np.min(gan_data.image), np.max(gan_data.image))\n",
+    "print (np.min(vae.image), np.max(vae.image))"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# 1. Binarize# "
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "To understand how real and generated objects are close to each other, we need to choose a space of features in which we look these objects at"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We go the easiest way and take pixels' values as features."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "from sklearn.cluster import KMeans, MiniBatchKMeans\n",
+    "import math\n",
+    "## function which map object to probability distribution ##\n",
+    "\n",
+    "def bin_counts (real_data, generated_data, number_of_bins=25):\n",
+    "    # binirize real and generated data, plot histogram and found density function\n",
+    "    return real_density, gen_density"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Create $\\alpha-$ and $\\beta-$ vectors as in\n",
+    "\n",
+    "$\\hat{PRD}(Q,P) = \\{(\\alpha(\\lambda), \\beta(\\lambda))| \\lambda \\in \\Lambda \\}$, where $\\Lambda = \\{\\tan (\\frac{i}{m+1} \\frac{\\pi}{2}) | i = 1, 2 ... m\\}$"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def count_alpha_beta (real_density, gen_density, num_angles = 1000):\n",
+    "    assert real_density.shape == gen_density.shape\n",
+    "    alpha_vec = []\n",
+    "    beta_vec = []\n",
+    "    angles = np.linspace(1e-6, np.pi/2 - 1e-6, num=num_angles)\n",
+    "    # you code\n",
+    "    return alpha_vec, beta_vec"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "For stability, take the average of several repetitions"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def count_prd(reals, gens, repeat_number = 10):\n",
+    "    vectors = [count_alpha_beta(reals, gens) for i in range(repeat_number)]\n",
+    "    vectors = np.array(vectors).mean(axis=0)\n",
+    "    print (vectors.shape)\n",
+    "    return vectors"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 2. Apply it##"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "a, b = bin_counts(real_data.image, fake_data1.image)\n",
+    "c, d = bin_counts(real_gan_data.image, gan_data.image)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "## 3. Make vectors for plot and plot ##"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "data_for_plots = count_prd(a, b)\n",
+    "data_for_plots2 = count_prd(c, d)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "fig = plt.figure(figsize=(2.5, 2.5), dpi=200)\n",
+    "fig.add_subplot(111).tick_params(axis='both', which='major', labelsize=8)\n",
+    "plt.xlim([0, 1])\n",
+    "plt.ylim([0, 1])\n",
+    "plt.xlabel('Recall', fontsize=12)\n",
+    "plt.ylabel('Precision', fontsize=12)\n",
+    "plt.plot(data_for_plots[0], data_for_plots[1], label = \"VAE\")\n",
+    "plt.plot(data_for_plots2[0], data_for_plots2[1], label = \"GAN\")\n",
+    "plt.legend()\n",
+    "plt.show()"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "**What curves were obtained for the first(VAE) and the second(GAN) models? What can we say about the advantages and disadvantages of each model?**"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "#type answer here"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {
+    "collapsed": true
+   },
+   "source": [
+    "## Bonus: about features' space##\n",
+    "\n",
+    "It is possible to transfer the picture-> embedding, for example, using the 1st part of the Inception network as a feature extraxtor. This embedding can be used for bin counts also"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "# if you came here and still alive, the implementation of idea above will give you extra points =)\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.6.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}

homework03/homework03_part2_vae_advanced.ipynb

@@ -0,0 +1,71 @@
+import numpy as np
+import os
+from scipy.misc import imread,imresize
+import pandas as pd
+
+def fetch_lfw_dataset(attrs_name = "lfw_attributes.txt",
+                      images_name = "lfw-deepfunneled",
+                      raw_images_name = "lfw",
+                      use_raw=False,
+                      dx=80,dy=80,
+                      dimx=45,dimy=45
+    ): # sad smile
+
+    #download if not exists
+    if (not use_raw) and not os.path.exists(images_name):
+        print("images not found, donwloading...")
+        os.system("wget http://vis-www.cs.umass.edu/lfw/lfw-deepfunneled.tgz -O tmp.tgz")
+        print("extracting...")
+        os.system("tar xvzf tmp.tgz && rm tmp.tgz")
+        print("done")
+        assert os.path.exists(images_name)
+    
+    if use_raw and not os.path.exists(raw_images_name):
+        print("images not found, donwloading...")
+        os.system("wget http://vis-www.cs.umass.edu/lfw/lfw.tgz -O tmp.tgz")
+        print("extracting...")
+        os.system("tar xvzf tmp.tgz && rm tmp.tgz")
+        print("done")
+        assert os.path.exists(raw_images_name)
+
+    if not os.path.exists(attrs_name):
+        print("attributes not found, downloading...")
+        os.system("wget http://www.cs.columbia.edu/CAVE/databases/pubfig/download/%s" % attrs_name)
+        print("done")
+
+    #read attrs
+    df_attrs = pd.read_csv("lfw_attributes.txt",sep='\t',skiprows=1,) 
+    df_attrs = pd.DataFrame(df_attrs.iloc[:,:-1].values, columns = df_attrs.columns[1:])
+
+
+    #read photos
+    dirname = raw_images_name if use_raw else images_name
+    photo_ids = []
+    for dirpath, dirnames, filenames in os.walk(dirname):
+        for fname in filenames:
+            if fname.endswith(".jpg"):
+                fpath = os.path.join(dirpath,fname)
+                photo_id = fname[:-4].replace('_',' ').split()
+                person_id = ' '.join(photo_id[:-1])
+                photo_number = int(photo_id[-1])
+                photo_ids.append({'person':person_id,'imagenum':photo_number,'photo_path':fpath})
+
+    photo_ids = pd.DataFrame(photo_ids)
+
+    #mass-merge
+    #(photos now have same order as attributes)
+    df_attrs['imagenum'] = df_attrs['imagenum'].astype(np.int64)
+    df = pd.merge(df_attrs, photo_ids, on=('person','imagenum'))
+
+    assert len(df)==len(df_attrs),"lost some data when merging dataframes"
+
+    #image preprocessing
+    all_photos = df['photo_path'].apply(imread)\
+                                 .apply(lambda img:img[dy:-dy,dx:-dx])\
+                                 .apply(lambda img: imresize(img,[dimx,dimy]))
+
+    all_photos = np.stack(all_photos.values).astype('uint8')
+    all_attrs = df.drop(["photo_path","person","imagenum"],axis=1)
+    
+    return all_photos,all_attrs
+