print_figures.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Namespace(Diters=5, DitersAlt=100, batch_size=30, channelInds=[0, 2], channels_pt1=[0, 2], channels_pt2=[0, 1, 2], critRecon='BCELoss', dataProvider='DataProvider3Dh5', data_save_path='/root/results/integrated_cell/test_aaegan/aaegan3Dv6_128D_latent_v4/data.pyt', decDRatio=0.0001, dtype='float', encDRatio=0.0001, gpu_ids=[0, 1], imdir='/root/results/ipp/ipp_dataset_cellnuc_seg_curated_8_24_17', latentDistribution='gaussian', lrDec=5e-05, lrDecD=5e-05, lrEnc=5e-05, lrEncD=0.01, model_name='aaegan3Dv6', myseed=0, nClasses=0, nRef=0, nch=2, ndat=14302, nepochs=250, nepochs_pt2=300, nlatentdim=128, noise=1e-05, optimizer='adam', saveProgressIter=1, saveStateIter=1, save_dir='/root/results/integrated_cell/test_aaegan/aaegan3Dv6_128D_latent_v4/ref_model', save_parent='/root/results/integrated_cell/test_aaegan/aaegan3Dv6_128D_latent_v4', train_module='aaegan_trainv3')\n",
      "Loading from /root/results/integrated_cell/test_aaegan/aaegan3Dv6_128D_latent_v4/ref_model\n",
      "Namespace(Diters=5, DitersAlt=100, batch_size=30, channelInds=[0, 1, 2], channels_pt1=[0, 2], channels_pt2=[0, 1, 2], critRecon='BCELoss', dataProvider='DataProvider3Dh5', data_save_path='/root/results/integrated_cell/test_aaegan/aaegan3Dv6_128D_latent_v4/data.pyt', decDRatio=0.0001, dtype='float', encDRatio=0.0001, gpu_ids=[0, 1], imdir='/root/results/ipp/ipp_dataset_cellnuc_seg_curated_8_24_17', latentDistribution='gaussian', latentSample=<function sampleGaussian at 0x7f482bf7c6a8>, lrDec=5e-05, lrDecD=5e-05, lrEnc=5e-05, lrEncD=0.01, model_name='aaegan3Dv6', myseed=0, nClasses=10, nRef=128, nch=3, nclasses=1, ndat=14302, nepochs=250, nepochs_pt2=300, nlatentdim=128, noise=1e-05, noise_std=0, optimizer='adam', saveProgressIter=1, saveStateIter=1, save_dir='/root/results/integrated_cell/test_aaegan/aaegan3Dv6_128D_latent_v4/struct_model', save_parent='/root/results/integrated_cell/test_aaegan/aaegan3Dv6_128D_latent_v4', train_module='aaegan_trainv3')\n",
      "Loading from /root/results/integrated_cell/test_aaegan/aaegan3Dv6_128D_latent_v4/struct_model\n",
      "done loading models\n"
     ]
    }
   ],
   "source": [
    "import argparse\n",
    "import os\n",
    "import model_utils\n",
    "import pickle\n",
    "import torch\n",
    "import numpy as np\n",
    "import scipy\n",
    "\n",
    "from torch.autograd import Variable\n",
    "\n",
    "import pdb\n",
    "\n",
    "parent_dir = '/root/results/integrated_cell/test_aaegan/aaegan3Dv6_128D_latent_v4'\n",
    "gpu_ids = [0, 1]\n",
    "batch_size = 100\n",
    "\n",
    "# parser = argparse.ArgumentParser()\n",
    "# parser.add_argument('--parent_dir', help='save dir')\n",
    "# parser.add_argument('--gpu_ids', nargs='+', type=int, default=0, help='gpu id')\n",
    "# parser.add_argument('--batch_size', type=int, default=400, help='batch_size')\n",
    "# parser.add_argument('--overwrite', type=bool, default=False, help='overwrite existing results')\n",
    "# args = parser.parse_args()\n",
    "\n",
    "# model_dir = args.parent_dir + os.sep + 'struct_model' \n",
    "\n",
    "\n",
    "figure_dir = parent_dir + os.sep + 'figures'\n",
    "\n",
    "if not os.path.exists(figure_dir):\n",
    "    os.makedirs(figure_dir)\n",
    "\n",
    "\n",
    "\n",
    "torch.manual_seed(2)\n",
    "torch.cuda.manual_seed(2)\n",
    "np.random.seed(2)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "model_dir = parent_dir + os.sep + 'ref_model'\n",
    "opt_ref = pickle.load(open( '{0}/opt.pkl'.format(model_dir), \"rb\" ))\n",
    "print(opt_ref)\n",
    "opt_ref.gpu_ids = gpu_ids\n",
    "\n",
    "opt_ref.save_dir = model_dir\n",
    "models, _, _, logger_ref, _ = model_utils.load_model(opt_ref.model_name, opt_ref)\n",
    "enc_ref = models['enc']\n",
    "dec_ref = models['dec']\n",
    "\n",
    "enc_ref.train(False)\n",
    "dec_ref.train(False)\n",
    "models = None\n",
    "\n",
    "dp_ref = model_utils.load_data_provider(opt_ref.data_save_path, opt_ref.imdir, opt_ref.dataProvider)\n",
    "dp_ref.opts['channelInds'] = opt_ref.channelInds\n",
    "\n",
    "model_dir = parent_dir + os.sep + 'struct_model'\n",
    "opt = pickle.load(open( '{0}/opt.pkl'.format(model_dir), \"rb\" ))\n",
    "print(opt)\n",
    "opt.gpu_ids = gpu_ids\n",
    "\n",
    "opt.save_dir = model_dir\n",
    "models, _, _, logger, _ = model_utils.load_model(opt.model_name, opt)\n",
    "enc = models['enc']\n",
    "dec = models['dec']\n",
    "\n",
    "enc.train(False)\n",
    "dec.train(False)\n",
    "models = None\n",
    "\n",
    "dp = model_utils.load_data_provider(opt.data_save_path, opt.imdir, opt.dataProvider)\n",
    "\n",
    "\n",
    "print('done loading models')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib.patches as mpatches\n",
    "from imgToProjection import imgtoprojection\n",
    "from tqdm import tqdm\n",
    "from sklearn.metrics import confusion_matrix\n",
    "    \n",
    "def tensor2img(imgs, colors=None):\n",
    "\n",
    "    \n",
    "    if colors is None:\n",
    "            colormap = 'hsv'\n",
    "            colors = plt.get_cmap(colormap)(np.linspace(0, 1, imgs.shape[1]+1))\n",
    "    \n",
    "    imgs = imgs.numpy()\n",
    "    im_out = list()\n",
    "    \n",
    "    #for every image\n",
    "    for i in range(0, imgs.shape[0]):\n",
    "        img = imgs[i]\n",
    "        \n",
    "        #contrast adjust each channel\n",
    "        for j in range(0, img.shape[0]):\n",
    "            maxval = np.max(img[j])\n",
    "            if maxval > 0:\n",
    "                img[j] = img[j]/maxval\n",
    "            \n",
    "        \n",
    "        img = imgtoprojection(np.swapaxes(img, 1, 3), proj_all=True, colors = colors, global_adjust=True)\n",
    "        img = np.swapaxes(img, 0, 2)\n",
    "        \n",
    "        img = np.flip(np.flip(img,0), 1)\n",
    "        \n",
    "        #very light border between each projection\n",
    "        img[:,-2:,:] = .25\n",
    "        img[-2:,:,:] = .25\n",
    "        \n",
    "        im_out.append(img)\n",
    "\n",
    "    img = np.concatenate(im_out, 1)\n",
    "\n",
    "    return img\n",
    "\n",
    "def print_fig1(dp, save_path, save_path_struct, n_per_row = 6, colors=[[1,0,1], [1,1,0], [0,1,1]]):\n",
    "    #this figure is #classes by n_per_row max project image of cells. \n",
    "\n",
    "    ntrain = dp.get_n_dat('train')\n",
    "    \n",
    "    train_classes = dp.get_classes(np.arange(0, ntrain), 'train').numpy()\n",
    "    class_names = dp.label_names\n",
    "    \n",
    "    image_list = list()\n",
    "    image_list_struct = list()\n",
    "    \n",
    "    for i in range(0, len(class_names)):\n",
    "        inds = np.where(train_classes == i)[0]\n",
    "        np.random.shuffle(inds)\n",
    "        \n",
    "        #make the CMY image\n",
    "        images = dp.get_images(inds[0:n_per_row], 'train')\n",
    "        images_flat = tensor2img(images, colors)\n",
    "        image_list.append(images_flat)\n",
    "        \n",
    "        #make the struct-only Yellow image\n",
    "        images[:, [0,2], :, :,:] = images[:, [0,2], :, :,:].fill_(0) #not sure why i have to do it this way, but it doesn't work without the assigment\n",
    "        \n",
    "        images_flat_struct = tensor2img(images, colors)\n",
    "        image_list_struct.append(images_flat_struct)\n",
    "        \n",
    "        \n",
    "    images = np.concatenate(image_list, axis=0)\n",
    "    scipy.misc.imsave(save_path, images)\n",
    "    \n",
    "    images_struct = np.concatenate(image_list_struct, axis=0)\n",
    "    scipy.misc.imsave(save_path_struct, images_struct)\n",
    "                                   \n",
    "def print_fig2(enc, dec, dp, save_path, save_path_struct, n_per_row = 6, colors=[[1,0,1], [1,1,0], [0,1,1]], required_test_inds=None):\n",
    "    ntrain = dp.get_n_dat('train')\n",
    "    train_classes = dp.get_classes(np.arange(0, ntrain), 'train').numpy()\n",
    "    \n",
    "    class_names = dp.label_names\n",
    "    \n",
    "    nclasses = len(class_names)\n",
    "    train_inds = np.int_(np.zeros(nclasses))\n",
    "    for i in range(0, len(class_names)):\n",
    "        images_w = list()\n",
    "        class_inds = np.where(train_classes == i)[0]\n",
    "        np.random.shuffle(class_inds)\n",
    "        train_inds[i] = class_inds[0]\n",
    "        \n",
    "    train_images = dp.get_images(train_inds, 'train')\n",
    "    train_images_struct = train_images.clone()\n",
    "    train_images_struct[:, [0,2], :, :,:] = train_images_struct[:, [0,2], :, :,:].fill_(0)\n",
    "    \n",
    "    \n",
    "    n_per_row_tmp = n_per_row - len(required_test_inds)\n",
    "    \n",
    "    ntest = dp.get_n_dat('test')\n",
    "    test_inds= np.arange(0, ntest)\n",
    "    np.random.shuffle(test_inds)\n",
    "    test_inds = test_inds[np.arange(0, n_per_row_tmp-1)]\n",
    "    \n",
    "    test_inds = np.concatenate([test_inds, required_test_inds])\n",
    "    \n",
    "    test_images = dp.get_images(test_inds, 'test')\n",
    "    \n",
    "    images_h = list()\n",
    "    images_h_struct = list()   \n",
    "    \n",
    "    for i in range(0, len(class_names)):\n",
    "        images_w = list()\n",
    "        images_w_struct = list()\n",
    "        \n",
    "        train_inds = np.where(train_classes == i)[0]\n",
    "        np.random.shuffle(train_inds)\n",
    "        \n",
    "        for j in range(0, n_per_row-1):\n",
    "            image = Variable(torch.unsqueeze(test_images[j], 0))\n",
    "            z = enc(image)\n",
    "            \n",
    "            z[0].data.fill_(-100)\n",
    "            z[0].data[0,i] = 0\n",
    "\n",
    "            z[-1].data.fill_(0)\n",
    "    \n",
    "            image = dec(z)\n",
    "        \n",
    "            image = image.data.cpu()\n",
    "        \n",
    "            image[:, [0,2], :, :,:] = test_images[j][[0,2],:,:,:]\n",
    "        \n",
    "            images_w.append(tensor2img(image, colors))\n",
    "            \n",
    "            image[:, [0,2], :, :,:] = image[:, [0,2], :, :,:].fill_(0)\n",
    "            images_w_struct.append(tensor2img(image, colors))\n",
    "        \n",
    "        #CMY version\n",
    "        images_w = np.concatenate(images_w, axis=1)\n",
    "        images_w[:,-2:,:] = 0.5\n",
    "        image_flat = tensor2img(torch.unsqueeze(train_images[i], 0), colors)\n",
    "        images_w = np.concatenate([images_w, image_flat], axis=1)        \n",
    "        images_h.append(images_w)\n",
    "        \n",
    "        #Struct-only Yellow version\n",
    "        images_w_struct = np.concatenate(images_w_struct, axis=1)\n",
    "        images_w_struct[:,-2:,:] = 0.5\n",
    "        image_flat = tensor2img(torch.unsqueeze(train_images_struct[i], 0), colors)\n",
    "        images_w_struct = np.concatenate([images_w_struct, image_flat], axis=1)        \n",
    "        images_h_struct.append(images_w_struct)\n",
    "        \n",
    "    images = np.concatenate(images_h, axis=0)\n",
    "    scipy.misc.imsave(save_path, images)\n",
    "    \n",
    "    images_struct = np.concatenate(images_h_struct, axis=0)\n",
    "    scipy.misc.imsave(save_path_struct, images_struct)\n",
    "    \n",
    "def print_conf_mat(enc, dp, figure_dir, batch_size, default_gpu_id):\n",
    "\n",
    "\n",
    "    train_or_test_groups = ['test', 'train']\n",
    "\n",
    "    cf_out = dict()\n",
    "\n",
    "    for train_or_test in train_or_test_groups:\n",
    "        save_path = figure_dir + os.sep + 'conf_mat_' + train_or_test + '.csv'\n",
    "        \n",
    "        \n",
    "        y_hat = list()\n",
    "        y = list()\n",
    "\n",
    "        ndat = dp.get_n_dat(train_or_test)\n",
    "\n",
    "        intervals = np.arange(0, ndat, batch_size)\n",
    "\n",
    "        for i in tqdm(intervals):\n",
    "            batch_range = i + batch_size\n",
    "            if batch_range > ndat:\n",
    "                batch_range = ndat\n",
    "\n",
    "\n",
    "            dat_inds = np.arange(i, batch_range)\n",
    "\n",
    "            images = Variable(dp.get_images(dat_inds,train_or_test)).cuda(default_gpu_id)\n",
    "            labels = dp.get_classes(dat_inds,train_or_test).numpy()\n",
    "\n",
    "            z = enc(images)\n",
    "\n",
    "            y_hat.append(np.argmax(z[0].data.cpu().numpy(), axis=1))\n",
    "            y.append(labels)\n",
    "\n",
    "            del images, labels, z\n",
    "\n",
    "\n",
    "        y = np.concatenate(y, axis=0)\n",
    "        y_hat = np.concatenate(y_hat, axis=0)\n",
    "\n",
    "        cf = confusion_matrix(y, y_hat)\n",
    "        pd.DataFrame(cf, columns=dp.label_names).to_csv(save_path, index=False)\n",
    "\n",
    "        cf_out[train_or_test] = cf \n",
    "        \n",
    "    return cf_out\n",
    "\n",
    "def print_recon(enc, dec, dp, save_path, default_gpu_id, colors=[[1,0,1], [1,1,0], [0,1,1]]):\n",
    "    \n",
    "    train_or_test_groups = ['train', 'test'] \n",
    "\n",
    "    class_names = dp.label_names\n",
    "    \n",
    "\n",
    "    images_train_test = list()\n",
    "    \n",
    "    for train_or_test in train_or_test_groups:\n",
    "        \n",
    "        ntrain = dp.get_n_dat(train_or_test)\n",
    "        train_classes = dp.get_classes(np.arange(0, ntrain), train_or_test).numpy()\n",
    "        \n",
    "        image_in = list()\n",
    "        image_out = list()\n",
    "        \n",
    "        for i in range(0, len(class_names)):\n",
    "            inds = np.where(train_classes == i)[0]\n",
    "#             np.random.shuffle(inds)\n",
    "\n",
    "            #make the CMY image\n",
    "            images = dp.get_images([inds[0]], train_or_test)\n",
    "\n",
    "            image_in_flat = tensor2img(images, colors)\n",
    "            image_in.append(image_in_flat)\n",
    "            \n",
    "            image_recon = dec(enc(Variable(images).cuda(default_gpu_id)))\n",
    "            image_out_flat = tensor2img(image_recon.data.cpu(), colors)\n",
    "            image_out.append(image_out_flat)\n",
    "\n",
    "#             #make the struct-only Yellow image\n",
    "#             images[:, [0,2], :, :,:] = images[:, [0,2], :, :,:].fill_(0) #not sure why i have to do it this way, but it doesn't work without the assigment\n",
    "\n",
    "#             images_flat_struct = tensor2img(images, colors)\n",
    "#             image_list_struct.append(images_flat_struct)\n",
    "        \n",
    "        \n",
    "        image_in = np.concatenate(image_in, axis=1)\n",
    "        image_out = np.concatenate(image_out, axis=1)\n",
    "        \n",
    "        images = np.concatenate([image_in, image_out], axis=0)\n",
    "        images_train_test.append(images)\n",
    "        \n",
    "    images_train_test = np.concatenate(images_train_test, axis=0)\n",
    "    scipy.misc.imsave(save_path, images_train_test)\n",
    "    \n",
    "#     images_struct = np.concatenate(image_list_struct, axis=0)\n",
    "#     scipy.misc.imsave(save_path_struct, images_struct)\n",
    "\n",
    "\n",
    "def print_history(logger, save_path, r_or_s):\n",
    "    field_order = [\n",
    "                     'decDLoss',\n",
    "                     'minimaxDecDLoss',\n",
    "                     'encDLoss',\n",
    "                     'minimaxEncDLoss',\n",
    "                     'reconLoss',\n",
    "                     'classLoss',\n",
    "                     'refLoss']\n",
    "    \n",
    "    \n",
    "    field_dict = {'reconLoss': '$\\mathcal{L}_{X_{' + r_or_s + '}}$',\n",
    "                  'minimaxEncDLoss': '$\\mathcal{L}_{mmEncD^{' + r_or_s + '}}$',\n",
    "                  'encDLoss': '$\\mathcal{L}_{EncD^{' + r_or_s + '}}$',\n",
    "                  'minimaxDecDLoss': '$\\mathcal{L}_{mmDecD^{' + r_or_s + '}}$',\n",
    "                  'decDLoss': '$\\mathcal{L}_{DecD^{' + r_or_s + '}}$',\n",
    "                  'classLoss': '$\\mathcal{L}_{y}$',\n",
    "                  'refLoss': '$\\mathcal{L}_{\\hat{x}^{' + r_or_s + '}}$'}\n",
    "    \n",
    "    \n",
    "    plt.figure()\n",
    "\n",
    "    for i in range(0, len(field_order)):\n",
    "        field = field_order[i]\n",
    "        if field in logger.fields:\n",
    "            plt.plot(logger.log['iter'], logger.log[field], label=field_dict[field])\n",
    "    \n",
    "    plt.legend()\n",
    "#     plt.title('History')\n",
    "    plt.xlabel('iteration')\n",
    "    plt.ylabel('loss')\n",
    "    plt.savefig(save_path, bbox_inches='tight')\n",
    "    plt.close()\n",
    "    \n",
    "def print_latent_plot(embeddings, save_path, r_or_s, dims=[0,1]):\n",
    "    \n",
    "    train_or_test_groups = ['train', 'test'] \n",
    "    \n",
    "    plt.figure(num=None, figsize=(4, 4), dpi=120, facecolor='w', edgecolor='k')\n",
    "    \n",
    "    handles = list()\n",
    "    for train_or_test in train_or_test_groups:\n",
    "        embed_points = embeddings[train_or_test].numpy()\n",
    "        h = plt.scatter(embed_points[:,dims[0]], embed_points[:,dims[1]], s=1, alpha=0.5)\n",
    "        \n",
    "        h = mpatches.Patch(color=h.get_facecolor()[0], label=train_or_test)\n",
    "        handles.append(h)\n",
    "        \n",
    "    plt.xlabel('$z^{' + r_or_s + '}_{' + str(dims[0]+1) + '}$')\n",
    "    plt.ylabel('$z^{' + r_or_s + '}_{' + str(dims[1]+1) + '}$')    \n",
    "            \n",
    "    plt.legend(handles, train_or_test_groups, loc=1)\n",
    "        \n",
    "    ax_range = 4\n",
    "#     plt.axis([-ax_range, ax_range, -ax_range, ax_range])\n",
    "#     plt.axis('equal')\n",
    "    \n",
    "    plt.xlim(-ax_range, ax_range)\n",
    "    plt.ylim(-ax_range, ax_range)\n",
    "    plt.gca().set_aspect('equal', adjustable='box')\n",
    "\n",
    "\n",
    "    plt.savefig(save_path, bbox_inches='tight')\n",
    "    \n",
    "    plt.close('all')\n",
    "    \n",
    "    pass\n",
    "    \n",
    "def print_latent_grid(dec, ref_or_class_num, save_path, default_gpu_id, ndims = 128, nclasses = 10, dims=[0,1], std=1.5, nsamples=5, colors=[[1,0,1], [1,1,0], [0,1,1]]):\n",
    "    \n",
    "    z = list()\n",
    "    \n",
    "    if ref_or_class_num is not 'ref':\n",
    "        label = Variable(torch.Tensor(1, nclasses).fill_(-50).cuda(default_gpu_id))\n",
    "        label.data[0][ref_or_class_num] = 0\n",
    "\n",
    "        z.append(label)\n",
    "        \n",
    "        z.append(Variable(torch.Tensor(1, ndims).fill_(0).cuda(default_gpu_id)))\n",
    "        \n",
    "\n",
    "\n",
    "    \n",
    "    z.append(Variable(torch.Tensor(1, ndims).fill_(0).cuda(default_gpu_id)))\n",
    "    \n",
    "    samples = np.linspace(-std, std, nsamples)\n",
    "    \n",
    "    images_w = list()\n",
    "    for i in samples:\n",
    "        images_h = list()\n",
    "        for j in samples:\n",
    "            z[-1].data[0][dims[0]] = i\n",
    "            z[-1].data[0][dims[1]] = j\n",
    "    \n",
    "#             pdb.set_trace()\n",
    "            im_out = dec(z)\n",
    "            image_out_flat = tensor2img(im_out.data.cpu(), colors)\n",
    "            images_h.append(image_out_flat)\n",
    "            \n",
    "        images_w.append(np.concatenate(images_h, axis=0))\n",
    "        \n",
    "    image_out = np.concatenate(images_w, axis=1)\n",
    "    \n",
    "    return image_out\n",
    "    \n",
    "def print_image_counts(dp, save_path):\n",
    "    n_train = dp.get_n_dat('train')\n",
    "    n_test = dp.get_n_dat('test')\n",
    "    labels_train = dp.get_classes(np.arange(0,n_train), 'train').numpy()\n",
    "    labels_test = dp.get_classes(np.arange(0,n_test), 'test').numpy()\n",
    "    ulabels = np.unique(labels_train)\n",
    "    \n",
    "    image_counts = list()\n",
    "    for label in ulabels:\n",
    "        label_name = dp.label_names[label]\n",
    "        n_train_class = len(np.where(labels_train == label)[0])\n",
    "        n_test_class = len(np.where(labels_test == label)[0])\n",
    "        \n",
    "        image_counts.append([label_name, n_train_class+n_test_class, n_train_class, n_test_class])\n",
    "    \n",
    "    df = pd.DataFrame(image_counts, columns={'Label name', '#total', '#train', '#test'})\n",
    "    df.to_csv(save_path, index=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print_image_counts(dp, figure_dir + os.sep + 'label_counts.csv')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig1_path = figure_dir + os.sep + 'fig1.png'\n",
    "fig1_s1_path = figure_dir + os.sep + 'fig1_s1.png'\n",
    "print_fig1(dp, fig1_path, fig1_s1_path)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig2_path = figure_dir + os.sep + 'fig2.png'\n",
    "fig2_s2_path = figure_dir + os.sep + 'fig2_s2.png'\n",
    "print_fig2(enc, dec, dp, fig2_path, fig2_s2_path, n_per_row=6, required_test_inds=[898])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "history_ref_path = figure_dir + os.sep + 'ref_history.png'\n",
    "print_history(logger_ref, history_ref_path, 'r')\n",
    "\n",
    "history_struct_path = figure_dir + os.sep + 'struct_history.png'\n",
    "print_history(logger, history_struct_path, 's')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "recon_path = figure_dir + os.sep + 'struct_recon.png'\n",
    "print_recon(enc, dec, dp, recon_path, gpu_ids[0])\n",
    "\n",
    "\n",
    "recon_path = figure_dir + os.sep + 'ref_recon.png'\n",
    "print_recon(enc_ref, dec_ref, dp_ref, recon_path, gpu_ids[0], colors=[[1,0,1], [0,1,1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "conf_mat_path = figure_dir + os.sep + 'conf_mat'\n",
    "print_conf_mat(enc, dp, figure_dir, 100, gpu_ids[0])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "[107, np.random.choice(embeddings['test'].shape[1],1)[0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "latent_recon_path = figure_dir + os.sep + 'ref_latent.png'\n",
    "embeddings_path = parent_dir + os.sep + 'ref_model' + os.sep + 'embeddings.pkl'\n",
    "embeddings = model_utils.load_embeddings(embeddings_path)\n",
    "\n",
    "print_latent_plot(embeddings, latent_recon_path, 'r', [23,44])\n",
    "\n",
    "\n",
    "latent_recon_path = figure_dir + os.sep + 'struct_latent.png'\n",
    "embeddings_path = parent_dir + os.sep + 'struct_model' + os.sep + 'embeddings.pkl'\n",
    "embeddings = model_utils.load_embeddings(embeddings_path)\n",
    "\n",
    "print_latent_plot(embeddings, latent_recon_path, 's', [106, 32])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Printing 0/10\n",
      "Printing 1/10\n",
      "Printing 2/10\n",
      "Printing 3/10\n",
      "Printing 4/10\n",
      "Printing 5/10\n",
      "Printing 6/10\n",
      "Printing 7/10\n",
      "Printing 8/10\n",
      "Printing 9/10\n"
     ]
    }
   ],
   "source": [
    "std = 10\n",
    "ndims = opt.nRef\n",
    "\n",
    "nclasses = 10\n",
    "\n",
    "# z = enc(dp.get_images([0], 'train'))\n",
    "\n",
    "\n",
    "\n",
    "latent_grid_path = figure_dir + os.sep + 'grid_ref.png'\n",
    "image_out = print_latent_grid(dec_ref, 'ref', latent_grid_path, gpu_ids[0], std=std, colors=[[1,0,1], [0,1,1]], ndims = ndims, nclasses = nclasses)\n",
    "\n",
    "scipy.misc.imsave(latent_grid_path, image_out)\n",
    "\n",
    "image_out_ref = print_latent_grid(dec_ref, 'ref', latent_grid_path, gpu_ids[0], std=0, colors=[[1,0,1], [0,1,1]], ndims = ndims, nclasses = nclasses)\n",
    "\n",
    "for i in range(0, dp.get_n_classes()):\n",
    "    print('Printing ' + str(i) + os.sep + str(dp.get_n_classes()))\n",
    "#     latent_grid_path = figure_dir + os.sep + 'grid_struct_' + dp.label_names[i] + '.png'\n",
    "#     image_out = print_latent_grid(dec, i, latent_grid_path, gpu_ids[0], std=std, colors=[[1,0,1], [1,1,0], [0,1,1]], ndims = ndims, nclasses = nclasses)\n",
    "#     scipy.misc.imsave(latent_grid_path, image_out)\n",
    "    \n",
    "    latent_grid_path = figure_dir + os.sep + 'grid_struct_' + dp.label_names[i] + '_struct_only.png'\n",
    "    image_out = print_latent_grid(dec, i, latent_grid_path, gpu_ids[0], std=std, colors=[[0,0,0], [1,1,0], [0,0,0]], ndims = ndims, nclasses = nclasses)\n",
    "    scipy.misc.imsave(latent_grid_path, image_out)\n",
    "    \n",
    "    image_out = image_out + image_out_ref\n",
    "#     image_out[:,:,2] = image_out_ref[:,:,1]\n",
    "    \n",
    "    latent_grid_path = figure_dir + os.sep + 'grid_struct_' + dp.label_names[i] + '.png'\n",
    "    scipy.misc.imsave(latent_grid_path, image_out)\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[Variable containing:\n",
      "\n",
      "Columns 0 to 7 \n",
      "  0.0000 -32.3141 -19.0148 -22.0346 -21.7774 -28.4024 -17.2961 -28.5288\n",
      "\n",
      "Columns 8 to 9 \n",
      "-17.6348 -18.7201\n",
      "[torch.cuda.FloatTensor of size 1x10 (GPU 0)]\n",
      ", Variable containing:\n",
      "\n",
      "Columns 0 to 9 \n",
      "-1.2421 -1.8666  1.0871  1.4356  0.2813 -0.0823  1.3790  1.5186 -0.1162 -2.8959\n",
      "\n",
      "Columns 10 to 19 \n",
      "-1.4965 -0.1092  0.3826  1.0575 -2.4080  0.3335  1.4474  2.3057  0.1236  0.3739\n",
      "\n",
      "Columns 20 to 29 \n",
      " 1.1852 -0.4940  0.0411 -1.4081  1.1685 -1.0205  0.3768 -0.4713 -0.4891 -0.5888\n",
      "\n",
      "Columns 30 to 39 \n",
      " 0.7135 -1.0510  0.9977  2.3815  1.8175 -0.4765 -0.1575  1.6662 -0.3010  1.4256\n",
      "\n",
      "Columns 40 to 49 \n",
      "-0.3097  1.3435 -0.4803 -1.0051 -0.7811 -1.3811 -0.3242  0.9104 -1.7442  0.0405\n",
      "\n",
      "Columns 50 to 59 \n",
      " 0.3927  1.4628 -0.5285 -0.6673  1.5614 -0.3529 -2.0507  0.1374 -1.7390  0.1917\n",
      "\n",
      "Columns 60 to 69 \n",
      " 0.8466  0.1126  0.6902 -1.6565 -0.2541 -0.8102 -0.7836 -1.6872 -0.1238  0.5039\n",
      "\n",
      "Columns 70 to 79 \n",
      "-1.7467 -0.6762  0.0683  1.3307  1.5949 -0.2569  1.0501  0.1787 -0.1180 -0.2491\n",
      "\n",
      "Columns 80 to 89 \n",
      " 0.1377 -0.8563  0.9400  1.3725  0.3858  0.9030 -0.1992 -0.6985 -1.3498  0.5417\n",
      "\n",
      "Columns 90 to 99 \n",
      " 1.2368 -0.5085  1.3633 -1.9218 -1.0510 -0.3237 -1.0685  1.9066  0.3237  0.2709\n",
      "\n",
      "Columns 100 to 109 \n",
      "-1.2031  0.3489  0.9867  0.4230  1.0171  0.0306  2.7131  0.5094  1.3189 -0.3738\n",
      "\n",
      "Columns 110 to 119 \n",
      "-2.0975 -0.6514 -0.5911  0.1316  1.2871  0.8053 -0.4333 -0.8309 -0.2835  1.1288\n",
      "\n",
      "Columns 120 to 127 \n",
      "-0.0374  2.5680  0.5422  1.1930 -2.1833  0.2898  1.6237  0.0103\n",
      "[torch.cuda.FloatTensor of size 1x128 (GPU 0)]\n",
      ", Variable containing:\n",
      "\n",
      "Columns 0 to 9 \n",
      "-0.4340 -0.3968  1.1887 -0.1730  1.1993  0.4987  1.7757  2.0052  0.0018  0.9146\n",
      "\n",
      "Columns 10 to 19 \n",
      " 0.0184 -0.0192 -0.1626 -1.3583  0.6230  1.0430  0.7139  0.3160 -0.1914  0.2233\n",
      "\n",
      "Columns 20 to 29 \n",
      " 0.2200  0.0626  1.3527  2.1846  0.0526 -2.0332 -0.9309  1.1942 -0.4271  0.0191\n",
      "\n",
      "Columns 30 to 39 \n",
      "-1.5206 -0.2347  0.6309  0.0040  0.7203  1.3783  1.8671 -1.2568 -0.0525  0.3229\n",
      "\n",
      "Columns 40 to 49 \n",
      " 0.9554 -2.3609  1.3074 -0.4722 -0.4064  1.3495 -0.6089 -1.5821  0.1833 -1.2512\n",
      "\n",
      "Columns 50 to 59 \n",
      " 0.2274 -0.3927 -0.0860  0.5075 -0.4977  0.1027 -1.0924  0.5872  0.3464  0.3101\n",
      "\n",
      "Columns 60 to 69 \n",
      "-0.2069 -0.2775  1.0804 -0.8259  1.4185  0.0869 -0.7134 -2.1501  0.9859 -1.5795\n",
      "\n",
      "Columns 70 to 79 \n",
      "-1.0268  0.6408 -0.3016  0.5896  0.5862 -0.0785 -0.1202  1.4733  0.4394  0.5838\n",
      "\n",
      "Columns 80 to 89 \n",
      " 0.9077 -0.5975  1.1033 -0.3725 -1.4896 -0.9367  0.6639  0.2355  0.9490  3.4984\n",
      "\n",
      "Columns 90 to 99 \n",
      " 0.1510 -2.3673 -2.1315  1.2706 -0.6181  0.2114  0.7445 -0.7003 -0.6942 -0.3650\n",
      "\n",
      "Columns 100 to 109 \n",
      "-1.4424  0.1256  0.5627  0.3960 -0.5196  1.5664 -0.6312  1.1040 -0.0322  2.5345\n",
      "\n",
      "Columns 110 to 119 \n",
      "-0.5376 -0.0433  1.5742 -0.5458 -0.0802  1.7039  0.6193 -0.7198  1.3250 -0.4942\n",
      "\n",
      "Columns 120 to 127 \n",
      "-0.5451  1.1875 -1.2451 -0.3927  1.0179  0.8842  0.2097 -0.1364\n",
      "[torch.cuda.FloatTensor of size 1x128 (GPU 0)]\n",
      "]\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/opt/conda/envs/pytorch-py3.6/lib/python3.6/site-packages/torch/nn/modules/container.py:67: UserWarning: Implicit dimension choice for log_softmax has been deprecated. Change the call to include dim=X as an argument.\n",
      "  input = module(input)\n"
     ]
    }
   ],
   "source": [
    "z = enc(Variable(dp.get_images([0], 'train')).cuda(0))\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "print(np.where(dp.data['test']['inds']==9049))\n",
    "\n",
    "\n",
    "# print(np.where(dp.data['test']['inds']==8824))\n",
    "\n",
    "# print(np.where(dp.data['test']['inds']==9238))\n",
    "\n",
    "# print(np.where(dp.data['test']['inds']==9538))\n",
    "\n",
    "# print(np.where(dp.data['test']['inds']==9695))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "save_path = figure_dir + os.sep + 'tmp.png'\n",
    "colors=[[1,0,1], [1,1,0], [0,1,1]]\n",
    "\n",
    "images = Variable(dp.get_images([1], 'train')).cuda(gpu_ids[0])\n",
    "z = enc(images)\n",
    "z[1].data[0].fill_(0)\n",
    "img_out = dec(z)\n",
    "img_out = img_out.data.cpu()\n",
    "\n",
    "\n",
    "scipy.misc.imsave(save_path, tensor2img(img_out, colors))\n",
    "\n",
    "print(z)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.arange(0,128,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp.get_n_dat('train')+dp.get_n_dat('test')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "dp.label_names"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}