VAE_version2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/ysm-gpfs/pi/zhao/Softwares/Anaconda3/envs/py35/lib/python3.5/site-packages/h5py/__init__.py:36: FutureWarning: Conversion of the second argument of issubdtype from `float` to `np.floating` is deprecated. In future, it will be treated as `np.float64 == np.dtype(float).type`.\n",
      "  from ._conv import register_converters as _register_converters\n"
     ]
    }
   ],
   "source": [
    "import torch\n",
    "from torch import nn as nn\n",
    "from torch.distributions import Normal, multivariate_normal\n",
    "from torch.utils.data import Dataset, DataLoader\n",
    "import numpy as np\n",
    "import collections\n",
    "from typing import Iterable\n",
    "import scipy.sparse as sp_sparse\n",
    "from sklearn.preprocessing import StandardScaler\n",
    "from collections import defaultdict\n",
    "from tqdm import trange\n",
    "import sys\n",
    "import time\n",
    "from sklearn.manifold import TSNE\n",
    "import matplotlib.pyplot as plt\n",
    "import scanpy as sc\n",
    "import torch.nn.functional as F"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "device = torch.device(\"cpu\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Generate_X:\n",
    "    def __init__(self, p, give_mean = 'zero', give_sigma = 'one'):\n",
    "        \"\"\"\n",
    "        give_sigma: whether the Sigma is diagonal matrix and same across cell types.\n",
    "                    'one': The variances of genes are all ones.\n",
    "                    'linspace': The variances of genes are different but even spaced numbers\n",
    "                    'uniform': The variances of gene are randomly generated from [0,1]\n",
    "        \"\"\"\n",
    "        self.p = p\n",
    "        if give_mean is 'zero':\n",
    "            self.mean = np.array([0]*self.p, dtype =float)\n",
    "        elif give_mean is 'linspace':\n",
    "            self.mean = np.linspace(0,2,num = self.p, dtype=float)\n",
    "        elif give_mean is 'uniform':\n",
    "            self.mean =  np.random.rand(self.p, dtype = float)\n",
    "        else:\n",
    "            print('Wrong argument!')\n",
    "            pass\n",
    "        if give_sigma is 'one':\n",
    "            self.sigma = np.array([1]*self.p)\n",
    "        elif give_sigma is 'linspace':\n",
    "            self.sigma = np.linspace(0,2,num = self.p)\n",
    "        elif give_mean is 'uniform':\n",
    "            self.sigma =  np.random.rand(self.p)\n",
    "        else:\n",
    "            print('Wrong argument!')\n",
    "            pass\n",
    "        \n",
    "\n",
    "    def sym_Sigma(self):\n",
    "        p = self.p\n",
    "        L = np.tril(np.random.random((p,p))*2,0)\n",
    "        sparse = np.random.binomial(1,0.2,(p,p))\n",
    "        diag_indices = np.diag_indices(p)\n",
    "        sparse[diag_indices] = 1\n",
    "        L = L * sparse\n",
    "        S = np.matmul(L,L.transpose())\n",
    "        return S\n",
    "\n",
    "    def generate(self, n_ct, n_vec, same_mean = True, same_sigma = True):\n",
    "        \"\"\"\n",
    "        n_ct: int, the number of cell types\n",
    "        n_vec: the vector of cell size\n",
    "        \"\"\"\n",
    "        assert n_ct == len(n_vec)\n",
    "        ct_label = []\n",
    "        rst = []\n",
    "        covmat = []\n",
    "        meanmat = []\n",
    "        for ct in range(n_ct):  # ct: cell type\n",
    "            if same_sigma:\n",
    "                Sigma = np.diag(self.sigma)\n",
    "            else:\n",
    "                Sigma = self.sym_Sigma()\n",
    "            Sigma = Sigma.astype(float)\n",
    "            if same_mean:\n",
    "                mean = self.mean\n",
    "            else:\n",
    "                mean = (np.random.rand(self.p)-0.5)*10\n",
    "            MVN = np.random.multivariate_normal(mean, Sigma, n_vec[ct])\n",
    "            #print(MVN)\n",
    "            rst.append(MVN)\n",
    "            ct_label.append(np.array([ct]*n_vec[ct]))\n",
    "            covmat.append(Sigma)\n",
    "            meanmat.append(mean)\n",
    "        mat = np.array(rst)\n",
    "        ct_label = np.array(ct_label)\n",
    "        self.X = np.reshape(mat, (-1,self.p))\n",
    "        self.ct_label = np.reshape(ct_label, (-1,))\n",
    "        self.covmat = covmat\n",
    "        self.meanmat = meanmat\n",
    "        # print(self.X, self.ct_label)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "def sim_sample_indices(sample_size):\n",
    "    sample_indices = [[i]*sample_size[i] for i in range(len(sample_size))]\n",
    "    return np.asarray(sample_indices).flatten()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CytofDataset_Sim(Dataset):\n",
    "    \"\"\" Create CyTOF dataset for Pytorch in Simulation\n",
    "        The class contains __len__() and __getitem__() which could be used for dataloader.\n",
    "    \n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self,X, sample_indices, label_indices):\n",
    "        self.dense = type(X) is np.ndarray\n",
    "        self._X = np.ascontiguousarray(X, dtype=np.float32) if self.dense else X\n",
    "        self.nb_genes = self.X.shape[1]\n",
    "        self.samples, self.n_samples, self.sample_dict = arrange_categories(sample_indices)\n",
    "        self.labels, self.n_labels, self.label_dict = arrange_categories(label_indices)\n",
    "\n",
    "    @property\n",
    "    def X(self):\n",
    "        return self._X\n",
    "\n",
    "    def __len__(self):\n",
    "        return self._X.shape[0]\n",
    "    \n",
    "    def __getitem__(self, idx):\n",
    "        return self.X[idx], self.samples[idx], self.labels[idx]\n",
    "    \n",
    "#    def collate_fn(self, batch):\n",
    "#        indexes = np.array(batch)\n",
    "#        X = self.X[indexes]\n",
    "#        return self.collate_fn_end(X, indexes)\n",
    "#    \n",
    "#    def collate_fn_end(self, X, indexes):\n",
    "\n",
    "#        if self.dense:\n",
    "#            X = torch.from_numpy(X)\n",
    "#        else:\n",
    "#            X = torch.FloatTensor(X.toarray())\n",
    "#        return X,  torch.LongTensor(self.samples[indexes]), \\\n",
    "#                   torch.LongTensor(self.labels[indexes])\n",
    "\n",
    "\n",
    "    def get_sample(self, sample_sublist):\n",
    "        \"\"\"\n",
    "        sample_sublist: list\n",
    "        \"\"\"\n",
    "        loc = np.array([np.where(self.samples == self.sample_dict[sample]) for sample in sample_sublist]).flatten()\n",
    "        X_sub = self._X[loc]\n",
    "        samples_sub = self.samples[loc]\n",
    "        labels_sub = self.labels[loc]\n",
    "        return X_sub, samples_sub, labels_sub\n",
    "    \n",
    "    def get_celltype(self, celltype_sublist):\n",
    "        \"\"\"\n",
    "        celltype_sublist: list\n",
    "        \"\"\"\n",
    "        loc = np.array([np.where(self.labels == self.label_dict[batch]) for label in celltype_sublist]).flatten()\n",
    "        X_sub = self._X[loc]\n",
    "        samples_sub = self.samples[loc]\n",
    "        labels_sub = self.labels[loc]\n",
    "        return X_sub, samples_sub, labels_sub"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "def arrange_categories(original_categories, mapping_from=None, mapping_to=None):\n",
    "    unique_categories = np.unique(original_categories)\n",
    "    n_categories = len(unique_categories)\n",
    "    batch_dict = dict()\n",
    "    if mapping_to is None:\n",
    "        mapping_to = range(n_categories)\n",
    "    if mapping_from is None:\n",
    "        mapping_from = unique_categories\n",
    "    assert n_categories <= len(mapping_from)  # one cell_type can have no instance in dataset # Haven't debug it. Assume we have more than one cell type.\n",
    "    assert len(mapping_to) == len(mapping_from)\n",
    "\n",
    "    new_categories = np.copy(original_categories)\n",
    "    for idx_from, idx_to in zip(mapping_from, mapping_to):\n",
    "        # print(idx_from, idx_to)\n",
    "        new_categories[original_categories == idx_from] = idx_to\n",
    "        batch_dict[idx_from] = idx_to\n",
    "    return new_categories.astype(int), n_categories, batch_dict\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Manual_Layers(nn.Module):\n",
    "    def __init__(self, n_in=10, n_hidden=100, n_out=2):\n",
    "        super(Manual_Layers, self).__init__()\n",
    "        self.layers = nn.Sequential(\n",
    "            nn.Linear(n_in, n_hidden),\n",
    "            nn.LeakyReLU(0.2),\n",
    "            nn.Linear(n_hidden, n_out*2),\n",
    "        )\n",
    "        \n",
    "        \n",
    "    def forward(self, x: torch.Tensor):\n",
    "        x = self.layers(x)\n",
    "        \n",
    "        return x"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Encoder(nn.Module):\n",
    "    r\"\"\"Encodes data of ``n_input`` dimensions into a latent space of ``n_output``\n",
    "    dimensions using a fully-connected neural network of ``n_hidden`` layers.\n",
    "\n",
    "    :param n_input: The dimensionality of the input (data space)\n",
    "    :param n_output: The dimensionality of the output (latent space)\n",
    "    :param n_layers: The number of fully-connected hidden layers\n",
    "    :param n_hidden: The number of nodes per hidden layer\n",
    "    :dropout_rate: Dropout rate to apply to each of the hidden layers\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, n_input: int, n_output: int,\n",
    "                 n_layers: int = 1,\n",
    "                 n_hidden: int = 128, dropout_rate: float = 0.1):\n",
    "        super(Encoder, self).__init__()\n",
    "\n",
    "        #self.encoder = FCLayers(n_in=n_input, n_out=n_hidden, n_layers=n_layers,\n",
    "        #                        n_hidden=n_hidden, dropout_rate=dropout_rate)\n",
    "        #self.mean_encoder = nn.Linear(n_hidden, n_output)\n",
    "        #self.var_encoder = nn.Linear(n_hidden, n_output)\n",
    "            \n",
    "        self.encoder = Manual_Layers(n_in = n_input, n_hidden = n_hidden, n_out = n_output)\n",
    "       \n",
    "\n",
    "    def reparameterize(self, mu, var):\n",
    "        return Normal(mu, var.sqrt()).rsample()\n",
    "    \n",
    "    def encoder_function(self, x):\n",
    "        h = self.encoder(x)\n",
    "        q_m, q_logv = torch.chunk(h, 2, dim=1)\n",
    "        return q_m, q_logv\n",
    "\n",
    "    def forward(self, x: torch.Tensor):\n",
    "        r\"\"\"The forward computation for a single sample.\n",
    "\n",
    "         #. Encodes the data into latent space using the encoder network\n",
    "         #. Generates a mean \\\\( q_m \\\\) and variance \\\\( q_v \\\\) (clamped to \\\\( [-5, 5] \\\\))\n",
    "         #. Samples a new value from an i.i.d. multivariate normal \\\\( \\\\sim N(q_m, \\\\mathbf{I}q_v) \\\\)\n",
    "\n",
    "        :param x: tensor with shape (n_input,)\n",
    "        :return: tensors of shape ``(n_latent,)`` for mean and var, and sample\n",
    "        :rtype: 3-tuple of :py:class:`torch.Tensor`\n",
    "        \"\"\"\n",
    "\n",
    "        # Parameters for latent distribution\n",
    "        q_m, q_logv = self.encoder_function(x)\n",
    "        q_v = torch.exp(q_logv)\n",
    "        \n",
    "        #q = self.encoder(x)\n",
    "        #q_m = self.mean_encoder(q)\n",
    "        #q_v = torch.exp(self.var_encoder(q))  # (computational stability safeguard)torch.clamp(, -5, 5)\n",
    "        latent = self.reparameterize(q_m, q_v)\n",
    "        return q_m, q_v, latent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class DecoderVCSC(nn.Module):\n",
    "    r\"\"\"Decodes data from latent space of ``n_input`` dimensions ``n_output``\n",
    "    dimensions using a fully-connected neural network of ``n_hidden`` layers.\n",
    "\n",
    "    :param n_input: The dimensionality of the input (latent space)\n",
    "    :param n_output: The dimensionality of the output (data space). It is also the number of genes\n",
    "    :param n_cat_list: A list containing the number of categories\n",
    "    :param n_layers: The number of fully-connected hidden layers\n",
    "    :param n_hidden: The number of nodes per hidden layer\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, n_input: int, n_output: int,\n",
    "                 n_layers: int = 1,\n",
    "                 n_hidden: int = 128):\n",
    "        super(DecoderVCSC, self).__init__()\n",
    "\n",
    "        # shape: shape parameter in gamma distribution infered from estimated covariance matrix\n",
    "        self.px_decoder =Manual_Layers(n_in = n_input, n_hidden = n_hidden, n_out = n_output)\n",
    "        \n",
    "        # mu\n",
    "        self.px_mu_decoder =  nn.Linear(n_hidden, n_output)\n",
    "\n",
    "#         # D\n",
    "#         self.px_D_decoder = nn.Sequential(nn.Linear(n_hidden, n_output))\n",
    "\n",
    "#         # L\n",
    "#         self.px_L_decoder = nn.Linear(n_hidden, int(n_output*(n_output-1)/2))\n",
    "\n",
    "#         # dropout\n",
    "#         #self.px_dropout_decoder = nn.Linear(n_hidden, n_output)\n",
    "\n",
    "\n",
    "\n",
    "\n",
    "    def forward(self, z: torch.Tensor):\n",
    "        r\"\"\"The forward computation for a single sample.\n",
    "\n",
    "         #. Decodes the data from the latent space using the decoder network\n",
    "         #. Returns parameters for the multiVariate normal distribution of expression\n",
    "\n",
    "        :param z: tensor with shape ``(n_input,)``\n",
    "        :param mu: empirical mean parameter in multivariate normal distribution with shape ``(#gene,)``\n",
    "        :param D: diagonal vector of D in cholesky decomposition, where \\Sigma = L^T * D * L, \n",
    "                    and \\Sigma is cov matrix in multivariate normal distribution with shape ``(#gene,)``\n",
    "        :param L: vector of unit lower triangular L matrix in cholesky decomposition with shape ``(#gene*(#gene-1)/2)``\n",
    "        :return: parameters for the multivariate normal distribution of expression\n",
    "        :rtype: `torch.Tensor`\n",
    "        \"\"\"\n",
    "\n",
    "        \n",
    "\n",
    "        # The decoder returns values for the parameters of the ZINB distribution\n",
    "        px = self.px_decoder(z)\n",
    "        px_mu = self.px_mu_decoder(px)\n",
    "#         px_D = self.px_D_decoder(px)\n",
    "#         px_D = torch.exp(px_D)\n",
    "#         px_L = self.px_L_decoder(px)\n",
    "        #print(px_L.size())\n",
    "        #px_L = self.ReshapeL(px_L)\n",
    "        #px_L = self.ReshapeL(px_L)\n",
    "        #px_dropout = self.px_dropout_decoder(px_sigma)\n",
    "        \n",
    "        \n",
    "#         return px_mu, px_D, px_L\n",
    "        return px_mu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "def log_gaussian_positive(x, px_mu):\n",
    "    \"\"\"\n",
    "    This log likelihood is replaced by L2 square error\n",
    "    \"\"\"\n",
    "\n",
    "    reconst_loss =  -((px_mu-x)**2).sum(dim=-1) \n",
    "\n",
    "    \n",
    "    #res = part1 + part2\n",
    "    return reconst_loss"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "class VAE(nn.Module):\n",
    "    r\"\"\"Variational auto-encoder model.\n",
    "\n",
    "    :param n_input: Number of input genes\n",
    "    :param n_batch: Number of batches\n",
    "    :param n_labels: Number of labels\n",
    "    :param n_hidden: Number of nodes per hidden layer\n",
    "    :param n_latent: Dimensionality of the latent space\n",
    "    :param n_layers: Number of hidden layers used for encoder and decoder NNs\n",
    "    :param dropout_rate: Dropout rate for neural networks\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, n_input: int, n_labels: int = 18,\n",
    "                 n_hidden: int = 128, n_latent: int = 10, n_layers: int = 1,\n",
    "                 dropout_rate: float = 0.1):\n",
    "        super(VAE, self).__init__()\n",
    "        self.n_latent = n_latent\n",
    "        self.n_labels = n_labels\n",
    "\n",
    "        self.z_encoder = Encoder(n_input, n_latent, n_layers=n_layers, n_hidden=n_hidden,\n",
    "                                 dropout_rate=dropout_rate)\n",
    "        # decoder goes from n_latent-dimensional space to n_input-d data\n",
    "        self.decoder = nn.Linear(n_latent, n_input)\n",
    "        # self.decoder = DecoderVCSC(n_latent, n_input, n_layers=n_layers, n_hidden=n_hidden)\n",
    "\n",
    "    def get_latents(self, x, give_mean):\n",
    "        r\"\"\" returns the result of ``sample_from_posterior_z`` inside a list\n",
    "\n",
    "        :param x: tensor of values with shape ``(batch_size, n_input)``\n",
    "        :return: one element list of tensor\n",
    "        :rtype: list of :py:class:`torch.Tensor`\n",
    "        \"\"\"\n",
    "        return [self.sample_from_posterior_z(x, give_mean)]\n",
    "\n",
    "    def sample_from_posterior_z(self, x, give_mean=False):\n",
    "        r\"\"\" samples the tensor of latent values from the posterior\n",
    "        #doesn't really sample, returns the means of the posterior distribution\n",
    "\n",
    "        :param x: tensor of values with shape ``(batch_size, n_input)``\n",
    "        :param give_mean: is True when we want the mean of the posterior  distribution rather than sampling\n",
    "        :return: tensor of shape ``(batch_size, n_latent)``\n",
    "        :rtype: :py:class:`torch.Tensor`\n",
    "        \"\"\"\n",
    "        qz_m, qz_v, z = self.z_encoder(x)  \n",
    "        if give_mean:\n",
    "            z = qz_m\n",
    "        return z\n",
    "\n",
    "    def get_sample_mu(self, x):\n",
    "        r\"\"\"Returns the tensor of predicted frequencies of expression\n",
    "\n",
    "        :param x: tensor of values with shape ``(batch_size, n_input)``\n",
    "        :return: tensor of predicted frequencies of expression with shape ``(batch_size, n_input)``\n",
    "        \"\"\"\n",
    "        return self.inference(x)[0]\n",
    "\n",
    "    # def get_sample_D(self, x):\n",
    "    #     r\"\"\"Returns the tensor of means of the negative binomial distribution\n",
    "\n",
    "    #     :param x: tensor of values with shape ``(batch_size, n_input)``\n",
    "    #     :return: tensor of means of the negative binomial distribution with shape ``(batch_size, n_input)``\n",
    "    #     \"\"\"\n",
    "    #     return self.inference(x)[1]\n",
    "\n",
    "    # def get_sample_L(self, x):\n",
    "    #     r\"\"\"Returns the tensor of means of the negative binomial distribution\n",
    "\n",
    "    #     :param x: tensor of values with shape ``(batch_size, n_input)``\n",
    "    #     :return: tensor of means of the negative binomial distribution with shape ``(batch_size, n_input)``\n",
    "    #     \"\"\"\n",
    "    #     return self.inference(x)[2]\n",
    "\n",
    "    def _reconstruction_loss(self, x, px_mu):\n",
    "        # Reconstruction Loss\n",
    "        #reconst_loss = -log_gaussian_positive(x, px_mu, px_D, px_L)\n",
    "        #return reconst_loss\n",
    "        \n",
    "        recon_loss = log_gaussian_positive(x, px_mu)\n",
    "        return - recon_loss\n",
    "    \n",
    "\n",
    "    def inference(self, x):\n",
    "        x_ = x\n",
    "\n",
    "        # Sampling\n",
    "        qz_m, qz_v, z = self.z_encoder(x_)\n",
    "\n",
    "        # px_mu, px_D, px_L = self.decoder(z)\n",
    "        px_mu = self.decoder(z)\n",
    "        \n",
    "\n",
    "        return px_mu, qz_m, qz_v, z\n",
    "    \n",
    "    # def reconst_x(self, px_mu, px_D):\n",
    "    #     reconst_x = Normal(px_mu, 1/px_D).rsample()\n",
    "        \n",
    "\n",
    "    def forward(self, x):\n",
    "        r\"\"\" Returns the reconstruction loss and the Kullback divergences\n",
    "\n",
    "        :param x: tensor of values with shape (batch_size, n_input)\n",
    "        :return: the reconstruction loss and the Kullback divergences\n",
    "        \"\"\"\n",
    "        # Parameters for z latent distribution\n",
    "\n",
    "        px_mu, qz_m, qz_v, z = self.inference(x)\n",
    "        #reconst_loss = self._reconstruction_loss(x, px_mu, px_D, px_L)\n",
    "        reconst_loss = self._reconstruction_loss(x, px_mu)\n",
    "\n",
    "        # KL Divergence between two multivariate normal distributions\n",
    "        # mean = torch.zeros_like(qz_m)\n",
    "        # scale = torch.ones_like(qz_v)\n",
    "\n",
    "        # kl_divergence = torch.distributions.kl.kl_divergence(Normal(qz_m, torch.sqrt(qz_v)), Normal(mean, scale)).sum(dim=-1)\n",
    "        kl_divergence = - 0.5 * torch.sum(1 + torch.log(qz_v) - qz_m**2 - qz_v)\n",
    "        \n",
    "        return reconst_loss, kl_divergence"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate Simulation dataset in 10 dimensional space and 2 cell types. There are 1500 cells in each cell type population. No multi-sample problem included.\n",
    "sim1 = Generate_X(10)\n",
    "sim1.generate(2,[1500,1500], same_mean = False, same_sigma = False)\n",
    "sample_size = np.repeat(3000,1)\n",
    "sample_indices = sim_sample_indices(sample_size)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Generate CytofDataset_Sim class\n",
    "simX_data = CytofDataset_Sim(sim1.X, sample_indices, sim1.ct_label)\n",
    "simX, _, labels = simX_data.get_sample([0]) ## Used for simulation without multiple batches integration\n",
    "gene_dataset = simX_data"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Parameters Setup\n",
    "p = 10 # dimension of X\n",
    "d = 2 # dimension of z\n",
    "n_input = p\n",
    "n_latent = d\n",
    "n_layers = 3\n",
    "n_hidden = 20 # dimension of hidden layer\n",
    "dropout_rate = 0.1\n",
    "n_epochs = 150\n",
    "lr=1e-3\n",
    "batch_size = 1500"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.savetxt('./write/simulation', sim1.X, delimiter = ',')\n",
    "adata = sc.read_csv('./write/simulation')\n",
    "adata.obs['cell type'] = sim1.ct_label\n",
    "adata.obs['batch'] = sample_indices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "sc.pp.neighbors(adata, n_neighbors = 15, metric = 'euclidean', random_state = None)\n",
    "sc.tl.umap(adata, min_dist = 0.1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sc.pl.umap(adata, color = 'cell type')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [],
   "source": [
    "vae = VAE(gene_dataset.nb_genes, gene_dataset.n_labels,\n",
    "                 n_hidden = n_hidden, n_latent = n_latent, n_layers = n_layers)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_init = vae.get_sample_mu(torch.from_numpy(gene_dataset.X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "epochs = 100\n",
    "data_loader =  torch.utils.data.DataLoader(gene_dataset, batch_size = 100, shuffle =True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [],
   "source": [
    "optimizer = torch.optim.Adam(vae.parameters(), lr=1e-3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch[1/100] Loss: 0.075\n",
      "Epoch[2/100] Loss: 0.072\n",
      "Epoch[3/100] Loss: 0.065\n",
      "Epoch[4/100] Loss: 0.063\n",
      "Epoch[5/100] Loss: 0.063\n",
      "Epoch[6/100] Loss: 0.063\n",
      "Epoch[7/100] Loss: 0.056\n",
      "Epoch[8/100] Loss: 0.052\n",
      "Epoch[9/100] Loss: 0.050\n",
      "Epoch[10/100] Loss: 0.048\n",
      "Epoch[11/100] Loss: 0.047\n",
      "Epoch[12/100] Loss: 0.047\n",
      "Epoch[13/100] Loss: 0.045\n",
      "Epoch[14/100] Loss: 0.046\n",
      "Epoch[15/100] Loss: 0.042\n",
      "Epoch[16/100] Loss: 0.044\n",
      "Epoch[17/100] Loss: 0.039\n",
      "Epoch[18/100] Loss: 0.043\n",
      "Epoch[19/100] Loss: 0.041\n",
      "Epoch[20/100] Loss: 0.041\n",
      "Epoch[21/100] Loss: 0.040\n",
      "Epoch[22/100] Loss: 0.039\n",
      "Epoch[23/100] Loss: 0.040\n",
      "Epoch[24/100] Loss: 0.038\n",
      "Epoch[25/100] Loss: 0.040\n",
      "Epoch[26/100] Loss: 0.044\n",
      "Epoch[27/100] Loss: 0.039\n",
      "Epoch[28/100] Loss: 0.039\n",
      "Epoch[29/100] Loss: 0.040\n",
      "Epoch[30/100] Loss: 0.040\n",
      "Epoch[31/100] Loss: 0.038\n",
      "Epoch[32/100] Loss: 0.040\n",
      "Epoch[33/100] Loss: 0.042\n",
      "Epoch[34/100] Loss: 0.038\n",
      "Epoch[35/100] Loss: 0.040\n",
      "Epoch[36/100] Loss: 0.039\n",
      "Epoch[37/100] Loss: 0.040\n",
      "Epoch[38/100] Loss: 0.037\n",
      "Epoch[39/100] Loss: 0.039\n",
      "Epoch[40/100] Loss: 0.039\n",
      "Epoch[41/100] Loss: 0.037\n",
      "Epoch[42/100] Loss: 0.040\n",
      "Epoch[43/100] Loss: 0.036\n",
      "Epoch[44/100] Loss: 0.035\n",
      "Epoch[45/100] Loss: 0.035\n",
      "Epoch[46/100] Loss: 0.035\n",
      "Epoch[47/100] Loss: 0.035\n",
      "Epoch[48/100] Loss: 0.033\n",
      "Epoch[49/100] Loss: 0.036\n",
      "Epoch[50/100] Loss: 0.034\n",
      "Epoch[51/100] Loss: 0.036\n",
      "Epoch[52/100] Loss: 0.035\n",
      "Epoch[53/100] Loss: 0.036\n",
      "Epoch[54/100] Loss: 0.037\n",
      "Epoch[55/100] Loss: 0.034\n",
      "Epoch[56/100] Loss: 0.033\n",
      "Epoch[57/100] Loss: 0.033\n",
      "Epoch[58/100] Loss: 0.033\n",
      "Epoch[59/100] Loss: 0.034\n",
      "Epoch[60/100] Loss: 0.033\n",
      "Epoch[61/100] Loss: 0.034\n",
      "Epoch[62/100] Loss: 0.032\n",
      "Epoch[63/100] Loss: 0.032\n",
      "Epoch[64/100] Loss: 0.032\n",
      "Epoch[65/100] Loss: 0.034\n",
      "Epoch[66/100] Loss: 0.034\n",
      "Epoch[67/100] Loss: 0.032\n",
      "Epoch[68/100] Loss: 0.034\n",
      "Epoch[69/100] Loss: 0.033\n",
      "Epoch[70/100] Loss: 0.036\n",
      "Epoch[71/100] Loss: 0.033\n",
      "Epoch[72/100] Loss: 0.031\n",
      "Epoch[73/100] Loss: 0.032\n",
      "Epoch[74/100] Loss: 0.029\n",
      "Epoch[75/100] Loss: 0.031\n",
      "Epoch[76/100] Loss: 0.034\n",
      "Epoch[77/100] Loss: 0.031\n",
      "Epoch[78/100] Loss: 0.030\n",
      "Epoch[79/100] Loss: 0.030\n",
      "Epoch[80/100] Loss: 0.031\n",
      "Epoch[81/100] Loss: 0.031\n",
      "Epoch[82/100] Loss: 0.032\n",
      "Epoch[83/100] Loss: 0.029\n",
      "Epoch[84/100] Loss: 0.032\n",
      "Epoch[85/100] Loss: 0.031\n",
      "Epoch[86/100] Loss: 0.029\n",
      "Epoch[87/100] Loss: 0.030\n",
      "Epoch[88/100] Loss: 0.031\n",
      "Epoch[89/100] Loss: 0.031\n",
      "Epoch[90/100] Loss: 0.029\n",
      "Epoch[91/100] Loss: 0.028\n",
      "Epoch[92/100] Loss: 0.031\n",
      "Epoch[93/100] Loss: 0.031\n",
      "Epoch[94/100] Loss: 0.031\n",
      "Epoch[95/100] Loss: 0.030\n",
      "Epoch[96/100] Loss: 0.031\n",
      "Epoch[97/100] Loss: 0.028\n",
      "Epoch[98/100] Loss: 0.028\n",
      "Epoch[99/100] Loss: 0.029\n",
      "Epoch[100/100] Loss: 0.029\n"
     ]
    }
   ],
   "source": [
    "for epoch in range(epochs):\n",
    "    KL_weight = min(0.1, epoch/400)\n",
    "    for tensors_list in data_loader:\n",
    "        X, sample_list, label_list = tensors_list\n",
    "        recon_loss, KL = vae(X)\n",
    "        loss = torch.mean(recon_loss + KL_weight* KL)\n",
    "\n",
    "        optimizer.zero_grad()\n",
    "        loss.backward()\n",
    "        optimizer.step()\n",
    "        \n",
    "    print(\"Epoch[{}/{}] Loss: {:.3f}\".format(epoch+1, epochs, loss.data/batch_size))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_out = vae.get_sample_mu(torch.from_numpy(gene_dataset.X))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = gene_dataset.X\n",
    "x = torch.from_numpy(x).float()\n",
    "z = vae.get_latents(x, give_mean=True)\n",
    "z = z[0].detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<matplotlib.collections.PathCollection at 0x2af11df44c18>"
      ]
     },
     "execution_count": 111,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "plt.scatter(z[:,0], z[:,1], c = gene_dataset.labels, s = [1]*len(z), marker='o')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "([array([  3.,  27., 178., 568., 544., 166.,  13.,   1.,   0.,   0.]),\n",
       "  array([  0.,   0.,   5.,  46., 308., 600., 424., 105.,  11.,   1.]),\n",
       "  array([  7.,  40., 193., 333., 410., 340., 137.,  33.,   7.,   0.]),\n",
       "  array([  0.,   0.,   1.,  22., 145., 393., 517., 342.,  71.,   9.])],\n",
       " array([-1.8428144 , -0.853525  ,  0.13576451,  1.125054  ,  2.1143434 ,\n",
       "         3.103633  ,  4.092922  ,  5.082212  ,  6.0715013 ,  7.060791  ,\n",
       "         8.05008   ], dtype=float32),\n",
       " <a list of 4 Lists of Patches objects>)"
      ]
     },
     "execution_count": 124,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# Comparing true mean and estimated means\n",
    "i= 7\n",
    "plt.hist([mu_out[0:1500,i].detach().numpy(),mu_out[1500:3000,i].detach().numpy(), gene_dataset.X[0:1500,i], gene_dataset.X[1500:3000,i]], label = [\"ct_1_out\",\"ct_2_out\", \"ct_1\", \"ct_2\"])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([[-4.1520, -0.3836,  0.3578,  ...,  3.5136,  1.3413, -3.4974],\n",
       "        [-3.9964, -0.3718,  0.3312,  ...,  3.4554,  1.2794, -3.4222],\n",
       "        [-4.0183, -0.3721,  0.3074,  ...,  3.4765,  1.3369, -3.4283],\n",
       "        ...,\n",
       "        [-4.0992, -0.3481,  0.3595,  ...,  3.4876,  1.3897, -3.4629],\n",
       "        [-4.1139, -0.3899,  0.3628,  ...,  3.4985,  1.2865, -3.4819],\n",
       "        [-4.0081, -0.3699,  0.3128,  ...,  3.4806,  1.3117, -3.4390]],\n",
       "       grad_fn=<AddmmBackward>)"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "mu_out"
   ]
  },
  {
   "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.5.4"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}