examples/notebooks/Cell-Type-Annotation.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "yXsc6JTIw0HX"
   },
   "source": [
    "# Cell type annotation prediction\n",
    "\n",
    "Run this notebook on google colab to use a free GPU!\n",
    "\n",
    "[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/helicalAI/helical/blob/main/examples/notebooks/Cell-Type-Annotation.ipynb)\n",
    "\n",
    "In this notebook, an [scGPT](https://www.nature.com/articles/s41592-024-02201-0) model is used to predict a cell type annotation with a given gene expression profile.\n",
    "\n",
    "This follows the tutorial from scGPT [here](https://github.com/bowang-lab/scGPT/blob/main/tutorials/Tutorial_Annotation.ipynb), but instead of fine-tuning the entire model, a smaller neural network is trained, using the embeddings of the gene expressions as inputs, to make a prediction.\n",
    "\n",
    "The same approach is made with the [Geneformer](https://www.nature.com/articles/s41586-023-06139-9.epdf?sharing_token=u_5LUGVkd3A8zR-f73lU59RgN0jAjWel9jnR3ZoTv0N2UB4yyXENUK50s6uqjXH69sDxh4Z3J4plYCKlVME-W2WSuRiS96vx6t5ex2-krVDS46JkoVvAvJyWtYXIyj74pDWn_DutZq1oAlDaxfvBpUfSKDdBPJ8SKlTId8uT47M%3D) model and the results are compared against each other.\n",
    "\n",
    "This approach greatly reduces time and complexity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "VVhpT3bSxAML",
    "outputId": "49cc4e8e-7599-4320-c9db-d7a35eba6f1f"
   },
   "outputs": [],
   "source": [
    "# !pip install helical"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "# !pip install datasets --upgrade"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "aDf6LsRIZ80C",
    "outputId": "b7ef3182-a30f-4946-a2d5-72b6c9082b87"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:datasets:PyTorch version 2.3.0 available.\n",
      "INFO:datasets:Polars version 0.20.31 available.\n",
      "INFO:datasets:JAX version 0.4.31 available.\n"
     ]
    }
   ],
   "source": [
    "from sklearn.metrics import accuracy_score, precision_score, f1_score, recall_score\n",
    "from sklearn.preprocessing import LabelEncoder\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from sklearn.model_selection import train_test_split\n",
    "import anndata as ad\n",
    "import torch\n",
    "from torch.utils.data import DataLoader, TensorDataset\n",
    "from torch import nn\n",
    "from scipy.sparse import lil_matrix\n",
    "import torch.optim as optim\n",
    "from helical.models.scgpt import scGPT, scGPTConfig\n",
    "from helical.models.geneformer import Geneformer, GeneformerConfig\n",
    "from copy import deepcopy   \n",
    "from torch.nn.functional import one_hot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We load the our dataset from the EMBL [website](https://www.ebi.ac.uk/biostudies/arrayexpress/studies/E-MTAB-11673). To download the dataset, we are leveraging Huggingface's optimized library!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Generating train split: 100%|██████████| 25344/25344 [00:14<00:00, 1693.62 examples/s]\n",
      "Generating test split: 100%|██████████| 6336/6336 [00:02<00:00, 2115.23 examples/s]\n"
     ]
    }
   ],
   "source": [
    "from datasets import load_dataset\n",
    "ds = load_dataset(\"helical-ai/yolksac_human\",trust_remote_code=True, split=\"train[:65%]\",download_mode=\"reuse_cache_if_exists\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "TpvpV2yZpZBO",
    "outputId": "0caaa74e-f0ff-4122-bd27-32af6d85d155"
   },
   "outputs": [],
   "source": [
    "observation_columns = [obs for obs in list(ds.features.keys()) if not obs == 'raw_counts']\n",
    "obs_data = pd.DataFrame(ds.select_columns(observation_columns).data.to_pandas(),columns=observation_columns)\n",
    "lil = lil_matrix((len(ds),ds[0]['size']))\n",
    "lil.data = np.array(ds['raw_counts'],dtype=\"object\")\n",
    "lil.rows = np.array(ds['rows'],dtype=\"object\")\n",
    "adata = ad.AnnData(lil.tocsr(),obs=obs_data)\n",
    "adata.var_names = ds.features['raw_counts'].id.split(\",\")\n",
    "adata.var['gene_name'] = adata.var_names.str.upper()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XME3WOUl-BSf"
   },
   "source": [
    "Let's familiarise ourselves with the data!\n",
    "\n",
    "We are interested in the names of the cells we want to predict. They are saved in `adata.obs[\"LVL1\"]`.\n",
    "\n",
    "Additionally, we need to know how many distinct cell types/classes we have."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "id": "sjo5qHPFw0HY"
   },
   "outputs": [],
   "source": [
    "# get labels: the celltype\n",
    "num_types = adata.obs[\"LVL1\"].unique().shape[0]\n",
    "id2type = dict(enumerate(adata.obs[\"LVL1\"].astype(\"category\").cat.categories))\n",
    "\n",
    "celltypes_labels = np.array(adata.obs[\"LVL1\"].tolist())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "VzPLNqRr-BSg"
   },
   "source": [
    "This is all summarized in this dictionary:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "_j-x6weFm6UO",
    "outputId": "5d0c52f1-553e-460f-def7-7cf372b9bc89"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{0: 'ERYTHROID',\n",
       " 1: 'LYMPHOID',\n",
       " 2: 'MK',\n",
       " 3: 'MYELOID',\n",
       " 4: 'PROGENITOR',\n",
       " 5: 'STROMA'}"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id2type"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "HayHZKTC-BSi"
   },
   "source": [
    "Use the Helical package to get the embeddings of the gene expression profile.\n",
    "\n",
    "The only thing we need to specify is the column containing the names of the genes. (`gene_name` in this case)\n",
    "\n",
    "The resulting embeddings are the input features `x` for our smaller NN model."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "_cXrEgxHC-Wi"
   },
   "source": [
    "# scGPT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "t0hNoTJdw0Ha",
    "outputId": "26c17bfa-13de-4ccb-beb4-a725a40dd97f"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:helical.utils.downloader:File: '/home/benoit/.cache/helical/models/scgpt/scGPT_CP/vocab.json' exists already. File is not overwritten and nothing is downloaded.\n",
      "INFO:helical.utils.downloader:File saved to: '/home/benoit/.cache/helical/models/scgpt/scGPT_CP/vocab.json'\n",
      "INFO:helical.utils.downloader:File: '/home/benoit/.cache/helical/models/scgpt/scGPT_CP/best_model.pt' exists already. File is not overwritten and nothing is downloaded.\n",
      "INFO:helical.utils.downloader:File saved to: '/home/benoit/.cache/helical/models/scgpt/scGPT_CP/best_model.pt'\n",
      "INFO:helical.models.scgpt.model:Model finished initializing.\n",
      "INFO:helical.models.scgpt.model:Filtering out 11163 genes to a total of 26155 genes with an id in the scGPT vocabulary.\n",
      "INFO:helical.models.scgpt.model:Inference started:\n",
      "Embedding cells: 100%|██████████| 330/330 [00:33<00:00,  9.84it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(16474, 512)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "\n",
    "scgpt_config = scGPTConfig(batch_size=50, device=device)\n",
    "scgpt = scGPT(configurer = scgpt_config)\n",
    "data = scgpt.process_data(adata, gene_names = \"gene_name\")\n",
    "x_scgpt = scgpt.get_embeddings(data)\n",
    "x_scgpt.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "YxtVwacW-BSj"
   },
   "source": [
    "With the input features, we also need the corresponding labels `y`.\n",
    "\n",
    "They correspond to the cell type labels.\n",
    "\n",
    "As we have a categorical prediction, we transform the cell type labels to integer labels to work with CrossEntropyLoss later."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "zHMZ7VX8m6UQ",
    "outputId": "d40c15bd-4ea5-4821-def3-7f253a3af469"
   },
   "outputs": [],
   "source": [
    "y = celltypes_labels\n",
    "num_classes = num_types\n",
    "\n",
    "encoder = LabelEncoder()\n",
    "y_encoded = encoder.fit_transform(y)\n",
    "y_encoded = one_hot(torch.tensor(y_encoded),num_classes).float()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "wQpfYP2z-BSk"
   },
   "source": [
    "## Define and train the model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "iVtFwjSp4rgs",
    "outputId": "4b68dd99-6615-4912-97bb-8267135c40d5"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sequential(\n",
      "  (0): Linear(in_features=512, out_features=128, bias=True)\n",
      "  (1): ReLU()\n",
      "  (2): Dropout(p=0.4, inplace=False)\n",
      "  (3): Linear(in_features=128, out_features=32, bias=True)\n",
      "  (4): ReLU()\n",
      "  (5): Dropout(p=0.4, inplace=False)\n",
      "  (6): Linear(in_features=32, out_features=6, bias=True)\n",
      ")\n"
     ]
    }
   ],
   "source": [
    "input_shape = 512\n",
    "\n",
    "# Define the model architecture\n",
    "head_model = nn.Sequential(\n",
    "    nn.Linear(input_shape, 128),\n",
    "    nn.ReLU(),\n",
    "    nn.Dropout(0.4),\n",
    "    nn.Linear(128, 32),\n",
    "    nn.ReLU(),\n",
    "    nn.Dropout(0.4),\n",
    "    nn.Linear(32, num_classes)\n",
    "    )\n",
    "\n",
    "print(head_model)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "def train_model(model: nn.Sequential,\n",
    "                X_train: torch.Tensor,  \n",
    "                y_train: torch.Tensor,  \n",
    "                X_val: torch.Tensor, \n",
    "                y_val: torch.Tensor, \n",
    "                optimizer = optim.Adam, \n",
    "                loss_fn = nn.CrossEntropyLoss(),\n",
    "                num_epochs = 50, \n",
    "                batch = 64):    \n",
    "\n",
    "    # Create DataLoader for batching\n",
    "    train_dataset = TensorDataset(X_train, y_train)\n",
    "    train_loader = DataLoader(train_dataset, batch_size=batch, shuffle=True)\n",
    "\n",
    "    # Validation dataset\n",
    "    val_dataset = TensorDataset(X_val, y_val)\n",
    "    val_loader = DataLoader(val_dataset, batch_size=batch, shuffle=False)\n",
    "\n",
    "    # Ensure model is in training mode\n",
    "    model.train()\n",
    "\n",
    "    for epoch in range(num_epochs):\n",
    "        for batch_X, batch_y in train_loader:\n",
    "            # Zero the parameter gradients\n",
    "            optimizer.zero_grad()\n",
    "            \n",
    "            # Forward pass\n",
    "            outputs = model(batch_X)\n",
    "            \n",
    "            # Compute loss\n",
    "            loss = loss_fn(outputs, batch_y)\n",
    "            \n",
    "            # Backward pass and optimize\n",
    "            loss.backward()\n",
    "            optimizer.step()\n",
    "            optimizer.zero_grad()\n",
    "        \n",
    "        # Validation phase (optional)\n",
    "        model.eval()\n",
    "        with torch.no_grad():\n",
    "            val_losses = []\n",
    "            for val_X, val_y in val_loader:\n",
    "                val_outputs = model(val_X)\n",
    "                val_loss = loss_fn(val_outputs, val_y)\n",
    "                val_losses.append(val_loss.item())\n",
    "            \n",
    "            print(f\"Epoch {epoch+1}, Validation Loss: {sum(val_losses)/len(val_losses)}\")\n",
    "        \n",
    "        # Set back to training mode for next epoch\n",
    "        model.train()\n",
    "        \n",
    "    model.eval()   \n",
    "    return model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "m_MksIuNw0Hb",
    "outputId": "1c316b1e-87b3-4ad5-d283-e6e810c44d19"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Validation Loss: 0.10509900515899062\n",
      "Epoch 2, Validation Loss: 0.09210213305106243\n",
      "Epoch 3, Validation Loss: 0.08708009730952863\n",
      "Epoch 4, Validation Loss: 0.08486809238988477\n",
      "Epoch 5, Validation Loss: 0.07630292710830243\n",
      "Epoch 6, Validation Loss: 0.07355103734880686\n",
      "Epoch 7, Validation Loss: 0.06611681672690722\n",
      "Epoch 8, Validation Loss: 0.06312987544627574\n",
      "Epoch 9, Validation Loss: 0.056430156445668005\n",
      "Epoch 10, Validation Loss: 0.05318047078505445\n",
      "Epoch 11, Validation Loss: 0.05370905570005281\n",
      "Epoch 12, Validation Loss: 0.050026227198451616\n",
      "Epoch 13, Validation Loss: 0.04953212696441019\n",
      "Epoch 14, Validation Loss: 0.04679244866397662\n",
      "Epoch 15, Validation Loss: 0.05049864224341805\n",
      "Epoch 16, Validation Loss: 0.04329267257260373\n",
      "Epoch 17, Validation Loss: 0.05164720463262011\n",
      "Epoch 18, Validation Loss: 0.044551525596314326\n",
      "Epoch 19, Validation Loss: 0.04502302069494572\n",
      "Epoch 20, Validation Loss: 0.040517984640945755\n",
      "Epoch 21, Validation Loss: 0.04486050424971976\n",
      "Epoch 22, Validation Loss: 0.044199613513998114\n",
      "Epoch 23, Validation Loss: 0.04122369681135751\n",
      "Epoch 24, Validation Loss: 0.03933001797346291\n",
      "Epoch 25, Validation Loss: 0.042462229007819235\n",
      "Epoch 26, Validation Loss: 0.04435293143167375\n",
      "Epoch 27, Validation Loss: 0.04156974930755006\n",
      "Epoch 28, Validation Loss: 0.03967876623657783\n",
      "Epoch 29, Validation Loss: 0.03859212029671583\n",
      "Epoch 30, Validation Loss: 0.041997895730533995\n",
      "Epoch 31, Validation Loss: 0.03875408053639918\n",
      "Epoch 32, Validation Loss: 0.041402942252506576\n",
      "Epoch 33, Validation Loss: 0.04364953876714795\n",
      "Epoch 34, Validation Loss: 0.03740719119937589\n",
      "Epoch 35, Validation Loss: 0.03878503382908933\n",
      "Epoch 36, Validation Loss: 0.04403487707839723\n",
      "Epoch 37, Validation Loss: 0.045056324614471614\n",
      "Epoch 38, Validation Loss: 0.04669451509499385\n",
      "Epoch 39, Validation Loss: 0.04211538765230216\n",
      "Epoch 40, Validation Loss: 0.046166509291372046\n",
      "Epoch 41, Validation Loss: 0.0411657914261853\n",
      "Epoch 42, Validation Loss: 0.038813597457752064\n",
      "Epoch 43, Validation Loss: 0.03979039859125176\n",
      "Epoch 44, Validation Loss: 0.038490781341142095\n",
      "Epoch 45, Validation Loss: 0.03988477771837587\n",
      "Epoch 46, Validation Loss: 0.04218148411578463\n",
      "Epoch 47, Validation Loss: 0.04319032455588548\n",
      "Epoch 48, Validation Loss: 0.043836868794572256\n",
      "Epoch 49, Validation Loss: 0.046494297688835874\n",
      "Epoch 50, Validation Loss: 0.040836334969543926\n"
     ]
    }
   ],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(x_scgpt, y_encoded, test_size=0.1, random_state=42)\n",
    "\n",
    "head_model_scgpt = deepcopy(head_model)\n",
    "head_model_scgpt = train_model(head_model_scgpt, \n",
    "                               torch.from_numpy(X_train), \n",
    "                               y_train, \n",
    "                               torch.from_numpy(X_test), \n",
    "                               y_test,\n",
    "                               optim.Adam(head_model_scgpt.parameters(), lr=0.001),\n",
    "                               nn.CrossEntropyLoss())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "UX4bwC0xw0Hc",
    "outputId": "d726323c-ce91-4be6-a09c-608f1dda4bd7"
   },
   "outputs": [],
   "source": [
    "predictions_nn = head_model_scgpt(torch.Tensor(X_test))\n",
    "y_pred = np.array(torch.argmax(predictions_nn, dim=1))\n",
    "y_true = np.array(y_test.argmax(axis=1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "Uy8_LASN-BSl"
   },
   "source": [
    "## Present the results\n",
    "- on the test set and,\n",
    "- a separate, unseen evaluation set"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "id": "_Lkv-mfDuKUP"
   },
   "outputs": [],
   "source": [
    "def get_evaluations(name_data_set, y_true, y_pred) -> dict:\n",
    "  accuracy = accuracy_score(y_true, y_pred)\n",
    "  precision = precision_score(y_true, y_pred, average='macro')\n",
    "  f1 = f1_score(y_true, y_pred, average='macro')\n",
    "  recall = recall_score(y_true, y_pred, average='macro')\n",
    "  print(f\"{name_data_set} accuracy: {(accuracy*100):.1f}%\")\n",
    "  print(f\"{name_data_set} precision: {(precision*100):.1f}%\")\n",
    "  print(f\"{name_data_set} f1: {(f1*100):.1f}%\")\n",
    "  print(f\"{name_data_set} recall: {(recall*100):.1f}%\")\n",
    "  return {\n",
    "      \"accuracy\": accuracy,\n",
    "      \"precision\": precision,\n",
    "      \"f1\": f1,\n",
    "      \"recall\": recall,\n",
    "  }"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "q3THhrm7uS99",
    "outputId": "6737b828-df9c-4507-c577-80082247918b"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Test set accuracy: 99.3%\n",
      "Test set precision: 97.8%\n",
      "Test set f1: 97.4%\n",
      "Test set recall: 97.2%\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "{'accuracy': 0.9927184466019418,\n",
       " 'precision': 0.9775860337484131,\n",
       " 'f1': 0.9743593343813646,\n",
       " 'recall': 0.9720213390843576}"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_evaluations(\"Test set\", y_true, y_pred)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "PGwcZiNaLkBv"
   },
   "source": [
    "Load the unseen evaluation set:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Generating train split: 100%|██████████| 25344/25344 [00:14<00:00, 1777.43 examples/s]\n",
      "Generating test split: 100%|██████████| 6336/6336 [00:02<00:00, 2123.87 examples/s]\n"
     ]
    }
   ],
   "source": [
    "ds = load_dataset(\"helical-ai/yolksac_human\",trust_remote_code=True, split=\"train[70%:]\",download_mode=\"reuse_cache_if_exists\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation_columns = [obs for obs in list(ds.features.keys()) if not obs == 'raw_counts']\n",
    "obs_data = pd.DataFrame(ds.select_columns(observation_columns).data.to_pandas(),columns=observation_columns)\n",
    "lil = lil_matrix((len(ds),ds[0]['size']))\n",
    "lil.data = np.array(ds['raw_counts'],dtype=\"object\")\n",
    "lil.rows = np.array(ds['rows'],dtype=\"object\")\n",
    "adata_unseen = ad.AnnData(lil.tocsr(),obs=obs_data)\n",
    "adata_unseen.var_names = ds.features['raw_counts'].id.split(\",\")\n",
    "adata_unseen.var['gene_name'] = adata_unseen.var_names.str.upper()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "18bomcpxlxtY",
    "outputId": "ab17404e-20c0-4590-b730-492de07e55bd"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:helical.models.scgpt.model:Filtering out 11163 genes to a total of 26155 genes with an id in the scGPT vocabulary.\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:helical.models.scgpt.model:Inference started:\n",
      "Embedding cells: 100%|██████████| 153/153 [00:15<00:00,  9.72it/s]\n"
     ]
    }
   ],
   "source": [
    "data_unseen = scgpt.process_data(adata_unseen, gene_names=\"gene_name\")\n",
    "x_unseen = scgpt.get_embeddings(data_unseen)\n",
    "predictions_nn_unseen = head_model_scgpt(torch.Tensor(x_unseen))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "CTDOE-0uLFAq"
   },
   "source": [
    "We should double check that the cell types are mapped to the correct id numbers for both the training data and this new data set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "h0Z6ZTBEJuuY",
    "outputId": "afab8809-b893-42fc-865d-4149f181a3ab"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "num_types = adata_unseen.obs[\"LVL1\"].unique().shape[0]\n",
    "id2type_unseen = dict(enumerate(adata_unseen.obs[\"LVL1\"].astype(\"category\").cat.categories))\n",
    "id2type_unseen == id2type"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "loLEKJr3qZvL",
    "outputId": "32ec87e0-96d3-4d5e-a1ae-6d3244e80ddb"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation set accuracy: 99.2%\n",
      "Evaluation set precision: 90.8%\n",
      "Evaluation set f1: 79.1%\n",
      "Evaluation set recall: 80.7%\n"
     ]
    }
   ],
   "source": [
    "y_true_unseen = np.array(adata_unseen.obs[\"LVL1\"].tolist())\n",
    "y_pred_unseen = [id2type[prediction] for prediction in np.array(torch.argmax(predictions_nn_unseen, dim=1))]\n",
    "\n",
    "scgpt_results = get_evaluations(\"Evaluation set\", y_true_unseen, y_pred_unseen)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "RgMbzX-z-BSm"
   },
   "source": [
    "Plot a confusion matrix to visualise the classification performance for each the cell type. This is done for the evalation set."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 1000
    },
    "id": "3f-apdJ4-BSm",
    "outputId": "3a195685-3539-4eb3-a90c-f029ecaf7949"
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<Axes: >"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1200x1200 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from sklearn.metrics import confusion_matrix\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "set_predicted_cell_types = list(adata_unseen.obs[\"LVL1\"].unique())\n",
    "for i in set(y_pred_unseen):\n",
    "    if i not in set_predicted_cell_types:\n",
    "        set_predicted_cell_types.remove(i)\n",
    "\n",
    "cm = confusion_matrix(y_true_unseen, y_pred_unseen)\n",
    "cm = cm.astype(\"float\") / cm.sum(axis=1)[:, np.newaxis]\n",
    "cm = pd.DataFrame(cm, index=set_predicted_cell_types[:cm.shape[0]], columns=set_predicted_cell_types[:cm.shape[1]])\n",
    "plt.figure(figsize=(12, 12))\n",
    "sns.heatmap(cm, annot=True, fmt=\".1f\", cmap=\"Blues\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "XdG0swPrC5sh"
   },
   "source": [
    "# Geneformer"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do the same with the Geneformer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 285,
     "referenced_widgets": [
      "9be7ad77cfbb4aebbf850bce0d703286",
      "96cf6bd80b23485a91309f97fceae386",
      "6793d6aa02fe4992b2a3079935804e68",
      "8b87146682714f9394465afb70fb6296",
      "8602ffeb4a5548f3b88e0011ff526b60",
      "dd28b99c3789438ba123044f9d8bd481",
      "11d0b1de79104633bd46099d3fc9f845",
      "b0387ec16b2346d6a690f8bd8ef7aae9",
      "0fcbdfa61d8c47499ea91c045e6bdb88",
      "475e8bc25e844eb7bda64024f6fd328b",
      "06b297ce68a54494925355922e6a3e60",
      "129fbaa5b93146839d3e095e066689b2",
      "75250bb34c7a4816bb50bab813367823",
      "18e7db16f29b4c5fb37b12b7ecabd994",
      "811ae6f2713942459f44a8ad0b78f1c8",
      "8333081f6e6844fb9872d9d14b9798f4",
      "1a9866fd593a4773a9336548d9fb4e7c",
      "6105972c9a224bb2b83c39d498d82694",
      "ac8fd8833f8b434c98ebf9de7fd7c956",
      "746baf43caea4ee2831817691b968573",
      "94072eee12234d52906f701dbaec4ea7",
      "0ba9a6eb6f0c4d63ae804a09f5d3b7a5"
     ]
    },
    "id": "5P_7jNYDqbYp",
    "outputId": "2fcd4258-77bb-47f1-94fd-6e9742f02e04"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:helical.utils.downloader:File: '/home/benoit/.cache/helical/models/geneformer/v1/gene_median_dictionary.pkl' exists already. File is not overwritten and nothing is downloaded.\n",
      "INFO:helical.utils.downloader:File saved to: '/home/benoit/.cache/helical/models/geneformer/v1/gene_median_dictionary.pkl'\n",
      "INFO:helical.utils.downloader:File: '/home/benoit/.cache/helical/models/geneformer/v1/token_dictionary.pkl' exists already. File is not overwritten and nothing is downloaded.\n",
      "INFO:helical.utils.downloader:File saved to: '/home/benoit/.cache/helical/models/geneformer/v1/token_dictionary.pkl'\n",
      "INFO:helical.utils.downloader:File: '/home/benoit/.cache/helical/models/geneformer/v1/ensembl_mapping_dict.pkl' exists already. File is not overwritten and nothing is downloaded.\n",
      "INFO:helical.utils.downloader:File saved to: '/home/benoit/.cache/helical/models/geneformer/v1/ensembl_mapping_dict.pkl'\n",
      "INFO:helical.utils.downloader:File: '/home/benoit/.cache/helical/models/geneformer/v1/gf-12L-30M-i2048/config.json' exists already. File is not overwritten and nothing is downloaded.\n",
      "INFO:helical.utils.downloader:File saved to: '/home/benoit/.cache/helical/models/geneformer/v1/gf-12L-30M-i2048/config.json'\n",
      "INFO:helical.utils.downloader:File: '/home/benoit/.cache/helical/models/geneformer/v1/gf-12L-30M-i2048/training_args.bin' exists already. File is not overwritten and nothing is downloaded.\n",
      "INFO:helical.utils.downloader:File saved to: '/home/benoit/.cache/helical/models/geneformer/v1/gf-12L-30M-i2048/training_args.bin'\n",
      "INFO:helical.utils.downloader:File: '/home/benoit/.cache/helical/models/geneformer/v1/gf-12L-30M-i2048/pytorch_model.bin' exists already. File is not overwritten and nothing is downloaded.\n",
      "INFO:helical.utils.downloader:File saved to: '/home/benoit/.cache/helical/models/geneformer/v1/gf-12L-30M-i2048/pytorch_model.bin'\n",
      "INFO:helical.models.geneformer.model:Model finished initializing.\n",
      "INFO:pyensembl.sequence_data:Loaded sequence dictionary from /home/benoit/.cache/pyensembl/GRCh38/ensembl110/Homo_sapiens.GRCh38.cdna.all.fa.gz.pickle\n",
      "INFO:pyensembl.sequence_data:Loaded sequence dictionary from /home/benoit/.cache/pyensembl/GRCh38/ensembl110/Homo_sapiens.GRCh38.ncrna.fa.gz.pickle\n",
      "INFO:pyensembl.sequence_data:Loaded sequence dictionary from /home/benoit/.cache/pyensembl/GRCh38/ensembl110/Homo_sapiens.GRCh38.pep.all.fa.gz.pickle\n",
      "INFO:helical.utils.mapping:Mapped 21111 genes to Ensembl IDs from a total of 37318 genes.\n",
      "INFO:helical.models.geneformer.geneformer_tokenizer:AnnData object with n_obs × n_vars = 16474 × 37318\n",
      "    obs: 'rows', 'size', 'LVL1', 'LVL2', 'LVL3', 'total_counts'\n",
      "    var: 'gene_name', 'id_in_vocab', 'ensembl_id', 'gene_ids_collapsed' has no column attribute 'filter_pass'; tokenizing all cells.\n",
      "INFO:helical.models.geneformer.geneformer_tokenizer:Creating dataset.\n",
      "Map: 100%|██████████| 16474/16474 [00:05<00:00, 3025.41 examples/s]\n",
      "INFO:helical.models.geneformer.model:Inference started:\n",
      "100%|██████████| 330/330 [05:07<00:00,  1.07it/s]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "(16474, 512)"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "device = \"cuda\" if torch.cuda.is_available() else \"cpu\"\n",
    "if 'rows' in adata.obs:\n",
    "    adata.obs['rows'] = adata.obs['rows'].astype(str)\n",
    "geneformer_config = GeneformerConfig(batch_size=50, device=device)\n",
    "geneformer = Geneformer(configurer = geneformer_config)\n",
    "\n",
    "data_geneformer = geneformer.process_data(adata, gene_names = \"gene_name\")\n",
    "x_geneformer = geneformer.get_embeddings(data_geneformer)\n",
    "x_geneformer.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "ITj-Gd-TDIcu",
    "outputId": "4946c091-3340-4332-e208-2ab2fc46f15e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Epoch 1, Validation Loss: 0.21696129383949134\n",
      "Epoch 2, Validation Loss: 0.10857223622644177\n",
      "Epoch 3, Validation Loss: 0.09659991732153755\n",
      "Epoch 4, Validation Loss: 0.09191516814126562\n",
      "Epoch 5, Validation Loss: 0.08651317040829991\n",
      "Epoch 6, Validation Loss: 0.08288597050033367\n",
      "Epoch 7, Validation Loss: 0.07626076801142727\n",
      "Epoch 8, Validation Loss: 0.07917614357295231\n",
      "Epoch 9, Validation Loss: 0.07136841879065077\n",
      "Epoch 10, Validation Loss: 0.07527488532426875\n",
      "Epoch 11, Validation Loss: 0.06889283100966938\n",
      "Epoch 12, Validation Loss: 0.07603136524546873\n",
      "Epoch 13, Validation Loss: 0.07237893132080969\n",
      "Epoch 14, Validation Loss: 0.0707903919716885\n",
      "Epoch 15, Validation Loss: 0.06682811810214144\n",
      "Epoch 16, Validation Loss: 0.06787337761488743\n",
      "Epoch 17, Validation Loss: 0.06565282110554668\n",
      "Epoch 18, Validation Loss: 0.07381324346072059\n",
      "Epoch 19, Validation Loss: 0.0704241120183724\n",
      "Epoch 20, Validation Loss: 0.06702452171773005\n",
      "Epoch 21, Validation Loss: 0.06794494667925531\n",
      "Epoch 22, Validation Loss: 0.06038204437041154\n",
      "Epoch 23, Validation Loss: 0.060252198385289654\n",
      "Epoch 24, Validation Loss: 0.06358248780060631\n",
      "Epoch 25, Validation Loss: 0.06292168345176972\n",
      "Epoch 26, Validation Loss: 0.06266387048078916\n",
      "Epoch 27, Validation Loss: 0.061681864904060676\n",
      "Epoch 28, Validation Loss: 0.058782341822874375\n",
      "Epoch 29, Validation Loss: 0.05916480725416197\n",
      "Epoch 30, Validation Loss: 0.05904467829924005\n",
      "Epoch 31, Validation Loss: 0.05701122948084958\n",
      "Epoch 32, Validation Loss: 0.05678210777785772\n",
      "Epoch 33, Validation Loss: 0.06069203816206517\n",
      "Epoch 34, Validation Loss: 0.05833638691043374\n",
      "Epoch 35, Validation Loss: 0.060886409481799304\n",
      "Epoch 36, Validation Loss: 0.05711668227852967\n",
      "Epoch 37, Validation Loss: 0.06182696464496145\n",
      "Epoch 38, Validation Loss: 0.05757013989093069\n",
      "Epoch 39, Validation Loss: 0.056393348726067834\n",
      "Epoch 40, Validation Loss: 0.0600513292447431\n",
      "Epoch 41, Validation Loss: 0.06829129664290051\n",
      "Epoch 42, Validation Loss: 0.062308046387512986\n",
      "Epoch 43, Validation Loss: 0.055768700710569434\n",
      "Epoch 44, Validation Loss: 0.05563147523431466\n",
      "Epoch 45, Validation Loss: 0.06237108943661532\n",
      "Epoch 46, Validation Loss: 0.05813543734928736\n",
      "Epoch 47, Validation Loss: 0.05794153505569109\n",
      "Epoch 48, Validation Loss: 0.06292974418521716\n",
      "Epoch 49, Validation Loss: 0.06411586219977695\n",
      "Epoch 50, Validation Loss: 0.05854638515917871\n"
     ]
    }
   ],
   "source": [
    "X_train, X_test, y_train, y_test = train_test_split(x_geneformer, y_encoded, test_size=0.1, random_state=42)\n",
    "\n",
    "head_model_geneformer = deepcopy(head_model)\n",
    "head_model_geneformer = train_model(head_model_geneformer, \n",
    "                                    torch.tensor(X_train), \n",
    "                                    y_train, \n",
    "                                    torch.tensor(X_test), \n",
    "                                    y_test,\n",
    "                                    optim.Adam(head_model_geneformer.parameters(), lr=0.001),\n",
    "                                    nn.CrossEntropyLoss())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 156,
     "referenced_widgets": [
      "042588def40e42848c464da311dfa395",
      "9f06f76e74ba4d4493a2b3810fa78501",
      "afde76acb7cd4642967e74fc01cc5e60",
      "bed90884638d44a1a0e8f2002485a49c",
      "577aff58497a41afb68c49c4e4a3483c",
      "e6639753498c44abbb25f2dd39f224a6",
      "0ae5dd4c69154c36ac6409002dbfdbe3",
      "98077a70b5aa4738b2f9ce21fc8a76f8",
      "6c0eae3868aa4ea98c7c1106aba4cb84",
      "08d07e9439494aa895b90bda386cd2d9",
      "c284a26712fc46a49f40081765203b11",
      "9e58f857ee8a43ac94614686ba82cf82",
      "21078359f8b64f1f9e5b70fbb559ac5e",
      "0536305995ae41b989c00348dec37a50",
      "da40c55164824b2e81fef416cea0bdf3",
      "45e0ffdc378040c8b8fb62172c321be5",
      "031f15e503284b6e989e599834bc0cfc",
      "d6a09da0033a4fff88ce7ad041ea5151",
      "44164c48e4774fd28c8e7514e26dfec3",
      "7fba8d16f48b451ba2695e7d8d0c605b",
      "8f571f239ad54eb19d35da67e47ddea9",
      "fb07aa128c734c1396a8d2e8e46dfd7e"
     ]
    },
    "id": "ycWcn3Ra1YbG",
    "outputId": "8e38e24d-261d-4d77-b704-a8d3c6df9b73"
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "INFO:pyensembl.sequence_data:Loaded sequence dictionary from /home/benoit/.cache/pyensembl/GRCh38/ensembl110/Homo_sapiens.GRCh38.cdna.all.fa.gz.pickle\n",
      "INFO:pyensembl.sequence_data:Loaded sequence dictionary from /home/benoit/.cache/pyensembl/GRCh38/ensembl110/Homo_sapiens.GRCh38.ncrna.fa.gz.pickle\n",
      "INFO:pyensembl.sequence_data:Loaded sequence dictionary from /home/benoit/.cache/pyensembl/GRCh38/ensembl110/Homo_sapiens.GRCh38.pep.all.fa.gz.pickle\n",
      "INFO:helical.utils.mapping:Mapped 21111 genes to Ensembl IDs from a total of 37318 genes.\n",
      "INFO:helical.models.geneformer.geneformer_tokenizer:AnnData object with n_obs × n_vars = 7603 × 37318\n",
      "    obs: 'rows', 'size', 'LVL1', 'LVL2', 'LVL3', 'total_counts'\n",
      "    var: 'gene_name', 'id_in_vocab', 'ensembl_id', 'gene_ids_collapsed' has no column attribute 'filter_pass'; tokenizing all cells.\n",
      "INFO:helical.models.geneformer.geneformer_tokenizer:Creating dataset.\n",
      "Map: 100%|██████████| 7603/7603 [00:03<00:00, 2071.15 examples/s]\n",
      "INFO:helical.models.geneformer.model:Inference started:\n",
      "100%|██████████| 153/153 [02:21<00:00,  1.08it/s]\n"
     ]
    }
   ],
   "source": [
    "data_unseen_geneformer = geneformer.process_data(adata_unseen, gene_names = \"gene_name\")\n",
    "x_unseen_geneformer = geneformer.get_embeddings(data_unseen_geneformer)\n",
    "predictions_nn_unseen_geneformer = head_model_geneformer(torch.Tensor(x_unseen_geneformer))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/"
    },
    "id": "eR8jNVcrEMRR",
    "outputId": "5d4ff27a-3bbb-409d-db36-61f787dc1b0e"
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Evaluation set accuracy: 98.9%\n",
      "Evaluation set precision: 71.6%\n",
      "Evaluation set f1: 73.6%\n",
      "Evaluation set recall: 77.3%\n"
     ]
    }
   ],
   "source": [
    "y_true_unseen = np.array(adata_unseen.obs[\"LVL1\"].tolist())\n",
    "y_pred_unseen = [id2type[prediction] for prediction in np.array(torch.argmax(predictions_nn_unseen_geneformer, dim=1))]\n",
    "\n",
    "geneformer_results = get_evaluations(\"Evaluation set\", y_true_unseen, y_pred_unseen)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "colab": {
     "base_uri": "https://localhost:8080/",
     "height": 990
    },
    "id": "sK4UqSqQFSaS",
    "outputId": "b1d94806-ed84-4061-d50b-d6b567df66f4"
   },
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 1000x1000 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "fig, axs = plt.subplots(2, 2, figsize=(10, 10))\n",
    "\n",
    "values_1 = [scgpt_results[\"accuracy\"], geneformer_results[\"accuracy\"]]\n",
    "x = [\"scGPT\", \"Geneformer\"]\n",
    "axs[0, 0].bar(x, values_1, width=0.4)\n",
    "axs[0, 0].set_title(\"Accuracy\")\n",
    "axs[0, 0].set_ylim([0, 1])\n",
    "\n",
    "values_2 = [scgpt_results[\"precision\"], geneformer_results[\"precision\"]]\n",
    "axs[0, 1].bar(x, values_2, width=0.4)\n",
    "axs[0, 1].set_title(\"Precision\")\n",
    "axs[0, 1].set_ylim([0, 1])\n",
    "\n",
    "values_3 = [scgpt_results[\"f1\"], geneformer_results[\"f1\"]]\n",
    "axs[1, 0].bar(x, values_3, width=0.4)\n",
    "axs[1, 0].set_title(\"F1\")\n",
    "axs[1, 0].set_ylim([0, 1])\n",
    "\n",
    "values_4 = [scgpt_results[\"recall\"], geneformer_results[\"recall\"]]\n",
    "axs[1, 1].bar(x, values_4, width=0.4)\n",
    "axs[1, 1].set_title(\"Recall\")\n",
    "axs[1, 1].set_ylim([0, 1])\n",
    "\n",
    "fig.suptitle(\"scGPT vs. Geneformer \\n Probing Comparison\")\n",
    "fig.tight_layout()\n",
    "plt.show()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "id": "W4yqDgBPMNhX"
   },
   "source": [
    "\n",
    "## scGPT\n",
    "- Accuracy: 99.2%\n",
    "- Precision: 90.8%\n",
    "- Recall: 79.1%\n",
    "- Macro F1: 80.7%\n",
    "\n",
    "## Geneformer\n",
    "- Accuracy: 98.9%\n",
    "- Precision: 71.6%\n",
    "- Recall: 73.6%\n",
    "- Macro F1: 77.3%"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    " (c) Helical 2024 - Developed by the Helical Team"
   ]
  }
 ],
 "metadata": {
  "language_info": {
   "name": "python"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}