MARS_source.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "attended-cookie",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "import anndata\n",
    "from scipy.spatial import distance\n",
    "import scanpy as sc\n",
    "from collections import OrderedDict\n",
    "from collections import defaultdict"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "found-marijuana",
   "metadata": {},
   "outputs": [],
   "source": [
    "import argparse\n",
    "\n",
    "\n",
    "def get_parser():\n",
    "    parser = argparse.ArgumentParser()\n",
    "    \n",
    "    parser.add_argument('-pretrain_batch', '--pretrain_batch',\n",
    "                        type=int,\n",
    "                        help='Batch size for pretraining. Default: no batch',\n",
    "                        default=None)\n",
    "    \n",
    "    parser.add_argument('-pretrain','--pretrain',\n",
    "                        type = bool,\n",
    "                        default = True,\n",
    "                        help='Pretrain model with autoencoder; otherwise load existing')\n",
    "    \n",
    "    parser.add_argument('-nepoch', '--epochs',\n",
    "                        type=int,\n",
    "                        help='number of epochs to train for',\n",
    "                        default=30)\n",
    "\n",
    "    parser.add_argument('-nepoch_pretrain', '--epochs_pretrain',\n",
    "                        type=int,\n",
    "                        help='number of epochs to pretrain for',\n",
    "                        default=25)\n",
    "\n",
    "    parser.add_argument('-source_file','--model_file',\n",
    "                        type = str,\n",
    "                        default = 'trained_models/source.pt',\n",
    "                        help='location for storing source model and data')\n",
    "\n",
    "    parser.add_argument('-lr', '--learning_rate',\n",
    "                        type=float,\n",
    "                        help='learning rate for the model, default=0.001',\n",
    "                        default=0.001)\n",
    "\n",
    "    parser.add_argument('-lrS', '--lr_scheduler_step',\n",
    "                        type=int,\n",
    "                        help='StepLR learning rate scheduler step, default=20',\n",
    "                        default=20) \n",
    "\n",
    "    parser.add_argument('-lrG', '--lr_scheduler_gamma',\n",
    "                        type=float,\n",
    "                        help='StepLR learning rate scheduler gamma, default=0.5',\n",
    "                        default=0.5)\n",
    "  \n",
    "    parser.add_argument('-seed', '--manual_seed',\n",
    "                        type=int,\n",
    "                        help='input for the manual seeds initializations',\n",
    "                        default=3)\n",
    "    \n",
    "    parser.add_argument('--cuda',\n",
    "                        action='store_true',\n",
    "                        help='enables cuda')\n",
    "    \n",
    "    return parser"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "characteristic-deposit",
   "metadata": {},
   "outputs": [],
   "source": [
    "params, unknown= get_parser().parse_known_args()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "distant-conditions",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Namespace(cuda=False, epochs=30, epochs_pretrain=25, learning_rate=0.001, lr_scheduler_gamma=0.5, lr_scheduler_step=20, manual_seed=3, model_file='trained_models/source.pt', pretrain=True, pretrain_batch=None)"
      ]
     },
     "execution_count": 127,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "eleven-eligibility",
   "metadata": {},
   "outputs": [],
   "source": [
    "if torch.cuda.is_available() and not params.cuda:\n",
    "        print(\"WARNING: You have a CUDA device, so you should probably run with --cuda\")\n",
    "device = 'cuda:0' if torch.cuda.is_available() and params.cuda else 'cpu'\n",
    "params.device = device"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "fallen-thing",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Namespace(cuda=False, device='cpu', epochs=30, epochs_pretrain=25, learning_rate=0.001, lr_scheduler_gamma=0.5, lr_scheduler_step=20, manual_seed=3, model_file='trained_models/source.pt', pretrain=True, pretrain_batch=None)"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "params"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "backed-figure",
   "metadata": {},
   "outputs": [],
   "source": [
    "# coding=utf-8\n",
    "import torch.utils.data as data\n",
    "import numpy as np\n",
    "import torch\n",
    "\n",
    "'''\n",
    "Class representing dataset for an single-cell experiment.\n",
    "'''\n",
    "\n",
    "IMG_CACHE = {}\n",
    "\n",
    "\n",
    "class ExperimentDataset(data.Dataset):\n",
    "    \n",
    "    \n",
    "    def __init__(self, x, cells, genes, metadata, y=[]):\n",
    "        '''\n",
    "        x: numpy array of gene expressions of cells (rows are cells)\n",
    "        cells: cell IDs in the order of appearance\n",
    "        genes: gene IDs in the order of appearance\n",
    "        metadata: experiment identifier\n",
    "        y: numeric labels of cells (empty list if unknown)\n",
    "        '''\n",
    "        super(ExperimentDataset, self).__init__()\n",
    "        \n",
    "        self.nitems = x.shape[0]\n",
    "        if len(y)>0:\n",
    "            print(\"== Dataset: Found %d items \" % x.shape[0])\n",
    "            print(\"== Dataset: Found %d classes\" % len(np.unique(y)))\n",
    "                \n",
    "        if type(x)==torch.Tensor:\n",
    "            self.x = x\n",
    "        else:\n",
    "            shape = x.shape[1]\n",
    "            self.x = [torch.from_numpy(inst).view(shape).float() for inst in x]\n",
    "        if len(y)==0:\n",
    "            y = np.zeros(len(self.x), dtype=np.int64)\n",
    "        self.y = tuple(y.tolist())\n",
    "        self.xIDs = cells\n",
    "        self.yIDs = genes\n",
    "        self.metadata = metadata\n",
    "            \n",
    "    def __getitem__(self, idx):\n",
    "        return self.x[idx].squeeze(), self.y[idx], self.xIDs[idx]\n",
    "    #, self.yIDs[idx]\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.nitems\n",
    "    \n",
    "    def get_dim(self):\n",
    "        return self.x[0].shape[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "retained-charter",
   "metadata": {},
   "outputs": [],
   "source": [
    "adata=sc.read_h5ad(\"/Users/yaoestelle/scRNA_mit.h5ad\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "middle-conservation",
   "metadata": {},
   "outputs": [],
   "source": [
    "sub = adata[:5000,:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "id": "inclusive-climb",
   "metadata": {},
   "outputs": [],
   "source": [
    "###Choose one cell type as unannotated\n",
    "noT =  sub[:3000,]\n",
    "y_annotated = np.array(noT.obs['dbscan'], dtype=np.int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "id": "racial-admission",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "== Dataset: Found 3000 items \n",
      "== Dataset: Found 8 classes\n"
     ]
    }
   ],
   "source": [
    "annotated = ExperimentDataset(noT.X.toarray(), \n",
    "                              noT.obs_names, \n",
    "                              noT.var_names, \n",
    "                              'noTcell', y_annotated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "id": "affected-sight",
   "metadata": {},
   "outputs": [],
   "source": [
    "Tcell =  sub[3000:,]\n",
    "y_unannotated = np.array(Tcell.obs['dbscan'], dtype=np.int64)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "id": "illegal-nepal",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "== Dataset: Found 2000 items \n",
      "== Dataset: Found 6 classes\n"
     ]
    }
   ],
   "source": [
    "unannotated = ExperimentDataset(Tcell.X.toarray(), \n",
    "                                Tcell.obs_names, \n",
    "                                Tcell.var_names, \n",
    "                                'Tcell', y_unannotated)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "id": "published-kelly",
   "metadata": {},
   "outputs": [],
   "source": [
    "pretrain_data = ExperimentDataset(Tcell.X.toarray(), \n",
    "                                  Tcell.obs_names, \n",
    "                                  Tcell.var_names, 'Tcell')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "id": "controversial-campus",
   "metadata": {},
   "outputs": [],
   "source": [
    "n_clusters = len(np.unique(unannotated.y))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "id": "regional-metropolitan",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "6"
      ]
     },
     "execution_count": 154,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_clusters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "id": "furnished-fossil",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Counter({1: 1236, 2: 6, 3: 1232, 4: 317, 5: 4, 6: 200, 7: 3, 8: 2})"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Counter(unannotated.y)\n",
    "Counter(annotated.y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "id": "impressed-favorite",
   "metadata": {},
   "outputs": [],
   "source": [
    "class EpochSampler(object):\n",
    "    '''\n",
    "    EpochSampler: yield permuted indexes at each epoch.\n",
    "   \n",
    "    __len__ returns the number of episodes per epoch (same as 'self.iterations').\n",
    "    '''\n",
    "\n",
    "    def __init__(self, indices):\n",
    "        '''\n",
    "        Initialize the EpochSampler object\n",
    "        Args:\n",
    "        - labels: an iterable containing all the labels for the current dataset\n",
    "        samples indexes will be infered from this iterable.\n",
    "        - iterations: number of epochs\n",
    "        '''\n",
    "        super(EpochSampler, self).__init__()\n",
    "        self.indices = indices\n",
    "        \n",
    "\n",
    "    def __iter__(self):\n",
    "        '''\n",
    "        yield a batch of indexes\n",
    "        '''\n",
    "        \n",
    "        while(True):\n",
    "            shuffled_idx = self.indices[torch.randperm(len(self.indices))]\n",
    "            \n",
    "            yield shuffled_idx\n",
    "            \n",
    "\n",
    "    def __len__(self):\n",
    "        '''\n",
    "        returns the number of iterations (episodes) per epoch\n",
    "        '''\n",
    "        return self.iterations"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "id": "median-cologne",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.utils.data import DataLoader ##prefetch by batch\n",
    "#from model.epoch_sampler import EpochSampler\n",
    "\n",
    "\n",
    "def init_labeled_loader(data, val_split = 0.8):\n",
    "    \"\"\"Initialize loaders for train and validation sets. \n",
    "    Class labels are used only\n",
    "    for stratified sampling between train and validation set.\"\"\"\n",
    "    \n",
    "    target = torch.tensor(list(data.y))\n",
    "    uniq = torch.unique(target, sorted=True)\n",
    "    \n",
    "    class_idxs = list(map(lambda c: target.eq(c).nonzero(), uniq))\n",
    "    class_idxs = [idx[torch.randperm(len(idx))] for idx in class_idxs]\n",
    "    \n",
    "    train_idx = torch.cat([idx[:int(val_split*len(idx))] for idx in class_idxs])\n",
    "    val_idx = torch.cat([idx[int(val_split*len(idx)):] for idx in class_idxs])\n",
    "    \n",
    "    train_loader = DataLoader(data, \n",
    "                              batch_sampler=EpochSampler(train_idx),\n",
    "                              pin_memory=True)\n",
    "    \n",
    "    val_loader = DataLoader(data, \n",
    "                            batch_sampler=EpochSampler(val_idx),\n",
    "                            pin_memory=True)\n",
    "    \n",
    "    return train_loader, val_loader\n",
    "\n",
    "\n",
    "def init_loader(datasets, val_split = 0.8):\n",
    "    \n",
    "    train_loader_all = []\n",
    "    val_loader_all = []\n",
    "    \n",
    "    for data in datasets:\n",
    "        \n",
    "        curr_load_tr, curr_load_val = init_labeled_loader(data, val_split)\n",
    "        train_loader_all.append(curr_load_tr)\n",
    "        val_loader_all.append(curr_load_val)\n",
    "    \n",
    "    if val_split==1:\n",
    "        val_loader_all = None\n",
    "        \n",
    "    return train_loader_all, val_loader_all\n",
    "\n",
    "\n",
    "def init_data_loaders(labeled_data, unlabeled_data, \n",
    "                      pretrain_data, pretrain_batch, val_split):\n",
    "    \n",
    "    \"\"\"Initialize loaders for pretraing, \n",
    "    training (labeled and unlabeled datasets) and validation. \"\"\"\n",
    "    \n",
    "    train_loader, val_loader = init_loader(labeled_data, val_split)\n",
    "    \n",
    "    if not pretrain_data:\n",
    "        pretrain_data = unlabeled_data\n",
    "    \n",
    "    pretrain_loader = torch.utils.data.DataLoader(dataset=pretrain_data, shuffle=True,\n",
    "                                                  batch_size=pretrain_batch if pretrain_batch!=None else len(unlabeled_data.x))        \n",
    "    test_loader = DataLoader(unlabeled_data, \n",
    "                            batch_sampler=EpochSampler(torch.randperm(len(unlabeled_data.x))),\n",
    "                            pin_memory=True) \n",
    "    \n",
    "    #test_loader,_ = init_loader([unlabeled_data], 1.0) # to reproduce results in the paper\n",
    "    #test_loader = test_loader[0]\n",
    "    return train_loader, test_loader, pretrain_loader, val_loader\n",
    "           \n",
    "           \n",
    "def euclidean_dist(x, y):\n",
    "    '''\n",
    "    Compute euclidean distance between two tensors\n",
    "    '''\n",
    "    # x: N x D\n",
    "    # y: M x D\n",
    "    n = x.size(0)\n",
    "    m = y.size(0)\n",
    "    d = x.size(1)\n",
    "    if d != y.size(1):\n",
    "        raise Exception\n",
    "\n",
    "    x = x.unsqueeze(1).expand(n, m, d)\n",
    "    y = y.unsqueeze(0).expand(n, m, d)\n",
    "\n",
    "    return torch.pow(x - y, 2).sum(2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "id": "valued-pocket",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch.nn as nn\n",
    "\n",
    "def full_block(in_features, out_features, p_drop):\n",
    "        return nn.Sequential(\n",
    "            nn.Linear(in_features, out_features, bias=True),\n",
    "            nn.LayerNorm(out_features),\n",
    "            nn.ELU(),\n",
    "            nn.Dropout(p=p_drop),\n",
    "        )\n",
    "\n",
    "class FullNet(nn.Module):\n",
    "    '''\n",
    "    '''\n",
    "    def __init__(self, x_dim, hid_dim=64, z_dim=64, p_drop=0.2):\n",
    "        super(FullNet, self).__init__()\n",
    "        self.z_dim = z_dim\n",
    "        \n",
    "        self.encoder = nn.Sequential(\n",
    "            full_block(x_dim, hid_dim, p_drop),\n",
    "            full_block(hid_dim, z_dim, p_drop),\n",
    "        )\n",
    "        \n",
    "        self.decoder = nn.Sequential(\n",
    "            full_block(z_dim, hid_dim, p_drop),\n",
    "            full_block(hid_dim, x_dim, p_drop),\n",
    "        )\n",
    "      \n",
    "    def forward(self, x):\n",
    "        \n",
    "        encoded = self.encoder(x)\n",
    "        decoded = self.decoder(encoded)\n",
    "        \n",
    "        return encoded, decoded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "id": "coastal-reading",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.nn import functional as F\n",
    "\n",
    "#from model.utils import euclidean_dist\n",
    "\n",
    "def loss_task(encoded, prototypes, target, criterion='dist'):\n",
    "    \"\"\"Calculate loss.\n",
    "    criterion: NNLoss - assign to closest prototype and calculate NNLoss\n",
    "    dist - loss is distance to prototype that example needs to be assigned to\n",
    "                and -distance to prototypes from other class\n",
    "    \"\"\"\n",
    "    \n",
    "    uniq = torch.unique(target, sorted=True)\n",
    "    \n",
    "    ###index of samples for each class of labels\n",
    "    class_idxs = list(map(lambda c: target.eq(c).nonzero(), uniq))\n",
    "    \n",
    "    # prepare targets so they start from 0,1\n",
    "    for idx,v in enumerate(uniq):\n",
    "        target[target==v]=idx\n",
    "    \n",
    "    dists = euclidean_dist(encoded, prototypes)\n",
    "    \n",
    "    if criterion=='NNLoss':\n",
    "       \n",
    "        loss = torch.nn.NLLLoss()\n",
    "        log_p_y = F.log_softmax(-dists, dim=1)\n",
    "        \n",
    "        loss_val = loss(log_p_y, target)\n",
    "        _, y_hat = log_p_y.max(1)\n",
    "        \n",
    "    \n",
    "    elif criterion=='dist':\n",
    "        \n",
    "        loss_val = torch.stack([dists[idx_example, idx_proto].mean(0) for idx_proto,idx_example in enumerate(class_idxs)]).mean()\n",
    "        #loss_val1 = loss_val1/len(embeddings) \n",
    "        y_hat = torch.max(-dists,1)[1]\n",
    "        \n",
    "    acc_val = y_hat.eq(target.squeeze()).float().mean()    \n",
    "        \n",
    "    return loss_val, acc_val\n",
    "\n",
    "def loss_test_nn(encoded, prototypes):\n",
    "    dists = euclidean_dist(encoded, prototypes)\n",
    "    min_dist = torch.min(dists, 1)\n",
    "    \n",
    "    y_hat = min_dist[1]\n",
    "    args_uniq = torch.unique(y_hat, sorted=True)\n",
    "    args_count = torch.stack([(y_hat==x_u).sum() for x_u in args_uniq])\n",
    "    print(args_count)\n",
    "    \n",
    "    loss = torch.nn.NLLLoss()\n",
    "    log_p_y = F.log_softmax(-dists, dim=1)\n",
    "    print(log_p_y.shape)\n",
    "        \n",
    "    loss_val = loss(log_p_y, y_hat)\n",
    "    _, y_hat = log_p_y.max(1)\n",
    "    \n",
    "    return loss_val, args_count\n",
    "\n",
    "\n",
    "def loss_test_basic(encoded, prototypes):\n",
    "    dists = euclidean_dist(encoded, prototypes)\n",
    "    min_dist = torch.min(dists, 1)\n",
    "    \n",
    "    y_hat = min_dist[1]\n",
    "    args_uniq = torch.unique(y_hat, sorted=True)\n",
    "    args_count = torch.stack([(y_hat==x_u).sum() for x_u in args_uniq])\n",
    "    #print(args_count)\n",
    "    \n",
    "    min_dist = min_dist[0] # get_distances\n",
    "    \n",
    "    #thr = torch.stack([torch.sort(min_dist[y_hat==idx_class])[0][int(len(min_dist[y_hat==idx_class])*0.9)] for idx_class in args_uniq])\n",
    "    #loss_val = torch.stack([min_dist[y_hat==idx_class][min_dist[y_hat==idx_class]>=thr[idx_class]].mean(0) for idx_class in args_uniq]).mean()\n",
    "    \n",
    "    loss_val = torch.stack([min_dist[y_hat==idx_class].mean(0) for idx_class in args_uniq]).mean()\n",
    "    \n",
    "    #loss_val,_ = loss_task(encoded, prototypes, y_hat, criterion='dist') # same\n",
    "    \n",
    "    return loss_val, args_count\n",
    "\n",
    "def loss_test(encoded, prototypes, tau):\n",
    "    #prototypes = torch.stack(prototypes).squeeze() \n",
    "    loss_val_test, args_count = loss_test_basic(encoded, prototypes)\n",
    "    \n",
    "    \n",
    "    ###Intracluster distance \n",
    "    if tau>0:\n",
    "        dists = euclidean_dist(prototypes, prototypes)\n",
    "        nproto = prototypes.shape[0]\n",
    "        loss_val2 = - torch.sum(dists)/(nproto*nproto-nproto)\n",
    "        \n",
    "        loss_val_test += tau*loss_val2\n",
    "        \n",
    "    return loss_val_test, args_count\n",
    "\n",
    "def reconstruction_loss(decoded, x):\n",
    "    loss_func = torch.nn.MSELoss()\n",
    "    loss_rcn = loss_func(decoded, x)\n",
    "    #print('Reconstruction {}'.format(loss_rcn))\n",
    "    \n",
    "    return loss_rcn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "id": "honey-terry",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import torch\n",
    "#from sklearn.cluster import k_means_\n",
    "from sklearn.cluster import KMeans\n",
    "\n",
    "#############################################\n",
    "#############################################\n",
    "def compute_landmarks_tr(embeddings, target, prev_landmarks=None, tau=0.2):\n",
    "    \"\"\"Computing landmarks of each class in the labeled meta-dataset. \n",
    "    \n",
    "    Landmark is a closed form solution of \n",
    "    minimizing distance to the mean and maximizing distance to other landmarks. \n",
    "    \n",
    "    If tau=0, landmarks are just mean of data points.\n",
    "    \n",
    "    embeddings: embeddings of the labeled dataset\n",
    "    target: labels in the labeled dataset\n",
    "    prev_landmarks: landmarks from previous iteration\n",
    "    tau: regularizer for inter- and intra-cluster distance\n",
    "    \"\"\"\n",
    "    \n",
    "    uniq = torch.unique(target, sorted=True)\n",
    "    class_idxs = list(map(lambda c: target.eq(c).nonzero(), uniq))\n",
    "    \n",
    "    landmarks_mean = torch.stack([embeddings[idx_class].mean(0) for idx_class in class_idxs]).squeeze()\n",
    "    \n",
    "    if prev_landmarks is None or tau==0:\n",
    "        return landmarks_mean\n",
    "    \n",
    "    suma = prev_landmarks.sum(0)\n",
    "    nlndmk = prev_landmarks.shape[0]\n",
    "    lndmk_dist_part = (tau/(nlndmk-1))*torch.stack([suma-p for p in prev_landmarks])\n",
    "    landmarks = 1/(1-tau)*(landmarks_mean-lndmk_dist_part)\n",
    "    \n",
    "    return landmarks\n",
    "\n",
    "#############################################\n",
    "#############################################\n",
    "\n",
    "\n",
    "def init_landmarks(n_clusters, tr_load, test_load, model, device, mode='kmeans', pretrain=True):\n",
    "    \"\"\"Initialization of landmarks of the labeled and unlabeled meta-dataset.\n",
    "    nclusters: number of expected clusters in the unlabeled meta-dataset\n",
    "    tr_load: data loader for labeled meta-dataset\n",
    "    test_load: data loader for unlabeled meta-dataset\n",
    "    \"\"\"\n",
    "    lndmk_tr = [torch.zeros(size=(len(np.unique(dl.dataset.y)), model.z_dim), \n",
    "                            requires_grad=True, device=device) for dl in tr_load]\n",
    "    \n",
    "    lndmk_test = [torch.zeros(size=(1, model.z_dim), \n",
    "                              requires_grad=True, device=device) \n",
    "                       for _ in range(n_clusters)]\n",
    "    \n",
    "    kmeans_init_tr = [init_step(dl.dataset, model, device, pretrained=pretrain, mode=mode) \n",
    "                      for dl in tr_load]\n",
    "    \n",
    "    kmeans_init_test = init_step(test_load.dataset, model, device, \n",
    "                                 pretrained=pretrain, mode=mode, \n",
    "                                 n_clusters=n_clusters)\n",
    "    \n",
    "    ##No gradient calculation\n",
    "    with torch.no_grad():\n",
    "        [lndmk.copy_(kmeans_init_tr[idx])  for idx,lndmk in enumerate(lndmk_tr)]\n",
    "        [lndmk_test[i].copy_(kmeans_init_test[i,:]) for i in range(kmeans_init_test.shape[0])]\n",
    "        \n",
    "    return lndmk_tr, lndmk_test\n",
    "\n",
    "\n",
    "def init_step(dataset, model, device, pretrained, mode='kmeans',n_clusters=None):\n",
    "    \"\"\"Initialization of landmarks with k-means or k-means++ given dataset.\"\"\"\n",
    "    \n",
    "    if n_clusters==None:\n",
    "        n_clusters = len(np.unique(dataset.y))\n",
    "    nexamples = len(dataset.x)\n",
    "        \n",
    "    X =  torch.stack([dataset.x[i] for i in range(nexamples)])\n",
    "    \n",
    "    if mode=='kmeans++':\n",
    "        if not pretrained: # find centroids in original space\n",
    "            landmarks = k_means_._init_centroids(X.cpu().numpy(), n_clusters, 'k-means++')\n",
    "            landmarks = torch.tensor(landmarks, device=device)\n",
    "            landmarks = landmarks.to(device)\n",
    "            lndmk_encoded,_ = model(landmarks)\n",
    "            \n",
    "        else:\n",
    "            X = X.to(device)\n",
    "            encoded,_ = model(X)\n",
    "            landmarks = k_means_._init_centroids(encoded.data.cpu().numpy(), n_clusters, 'k-means++')\n",
    "            lndmk_encoded = torch.tensor(landmarks, device=device)\n",
    "    \n",
    "    elif mode=='kmeans': # run kmeans clustering\n",
    "        if not pretrained: \n",
    "            kmeans = KMeans(n_clusters, random_state=0).fit(X.cpu().numpy())\n",
    "            landmarks = torch.tensor(kmeans.cluster_centers_, device=device)\n",
    "            landmarks = landmarks.to(device)\n",
    "            ##Feed forward net on landmarks  (k means cluster)\n",
    "            ##landmarks are k means cluster centers = coordinates of cluster center\n",
    "            lndmk_encoded,_ = model(landmarks)\n",
    "        \n",
    "        ##already pretrained; return coordinates of centers \n",
    "        else:\n",
    "            X = X.to(device)\n",
    "            encoded,_ = model(X)\n",
    "            kmeans = KMeans(n_clusters, random_state=0).fit(encoded.data.cpu().numpy())\n",
    "            lndmk_encoded = torch.tensor(kmeans.cluster_centers_, device=device)\n",
    "    \n",
    "    return lndmk_encoded"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "id": "loved-laugh",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import sklearn.metrics as metrics\n",
    "from scipy.optimize import linear_sum_assignment \n",
    "\n",
    "def compute_scores(y_true, y_pred, scoring={'accuracy','precision','recall','nmi',\n",
    "                                                'adj_rand','f1_score','adj_mi'}):\n",
    "    y_true = y_true.cpu().numpy()\n",
    "    y_pred = y_pred.cpu().numpy()\n",
    "    \n",
    "    scores = {}\n",
    "    y_true, y_pred = hungarian_match(y_true, y_pred)\n",
    "    set_scores(scores, y_true, y_pred, scoring)\n",
    "        \n",
    "    return scores\n",
    "\n",
    "\n",
    "def set_scores(scores, y_true, y_pred, scoring):\n",
    "    labels=list(set(y_true))\n",
    "    \n",
    "    for metric in scoring:\n",
    "        if metric=='accuracy':\n",
    "            scores[metric] = metrics.accuracy_score(y_true, y_pred)\n",
    "        elif metric=='precision':\n",
    "            scores[metric] = metrics.precision_score(y_true, y_pred, labels, average='macro')\n",
    "        elif metric=='recall':\n",
    "            scores[metric] = metrics.recall_score(y_true, y_pred, labels, average='macro')\n",
    "        elif metric=='f1_score':\n",
    "            scores[metric] = metrics.f1_score(y_true, y_pred, labels, average='macro')\n",
    "        elif metric=='nmi':\n",
    "            scores[metric] = metrics.normalized_mutual_info_score(y_true, y_pred)\n",
    "        elif metric=='adj_mi':\n",
    "            scores[metric] = metrics.adjusted_mutual_info_score(y_true, y_pred)\n",
    "        elif metric=='adj_rand':\n",
    "            scores[metric] = metrics.adjusted_rand_score(y_true, y_pred)\n",
    "                \n",
    "                \n",
    "def hungarian_match(y_true, y_pred):\n",
    "    \"\"\"Matches predicted labels to original using hungarian algorithm.\"\"\"\n",
    "    \n",
    "    y_true = adjust_range(y_true)\n",
    "    y_pred = adjust_range(y_pred)\n",
    "    \n",
    "    D = max(y_pred.max(), y_true.max()) + 1\n",
    "    w = np.zeros((D, D), dtype=np.int64)\n",
    "    # Confusion matrix.\n",
    "    for i in range(y_pred.size):\n",
    "        w[y_pred[i], y_true[i]] += 1\n",
    "    ind = linear_sum_assignment(-w)\n",
    "    ind = np.asarray(ind)\n",
    "    ind = np.transpose(ind)\n",
    "    d = {i:j for i, j in ind}\n",
    "    y_pred = np.array([d[v] for v in y_pred])\n",
    "    \n",
    "    return y_true, y_pred\n",
    "\n",
    "\n",
    "def adjust_range(y):\n",
    "    \"\"\"Assures that the range of indices if from 0 to n-1.\"\"\"\n",
    "    y = np.array(y, dtype=np.int64)\n",
    "    val_set = set(y)\n",
    "    mapping = {val:i for  i,val in enumerate(val_set)}\n",
    "    y = np.array([mapping[val] for val in y], dtype=np.int64)\n",
    "    return y\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "id": "imperial-permission",
   "metadata": {},
   "outputs": [],
   "source": [
    "class MARS:\n",
    "    def __init__(self, n_clusters, params, \n",
    "                 labeled_data, unlabeled_data, \n",
    "                 pretrain_data=None, \n",
    "                 val_split=1.0, hid_dim_1=1000, hid_dim_2=100, p_drop=0.0, tau=0.2):\n",
    "        \"\"\"Initialization of MARS.\n",
    "        n_clusters: number of clusters in the unlabeled meta-dataset\n",
    "        params: parameters of the MARS model\n",
    "        labeled_data: list of labeled datasets. Each dataset needs to be instance of CellDataset.\n",
    "        unlabeled_data: unlabeled dataset. Instance of CellDataset.\n",
    "        pretrain_data: dataset for pretraining MARS. Instance of CellDataset. If not specified, unlabeled_data\n",
    "                        will be used.\n",
    "        val_split: percentage of data to use for train/val split (default: 1, meaning no validation set)\n",
    "        hid_dim_1: dimension in the first layer of the network (default: 1000)\n",
    "        hid_dim_2: dimension in the second layer of the network (default: 100)\n",
    "        p_drop: dropout probability (default: 0)\n",
    "        tau: regularizer for inter-cluster distance\n",
    "        \"\"\"\n",
    "        train_load, test_load, pretrain_load, val_load = init_data_loaders(labeled_data, unlabeled_data, \n",
    "                                                                           pretrain_data, params.pretrain_batch, \n",
    "                                                                           val_split)\n",
    "        self.train_loader = train_load\n",
    "        self.test_loader = test_load\n",
    "        self.pretrain_loader = pretrain_load\n",
    "        self.val_loader = val_load\n",
    "        \n",
    "        ##data file type (string name)\n",
    "        self.labeled_metadata = [data.metadata for data in labeled_data]\n",
    "        self.unlabeled_metadata = unlabeled_data.metadata\n",
    "        \n",
    "        self.genes = unlabeled_data.yIDs\n",
    "        \n",
    "        ##number of genes \n",
    "        x_dim = self.test_loader.dataset.get_dim()\n",
    "        \n",
    "        ##Feed forward neural net\n",
    "        self.init_model(x_dim, hid_dim_1, hid_dim_2, p_drop, params.device)\n",
    "        \n",
    "        self.n_clusters = n_clusters\n",
    "        \n",
    "        self.device = params.device\n",
    "        self.epochs = params.epochs\n",
    "        self.epochs_pretrain = params.epochs_pretrain\n",
    "        self.pretrain_flag = params.pretrain\n",
    "        self.model_file = params.model_file\n",
    "        self.lr = params.learning_rate\n",
    "        self.lr_gamma = params.lr_scheduler_gamma\n",
    "        self.step_size = params.lr_scheduler_step\n",
    "        \n",
    "        self.tau = tau\n",
    "        \n",
    "    ###################################################################\n",
    "    ###################################################################    \n",
    "    ###### With the fine tuned hyper parameter     \n",
    "    ###### Change the implementation of AE to VAE     \n",
    "    def init_model(self, x_dim, hid_dim, z_dim, p_drop, device):\n",
    "        \"\"\"\n",
    "        Initialize the model.\n",
    "        \"\"\"\n",
    "        self.model = FullNet(x_dim, hid_dim, z_dim, p_drop).to(device)\n",
    "    ###################################################################\n",
    "    ###################################################################\n",
    "    \n",
    "    def init_optim(self, param1, param2, learning_rate):\n",
    "        \"\"\"Initializing optimizers.\"\"\"\n",
    "        \n",
    "        optim = torch.optim.Adam(params=param1, lr=learning_rate)\n",
    "        optim_landmk_test = torch.optim.Adam(params=param2, lr=learning_rate)\n",
    "        \n",
    "        return optim, optim_landmk_test\n",
    "    \n",
    "    ###################################################################\n",
    "    ###################################################################\n",
    "    ########Will need to alter this part for VAE (KL + reconstruction loss + regularized)\n",
    "    def pretrain(self, optim):\n",
    "        \"\"\"\n",
    "        Pretraining model with autoencoder.\n",
    "        optim: optimizer\n",
    "        \"\"\"\n",
    "        print('Pretraining..')\n",
    "        \n",
    "        for _ in range(self.epochs_pretrain):\n",
    "            for _, batch in enumerate(self.pretrain_loader):\n",
    "                x,_,_ = batch\n",
    "                x = x.to(self.device)\n",
    "                _, decoded = self.model(x)\n",
    "                loss = reconstruction_loss(decoded, x) \n",
    "                optim.zero_grad()              \n",
    "                loss.backward()                    \n",
    "                optim.step() \n",
    "    ###################################################################\n",
    "    ###################################################################\n",
    "    \n",
    "    \n",
    "    def train(self, evaluation_mode=True, save_all_embeddings=True):\n",
    "        \"\"\"Train model.\n",
    "        evaluation_mode: if True, validates model on the unlabeled dataset. \n",
    "        In the evaluation mode, ground truth labels of the unlabeled dataset must be \n",
    "        provided to validate model\n",
    "        \n",
    "        save_all_embeddings: if True, MARS embeddings for annotated and unannotated \n",
    "        experiments will be saved in an anndata object,\n",
    "        otherwise only unnanotated will be saved. \n",
    "        If naming is called after, all embeddings need to be saved\n",
    "        \n",
    "        return: adata: anndata object containing labeled and unlabeled meta-dataset \n",
    "        with MARS embeddings and estimated labels on the unlabeled dataset\n",
    "                landmk_all: landmarks of the labeled and unlabeled meta-dataset in the \n",
    "                order given for training. Landmarks on the unlabeled\n",
    "                            dataset are provided last\n",
    "                metrics: clustering metrics if evaluation_mode is True\n",
    "                \n",
    "        \"\"\"\n",
    "        tr_iter = [iter(dl) for dl in self.train_loader]\n",
    "        \n",
    "        if self.val_loader is not None:\n",
    "            val_iter = [iter(dl) for dl in self.val_loader]\n",
    "        \n",
    "        ####Pre train step \n",
    "        optim_pretrain = torch.optim.Adam(params=list(self.model.parameters()), lr=self.lr)\n",
    "        if self.pretrain_flag:\n",
    "            self.pretrain(optim_pretrain)\n",
    "        else:\n",
    "            self.model.load_state_dict(torch.load(self.MODEL_FILE))    \n",
    "        ####\n",
    "        \n",
    "        test_iter = iter(self.test_loader)\n",
    "        \n",
    "        landmk_tr, landmk_test = init_landmarks(self.n_clusters, \n",
    "                                                self.train_loader, \n",
    "                                                self.test_loader, \n",
    "                                                self.model, self.device)\n",
    "        \n",
    "        optim, optim_landmk_test = self.init_optim(list(self.model.encoder.parameters()), \n",
    "                                                   landmk_test, self.lr)\n",
    "        \n",
    "        lr_scheduler = torch.optim.lr_scheduler.StepLR(optimizer=optim,\n",
    "                                                       gamma=self.lr_gamma,\n",
    "                                                       step_size=self.step_size)\n",
    "        \n",
    "        best_acc = 0\n",
    "        for epoch in range(1, self.epochs+1):\n",
    "            \n",
    "            ##Set model for training\n",
    "            self.model.train()\n",
    "            \n",
    "            ##This is equivalent to train step \n",
    "            loss_tr, acc_tr, landmk_tr, landmk_test = self.do_epoch(tr_iter, \n",
    "                                                                    test_iter,\n",
    "                                                                    optim, \n",
    "                                                                    optim_landmk_test,\n",
    "                                                                    landmk_tr, \n",
    "                                                                    landmk_test)\n",
    "            if epoch==self.epochs: \n",
    "                print('\\n=== Epoch: {} ==='.format(epoch))\n",
    "                print('Train acc: {}'.format(acc_tr))\n",
    "            if self.val_loader is None:\n",
    "                continue\n",
    "            self.model.eval()\n",
    "            ##Stop training \n",
    "            \n",
    "            with torch.no_grad():\n",
    "                loss_val,acc_val = self.do_val_epoch(val_iter, landmk_tr)\n",
    "                if acc_val > best_acc:\n",
    "                    print('Saving model...')\n",
    "                    best_acc = acc_val\n",
    "                    best_state = self.model.state_dict()\n",
    "                    #torch.save(model.state_dict(), self.model_file)\n",
    "                postfix = ' (Best)' if acc_val >= best_acc else ' (Best: {})'.format(best_acc)\n",
    "                print('Val loss: {}, acc: {}{}'.format(loss_val, acc_val, postfix))\n",
    "            lr_scheduler.step()\n",
    "            \n",
    "        if self.val_loader is None:\n",
    "            best_state = self.model.state_dict() # best is last\n",
    "        \n",
    "        landmk_all = landmk_tr+[torch.stack(landmk_test).squeeze()]\n",
    "        \n",
    "        ##Test time (assign labels to unlabaled data)\n",
    "        adata_test, eval_results = self.assign_labels(landmk_all[-1], evaluation_mode)\n",
    "        \n",
    "        adata = self.save_result(tr_iter, adata_test, save_all_embeddings)\n",
    "        \n",
    "        if evaluation_mode:\n",
    "            return adata, landmk_all, eval_results\n",
    "        \n",
    "        return adata, landmk_all\n",
    "    \n",
    "    def save_result(self, tr_iter, adata_test, save_all_embeddings):\n",
    "        \"\"\"Saving embeddings from labeled and unlabeled dataset, ground truth labels and \n",
    "        predictions to joint anndata object.\"\"\"\n",
    "        adata_all = []\n",
    "\n",
    "        if save_all_embeddings:\n",
    "            for task in range(len(tr_iter)): # saving embeddings from labeled dataset\n",
    "                task = int(task)\n",
    "                x, y, cells = next(tr_iter[task])\n",
    "                x, y = x.to(self.device), y.to(self.device)\n",
    "                encoded,_ = self.model(x)\n",
    "                adata_all.append(self.pack_anndata(x, cells, encoded, gtruth=y))\n",
    "            \n",
    "        adata_all.append(adata_test)    \n",
    "        \n",
    "        if save_all_embeddings:\n",
    "            adata = adata_all[0].concatenate(adata_all[1:], \n",
    "                                             batch_key='experiment',\n",
    "                                             batch_categories=self.labeled_metadata+[self.unlabeled_metadata])\n",
    "        else:\n",
    "            adata = adata_all[0]\n",
    "\n",
    "            \n",
    "        adata.obsm['MARS_embedding'] = np.concatenate([a.uns['MARS_embedding'] for a in adata_all])\n",
    "        #adata.write('result_adata.h5ad')\n",
    "        \n",
    "        return adata\n",
    "    \n",
    "    def assign_labels(self, landmk_test, evaluation_mode):\n",
    "        \"\"\"Assigning cluster labels to the unlabeled meta-dataset.\n",
    "        test_iter: iterator over unlabeled dataset\n",
    "        landmk_test: landmarks in the unlabeled dataset\n",
    "        evaluation mode: computes clustering metrics if True\n",
    "        \"\"\"\n",
    "        #test_iter = iter(self.test_loader)\n",
    "            \n",
    "        torch.no_grad()\n",
    "        self.model.eval() # eval mode\n",
    "        \n",
    "        test_iter = iter(self.test_loader)\n",
    "        \n",
    "        x_test, y_true, cells = next(test_iter) # cells are needed because dataset is in random order\n",
    "        x_test = x_test.to(self.device)\n",
    "        \n",
    "        encoded_test,_ = self.model(x_test)\n",
    "        \n",
    "        ###Embedding space eucledian distance \n",
    "        dists = euclidean_dist(encoded_test, landmk_test)\n",
    "        \n",
    "        ###Prediction based on the minimal distance to learned landmark\n",
    "        y_pred = torch.min(dists, 1)[1]\n",
    "        \n",
    "        adata = self.pack_anndata(x_test, cells, encoded_test, y_true, y_pred)\n",
    "        \n",
    "        eval_results = None\n",
    "        if evaluation_mode:\n",
    "            eval_results = compute_scores(y_true, y_pred)\n",
    "            \n",
    "        return adata, eval_results\n",
    "    \n",
    "    \n",
    "    def pack_anndata(self, x_input, cells, embedding, gtruth=[], estimated=[]):\n",
    "        \"\"\"Pack results in anndata object.\n",
    "        x_input: gene expressions in the input space\n",
    "        cells: cell identifiers\n",
    "        embedding: resulting embedding of x_test using MARS\n",
    "        landmk: MARS estimated landmarks\n",
    "        gtruth: ground truth labels if available (default: empty list)\n",
    "        estimated: MARS estimated clusters if available (default: empty list)\n",
    "        \"\"\"\n",
    "        adata = anndata.AnnData(x_input.data.cpu().numpy())\n",
    "        adata.obs_names = cells\n",
    "        adata.var_names = self.genes\n",
    "        if len(estimated)!=0:\n",
    "            adata.obs['MARS_labels'] = pd.Categorical(values=estimated.cpu().numpy())\n",
    "        if len(gtruth)!=0:\n",
    "            adata.obs['truth_labels'] = pd.Categorical(values=gtruth.cpu().numpy())\n",
    "        adata.uns['MARS_embedding'] = embedding.data.cpu().numpy()\n",
    "        \n",
    "        return adata\n",
    "    \n",
    "    \n",
    "    def do_epoch(self, tr_iter, test_iter, optim, optim_landmk_test, landmk_tr, landmk_test):\n",
    "        \"\"\"\n",
    "        One training epoch.\n",
    "        tr_iter: iterator over labeled meta-data\n",
    "        test_iter: iterator over unlabeled meta-data\n",
    "        \n",
    "        optim: optimizer for embedding\n",
    "        optim_landmk_test: optimizer for test landmarks\n",
    "        \n",
    "        landmk_tr: landmarks of labeled meta-data from previous epoch\n",
    "        landmk_test: landmarks of unlabeled meta-data from previous epoch\n",
    "        \"\"\"\n",
    "        self.set_requires_grad(False)\n",
    "        \n",
    "        for landmk in landmk_test:\n",
    "            landmk.requires_grad=False\n",
    "        \n",
    "        optim_landmk_test.zero_grad()\n",
    "        \n",
    "        # update centroids    \n",
    "        task_idx = torch.randperm(len(tr_iter)) ##shuffle per epoch\n",
    "        for task in task_idx:\n",
    "            \n",
    "            task = int(task)\n",
    "            x, y, _ = next(tr_iter[task])\n",
    "            x, y = x.to(self.device), y.to(self.device)\n",
    "            encoded,_ = self.model(x)\n",
    "            ##Compute how good the landmarks are to true labels\n",
    "            curr_landmk_tr = compute_landmarks_tr(encoded, y, landmk_tr[task], tau=self.tau)\n",
    "            landmk_tr[task] = curr_landmk_tr.data # save landmarks\n",
    "            \n",
    "        for landmk in landmk_test:\n",
    "            landmk.requires_grad=True\n",
    "            \n",
    "        x,y_test,_ = next(test_iter)\n",
    "        x = x.to(self.device)\n",
    "        encoded,_ = self.model(x)\n",
    "        loss, args_count = loss_test(encoded, \n",
    "                                     torch.stack(landmk_test).squeeze(), \n",
    "                                     self.tau)\n",
    "        loss.backward()\n",
    "        optim_landmk_test.step()\n",
    "                \n",
    "        # update embedding\n",
    "        self.set_requires_grad(True)\n",
    "        for landmk in landmk_test:\n",
    "            landmk.requires_grad=False\n",
    "            \n",
    "        optim.zero_grad()\n",
    "        total_accuracy = 0\n",
    "        total_loss = 0\n",
    "        ntasks = 0\n",
    "        mean_accuracy = 0\n",
    "        \n",
    "        task_idx = torch.randperm(len(tr_iter))\n",
    "        for task in task_idx:\n",
    "            task = int(task)\n",
    "            x, y, _ = next(tr_iter[task])\n",
    "            x, y = x.to(self.device), y.to(self.device)\n",
    "            encoded,_ = self.model(x)\n",
    "            ###Eucledian distance between embedding and landmark\n",
    "            loss, acc = loss_task(encoded, landmk_tr[task], y, criterion='dist')\n",
    "            total_loss += loss\n",
    "            total_accuracy += acc.item()\n",
    "            ntasks += 1\n",
    "        \n",
    "        if ntasks>0:\n",
    "            mean_accuracy = total_accuracy / ntasks\n",
    "        \n",
    "        # test part\n",
    "        x,y,_ = next(test_iter)\n",
    "        x = x.to(self.device)\n",
    "        encoded,_ = self.model(x)\n",
    "        loss,_ = loss_test(encoded, torch.stack(landmk_test).squeeze(), self.tau)\n",
    "        \n",
    "        total_loss += loss\n",
    "        ntasks += 1\n",
    "    \n",
    "        mean_loss = total_loss / ntasks\n",
    "        \n",
    "        mean_loss.backward()\n",
    "        optim.step()\n",
    "        \n",
    "        return mean_loss, mean_accuracy, landmk_tr, landmk_test\n",
    "    \n",
    "    def do_val_epoch(self, val_iter, prev_landmk):\n",
    "        \"\"\"One epoch of validation.\n",
    "        val_iter: iterator over validation set\n",
    "        prev_landmk: landmarks from previous epoch\n",
    "        \"\"\"\n",
    "        ntasks = len(val_iter)\n",
    "        task_idx = torch.randperm(ntasks)\n",
    "        \n",
    "        total_loss = 0\n",
    "        total_accuracy = 0\n",
    "        \n",
    "        for task in task_idx:\n",
    "            x, y, _ = next(val_iter[task])\n",
    "            x, y = x.to(self.device), y.to(self.device)\n",
    "            encoded = self.model(x)\n",
    "            loss, acc = loss_task(encoded, prev_landmk[task], y, criterion='dist')\n",
    "            total_loss += loss\n",
    "            total_accuracy += acc.item()\n",
    "        mean_accuracy = total_accuracy / ntasks\n",
    "        mean_loss = total_loss / ntasks\n",
    "        \n",
    "        return mean_loss, mean_accuracy\n",
    "    \n",
    "    \n",
    "    def set_requires_grad(self, requires_grad):\n",
    "        for param in self.model.parameters():\n",
    "            param.requires_grad = requires_grad\n",
    "    \n",
    "    def name_cell_types(self, adata, landmk_all, cell_name_mappings, \n",
    "                        top_match=5, umap_reduce_dim=True, ndim=10):\n",
    "        \"\"\"For each test cluster, estimate sigma and mean. \n",
    "        Fit Gaussian distribution with that mean and sigma\n",
    "        and calculate the probability of each of the train landmarks \n",
    "        to be the neighbor to the mean data point.\n",
    "        Normalization is performed with regards to all other landmarks in train.\"\"\"\n",
    "        \n",
    "        experiments = list(OrderedDict.fromkeys(list(adata.obs['experiment'])))\n",
    "        \n",
    "        encoded_tr = []\n",
    "        landmk_tr = []\n",
    "        landmk_tr_labels = []\n",
    "        for idx, exp in enumerate(experiments[:-1]):\n",
    "            tiss = adata[adata.obs['experiment'] == exp,:]\n",
    "            \n",
    "            if exp==self.unlabeled_metadata: \n",
    "                raise ValueError(\"Error: Unlabeled dataset needs to be last one in the input anndata object.\")\n",
    "                \n",
    "            encoded_tr.append(tiss.obsm['MARS_embedding'])\n",
    "            landmk_tr.append(landmk_all[idx])\n",
    "            landmk_tr_labels.append(np.unique(tiss.obs['truth_labels']))\n",
    "            \n",
    "        tiss = adata[adata.obs['experiment'] == self.unlabeled_metadata,:]\n",
    "        ypred_test = tiss.obs['MARS_labels']\n",
    "        uniq_ytest = np.unique(ypred_test)\n",
    "        encoded_test = tiss.obsm['MARS_embedding']\n",
    "        \n",
    "        landmk_tr_labels = np.concatenate(landmk_tr_labels)\n",
    "        encoded_tr = np.concatenate(encoded_tr)\n",
    "        landmk_tr = np.concatenate([p.cpu() for p in landmk_tr])\n",
    "        if  umap_reduce_dim:\n",
    "            encoded_extend = np.concatenate((encoded_tr, encoded_test, landmk_tr))\n",
    "            adata = anndata.AnnData(encoded_extend)\n",
    "            sc.pp.neighbors(adata, n_neighbors=15, use_rep='X')\n",
    "            sc.tl.umap(adata, n_components=ndim)\n",
    "            encoded_extend = adata.obsm['X_umap']\n",
    "            n1 = len(encoded_tr)\n",
    "            n2 = n1 + len(encoded_test)\n",
    "            encoded_tr = encoded_extend[:n1,:]\n",
    "            encoded_test = encoded_extend[n1:n2,:]\n",
    "            landmk_tr = encoded_extend[n2:,:]\n",
    "        \n",
    "        interp_names = defaultdict(list)\n",
    "        for ytest in uniq_ytest:\n",
    "            print('\\nCluster label: {}'.format(str(ytest)))\n",
    "            idx = np.where(ypred_test==ytest)\n",
    "            subset_encoded = encoded_test[idx[0],:]\n",
    "            mean = np.expand_dims(np.mean(subset_encoded, axis=0),0)\n",
    "            \n",
    "            sigma  = self.estimate_sigma(subset_encoded)\n",
    "            \n",
    "            prob = np.exp(-np.power(distance.cdist(mean, landmk_tr, metric='euclidean'),2)/(2*sigma*sigma))\n",
    "            prob = np.squeeze(prob, 0)\n",
    "            normalizat = np.sum(prob)\n",
    "            if normalizat==0:\n",
    "                print('Unassigned')\n",
    "                interp_names[ytest].append(\"unassigned\")\n",
    "                continue\n",
    "            \n",
    "            prob = np.divide(prob, normalizat)\n",
    "            \n",
    "            uniq_tr = np.unique(landmk_tr_labels)\n",
    "            prob_unique = []\n",
    "            for cell_type in uniq_tr: # sum probabilities of same landmarks\n",
    "                prob_unique.append(np.sum(prob[np.where(landmk_tr_labels==cell_type)]))\n",
    "            \n",
    "            sorted = np.argsort(prob_unique, axis=0)\n",
    "            best = uniq_tr[sorted[-top_match:]]\n",
    "            sortedv = np.sort(prob_unique, axis=0)\n",
    "            sortedv = sortedv[-top_match:]\n",
    "            for idx, b in enumerate(best):\n",
    "                interp_names[ytest].append((cell_name_mappings[b], sortedv[idx]))\n",
    "                print('{}: {}'.format(cell_name_mappings[b], sortedv[idx]))\n",
    "                \n",
    "        return interp_names\n",
    "    \n",
    "    \n",
    "    def estimate_sigma(self, dataset):\n",
    "        nex = dataset.shape[0]\n",
    "        dst = []\n",
    "        for i in range(nex):\n",
    "            for j in range(i+1, nex):\n",
    "                dst.append(distance.euclidean(dataset[i,:],dataset[j,:]))\n",
    "        return np.std(dst)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "critical-scotland",
   "metadata": {},
   "outputs": [],
   "source": [
    "val_split=0.8\n",
    "train_load, test_load, pretrain_load, val_load = init_data_loaders([annotated], \n",
    "                                                                   unannotated, \n",
    "                                                                   pretrain_data, \n",
    "                                                                   params.pretrain_batch, \n",
    "                                                                   val_split)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "id": "former-carter",
   "metadata": {},
   "outputs": [],
   "source": [
    "mars = MARS(n_clusters, params, \n",
    "            [annotated], unannotated, \n",
    "            pretrain_data, hid_dim_1=1000, hid_dim_2=100)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "id": "quiet-independence",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pretraining..\n",
      "\n",
      "=== Epoch: 30 ===\n",
      "Train acc: 0.9823333621025085\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/Users/yaoestelle/opt/anaconda3/envs/cs109b/lib/python3.8/site-packages/sklearn/utils/validation.py:70: FutureWarning: Pass labels=[0, 1, 2, 3, 4, 5] as keyword args. From version 1.0 (renaming of 0.25) passing these as positional arguments will result in an error\n",
      "  warnings.warn(f\"Pass {args_msg} as keyword args. From version \"\n",
      "/Users/yaoestelle/opt/anaconda3/envs/cs109b/lib/python3.8/site-packages/sklearn/utils/validation.py:70: FutureWarning: Pass labels=[0, 1, 2, 3, 4, 5] as keyword args. From version 1.0 (renaming of 0.25) passing these as positional arguments will result in an error\n",
      "  warnings.warn(f\"Pass {args_msg} as keyword args. From version \"\n",
      "/Users/yaoestelle/opt/anaconda3/envs/cs109b/lib/python3.8/site-packages/sklearn/utils/validation.py:70: FutureWarning: Pass labels=[0, 1, 2, 3, 4, 5] as keyword args. From version 1.0 (renaming of 0.25) passing these as positional arguments will result in an error\n",
      "  warnings.warn(f\"Pass {args_msg} as keyword args. From version \"\n"
     ]
    }
   ],
   "source": [
    "adata, landmarks, scores = mars.train(evaluation_mode=True, \n",
    "                                      save_all_embeddings=False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "id": "unusual-coalition",
   "metadata": {},
   "outputs": [],
   "source": [
    "from anndata import AnnData"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "id": "favorite-colors",
   "metadata": {},
   "outputs": [],
   "source": [
    "adata_mars = AnnData(adata.obsm['MARS_embedding'])\n",
    "adata_mars.obs['MARS_labels'] = pd.Categorical(adata.obs['MARS_labels'])\n",
    "adata_mars.obs['ground_truth'] = pd.Categorical(adata.obs['truth_labels'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "id": "senior-concord",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 989.28x288 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sc.pp.neighbors(adata_mars, n_neighbors=30, use_rep='X')\n",
    "sc.tl.umap(adata_mars)\n",
    "sc.pl.umap(adata_mars, color=['ground_truth','MARS_labels'],size=50)"
   ]
  }
 ],
 "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.8.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}