SIMS_tutorial.ipynb

{
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "4vQBIkvbvLTh"
      },
      "source": [
        "## **SIMS Tutorial**\n",
        "In this tutorial, we will walk through the [SIMS (Scalable, Interpretable Machine Learning for Single Cell)](https://www.cell.com/cell-genomics/fulltext/S2666-979X(24)00165-4) pipeline step by step. SIMS is a deep learning-based tool built on TabNet, a transformer-based model optimized for tabular data. It is designed to classify single-cell RNA sequencing (scRNA-seq) data while providing interpretable predictions.\n",
        "\n",
        "By following this tutorial, you will learn how to:\n",
        "- Download and prepare scRNA-seq data for SIMS\n",
        "- Train a SIMS model to classify cell types\n",
        "- Use the trained model to make predictions on new, unseen data\n",
        "- Evaluate predictions using accuracy metrics and visualization tools\n",
        "\n",
        "\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "5VBQ2IOZ2vBI"
      },
      "source": [
        "### **Before you begin**\n",
        "The `scsims` package is only compatible with Python versions between 3.8 and 3.11. Run the following cell to ensure you are using a compatible version (we recommend Python 3.9 for optimal performance)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 1,
      "metadata": {
        "id": "Ttl01qww2tSU"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Python 3.9.6\n"
          ]
        }
      ],
      "source": [
        "!python --version"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "Edu0ONPZwssS"
      },
      "source": [
        "If you're running this notebook for the first time, uncomment and execute the following line to **install the required packages:**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 12,
      "metadata": {},
      "outputs": [],
      "source": [
        "# !pip install --use-pep517 git+https://github.com/braingeneers/SIMS.git"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "Once the packages are installed, we can **import them:**"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {
        "collapsed": true,
        "id": "vgVLLQKsutZh"
      },
      "outputs": [],
      "source": [
        "import scanpy as sc\n",
        "import pandas as pd\n",
        "import anndata as ad\n",
        "import os\n",
        "import torch\n",
        "from scsims import SIMS\n",
        "from pytorch_lightning.callbacks import EarlyStopping, ModelCheckpoint\n",
        "from sklearn.model_selection import train_test_split"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### **Step 1: Prepare data**\n",
        "\n",
        "Before we can train our model, we need to prepare the data. This involves several key steps to ensure that the dataset is structured correctly and optimized for machine learning."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "o87__CAvvmAW"
      },
      "source": [
        "#### `1.a` Download data\n",
        "The dataset we are using comes from a study published in eLife by Domingo-Gonzalez et al. (2020). This study investigated immune cells in the developing mouse lung at single-cell resolution. It contains only 4,052 cells, making it ideal for this notebook (large enough for meaningful training but small enough for computational efficiency).\n",
        "\n",
        "🔗 Source:\n",
        "\n",
        "- [UCSC Cell Browser website](https://cells.ucsc.edu/?bp=lung&org=Mouse+(M.+musculus)) – where we download the dataset.\n",
        "- [Domingo-Gonzalez et al., 2020 (eLife)](https://elifesciences.org/articles/56890) – original study providing the data."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WYnJGosSvdz6",
        "outputId": "7f1933d5-a9a2-4023-fa9c-a88baad5af1b"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
            "                                 Dload  Upload   Total   Spent    Left  Speed\n",
            "100 24.1M  100 24.1M    0     0  3239k      0  0:00:07  0:00:07 --:--:-- 3581k --:--:--     0\n",
            "  % Total    % Received % Xferd  Average Speed   Time    Time     Time  Current\n",
            "                                 Dload  Upload   Total   Spent    Left  Speed\n",
            "100  748k  100  748k    0     0  2052k      0 --:--:-- --:--:-- --:--:-- 2057k\n"
          ]
        }
      ],
      "source": [
        "!curl -O https://cells.ucsc.edu/mouse-lung-immune/exprMatrix.tsv.gz\n",
        "!curl -O https://cells.ucsc.edu/mouse-lung-immune/meta.tsv"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "bJscEWnzw-SO"
      },
      "source": [
        "#### `1.b` Load the Anndata object\n",
        "In this step, we will load the gene expression matrix and associated metadata, clean the data, and convert it into an AnnData object for further processing."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 4,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "UBFZxH_7xCiH",
        "outputId": "37abe71d-838e-4e19-c77b-98a9cfb97af5"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "AnnData object with n_obs × n_vars = 4052 × 18072\n",
            "    obs: 'title', 'Sequencing run', 'Gender', 'Plate', 'Well', 'Timepoint', 'Cell Subtype', 'Mousename', 'Coverage', 'Number of genes', 'raw file 1', 'raw file 2'\n"
          ]
        }
      ],
      "source": [
        "# Load expression matrix\n",
        "expr_matrix = pd.read_csv(\"exprMatrix.tsv.gz\", sep=\"\\t\", index_col=0)\n",
        "\n",
        "# Load metadata\n",
        "meta = pd.read_csv(\"meta.tsv\", sep=\"\\t\", index_col=0)\n",
        "\n",
        "# This particular dataset stores gene names in a 'GENE|GENE' format\n",
        "# This step removes duplicate gene names if they exist\n",
        "if \"|\" in expr_matrix.index[0]:\n",
        "    expr_matrix.index = expr_matrix.index.str.split('|').str[0]\n",
        "\n",
        "# Transpose to make cells as rows and genes as columns (CELL x GENE)\n",
        "expr_matrix = expr_matrix.T\n",
        "\n",
        "# Ensure indices match\n",
        "expr_matrix = expr_matrix.loc[meta.index]\n",
        "\n",
        "# Create AnnData object\n",
        "adata = ad.AnnData(expr_matrix)\n",
        "\n",
        "# Add metadata to AnnData object\n",
        "adata.obs = meta\n",
        "\n",
        "# Show basic info\n",
        "print(adata)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `1.c` Select target feature\n",
        "In this example dataset, cell type labels are stored in the 'Cell Subtype' column, so we will remove other columns as they are not needed for training.\n",
        "\n",
        "🔹 **Note:** If you're using a different dataset, replace 'Cell Subtype' with the appropriate column that contains your cell type annotations. Run `adata.obs.columns` to check available columns in your dataset before selecting the target feature."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 5,
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "MkxzgZVkxgoe",
        "outputId": "ed7e7157-90f8-429f-8b2f-5907144a9653"
      },
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Cell types:  ['NK cell' 'T cell' 'B cell' 'Mac III' 'neutrophil' 'IL cell' 'Mac V'\n",
            " 'basophil' 'Mac II' 'mast cell' 'Mac IV' 'DC III' 'DC II' 'DC I' 'Mac I']\n"
          ]
        }
      ],
      "source": [
        "class_label = 'Cell Subtype' \n",
        "\n",
        "adata.obs = adata.obs[[class_label]] # Filter out other columns\n",
        "unique_classes = adata.obs[class_label].unique()\n",
        "print(\"Cell types: \", unique_classes)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "WZgjeu742EV1"
      },
      "source": [
        "#### `1.d` Preprocess the data\n",
        "Now we need to preprocess the data to ensure it is clean, normalized, and ready for model training. \n",
        "\n",
        "🔹 **Important:** The same preprocessing steps must be applied consistently to both the training dataset and any new data used for inference to ensure compatibility."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 6,
      "metadata": {
        "id": "K3_3a16_2Iu6"
      },
      "outputs": [],
      "source": [
        "# Perform some light filtering\n",
        "sc.pp.filter_cells(adata, min_genes=100)\n",
        "sc.pp.filter_genes(adata, min_cells=3)\n",
        "\n",
        "# Transform the data for model ingestion\n",
        "sc.pp.normalize_total(adata) \n",
        "sc.pp.log1p(adata)\n",
        "sc.pp.scale(adata)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `1.e` Split data\n",
        "In real-world applications, SIMS is typically used with two datasets: a **labeled** dataset for training and an **unlabeled** dataset for generating predictions. Since we don't have a separate unlabeled dataset for this example, we'll split our labeled dataset into a **training set** (used to train the model) and a **test set** (used to evaluate its performance). This allows us to assess how well SIMS generalizes to unseen data.\n",
        "\n",
        "🔹 **Note:** If you are using your own dataset, do not split it. Instead, load your test data separately during the prediction step. Make sure to preprocess your test data using the same steps applied to your training data to maintain consistency and avoid errors."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 7,
      "metadata": {},
      "outputs": [],
      "source": [
        "# Split cells into train and test (ex: 80% train, 20% test)\n",
        "train_cells, test_cells = train_test_split(adata.obs_names, test_size=0.2, random_state=42)\n",
        "\n",
        "# Create training and \"unlabeled\" test datasets\n",
        "adata_train = adata[train_cells].copy()\n",
        "adata_test = adata[test_cells].copy()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### **Step 2: Train the model with SIMS**\n",
        "Now that our dataset is preprocessed, we can train a machine learning model using SIMS. SIMS is built on [TabNet](https://arxiv.org/abs/1908.07442), a deep learning architecture optimized for tabular data. It allows us to classify immune cells based on gene expression while maintaining model interpretability."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `2.a` Initialize SIMS model\n",
        "We first create a SIMS object using the training dataset (`adata_train`) and specify the cell type label column:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 8,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Numerically encoding class labels\n",
            "Calculating weights\n"
          ]
        }
      ],
      "source": [
        "sims = SIMS(data=adata_train, class_label=class_label)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `2.b` Set up model parameters\n",
        "Next, we configure the model using setup_model():"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 9,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Setting up model ...\n",
            "Initializing network\n",
            "Initializing explain matrix\n"
          ]
        }
      ],
      "source": [
        "sims.setup_model(n_a=64, n_d=64, weights=sims.weights)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "- `n_a=64` and `n_d=64` define the number of attention and decision steps in the TabNet architecture.\n",
        "- `weights=sims.weights` ensures that the model adjusts for imbalanced cell types by weighting the loss inversely to label frequency. This helps the model learn rare cell types more effectively."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `2.c` Define Checkpointing Strategy\n",
        "Since training deep learning models takes time, we save the best version using a checkpointing system:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 10,
      "metadata": {},
      "outputs": [],
      "source": [
        "checkpoint_callback = ModelCheckpoint(\n",
        "    dirpath=\"./sims\",           # Save in the notebook's current directory\n",
        "    filename=\"sims_model\",  # File will be saved as 'sims_model.ckpt'\n",
        "    save_top_k=1,           # Keep only the best checkpoint\n",
        "    monitor=\"val_loss\",     # Save the best model based on validation loss\n",
        "    mode=\"min\",             # Lower validation loss is better\n",
        ")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `2.d` Configure the Training Process\n",
        "We set up the training loop using a PyTorch Lightning trainer:\n"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Setting up trainer ...\n"
          ]
        }
      ],
      "source": [
        "sims.setup_trainer(\n",
        "    callbacks=[\n",
        "        EarlyStopping(monitor=\"val_loss\", patience=50), # Stop training if validation loss does not improve for 50 epochs\n",
        "        checkpoint_callback, # Save the best model\n",
        "    ],\n",
        "    max_epochs=50,      # Complete training cycles through the dataset, can increase\n",
        "    accelerator=\"cpu\",  # Forces training on CPU, can switch to GPU/MPS if available\n",
        "    devices=1,          # Uses one CPU/GPU device\n",
        "    logger=False,       # Disable/enable logging\n",
        ")\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "🔹 **Note:** Weights & Biases (WandB) logging has been disabled in this example for simplicity. However, if you want to use WandB logging, follow these steps **before configuring the training process** (in the previous cell):\n",
        "1. Import WandbLogger: `from pytorch_lightning.loggers import WandbLogger`\n",
        "2. Initialize and set offline to True: `logger = WandbLogger(offline=True)` \n",
        "3. In `sims.setup_trainer()`, change code below to `logger=logger`"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `2.e` Train and save model\n",
        "Once everything is set up, we train the model with:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Beginning training\n",
            "Calculating weights\n",
            "Initializing with optimizer = Adam (\n",
            "Parameter Group 0\n",
            "    amsgrad: False\n",
            "    betas: (0.9, 0.999)\n",
            "    capturable: False\n",
            "    differentiable: False\n",
            "    eps: 1e-08\n",
            "    foreach: None\n",
            "    fused: False\n",
            "    lr: 0.01\n",
            "    maximize: False\n",
            "    weight_decay: 0.01\n",
            ")\n",
            "Initializating with scheduler = <torch.optim.lr_scheduler.ReduceLROnPlateau object at 0x33b669880>\n",
            "Epoch 49: 100%|██████████| 65/65 [00:08<00:00,  7.50it/s]                  \n",
            "Finished training\n"
          ]
        }
      ],
      "source": [
        "sims.train()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "After training, we verify that a trained model was saved:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 14,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Saved model: ['sims_model.ckpt']\n"
          ]
        }
      ],
      "source": [
        "print(\"Saved model:\", [f for f in os.listdir() if f.endswith(\".ckpt\")])"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### **Step 3: Predict on new data with trained model**"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `3.a` Load the Trained Model\n",
        "To make predictions, we first load the trained SIMS model from the checkpoint:"
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 15,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Initializing network\n",
            "Initializing explain matrix\n"
          ]
        }
      ],
      "source": [
        "sims = SIMS(weights_path=\"sims_model.ckpt\", map_location=torch.device('cpu'))"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "- `weights_path=\"sims_model.ckpt\"` loads the model checkpoint.\n",
        "- `map_location=torch.device('cpu')` ensures the model runs on CPU (set to \"cuda\" if using a GPU)."
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `3.b` Predict cell types\n",
        "We then use the model to predict cell types for the test dataset (`adata_test`). This returns a DataFrame containing predicted labels for each cell."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 16,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Parsing inference data...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 26/26 [00:32<00:00,  1.23s/it]\n"
          ]
        }
      ],
      "source": [
        "cell_predictions = sims.predict(adata_test)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `3.c` Align predictions with cell names, add predictions to AnnData object, and view\n",
        "To ensure that the predictions are correctly indexed, we align them with `adata_test.obs_names`. We then merge the predictions with the metadata of the test dataset (`adata_test.obs`) and can view the predictions."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 17,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "                               Cell Subtype  n_genes      pred_0  pred_1   \n",
            "M_P21_normal_CD45_2_DC36_B1          B cell     2513      B cell  Mac II  \\\n",
            "F_P7_normal_CD45_1_DC20_I12      neutrophil     1181  neutrophil   Mac I   \n",
            "M_P1_normal_CD45_2_DC35_B3            Mac V     3384       Mac V    DC I   \n",
            "M_E18.5_normal_CD45_2_DC35_D22       Mac II     3149      Mac II   Mac I   \n",
            "M_P1_normal_CD45_1_DC35_M10      neutrophil     1259  neutrophil   Mac I   \n",
            "\n",
            "                                 pred_2    prob_0    prob_1    prob_2  \n",
            "M_P21_normal_CD45_2_DC36_B1     IL cell  0.933107  0.050598  0.016295  \n",
            "F_P7_normal_CD45_1_DC20_I12     NK cell  0.854346  0.091639  0.054015  \n",
            "M_P1_normal_CD45_2_DC35_B3       Mac IV  0.638564  0.187885  0.173551  \n",
            "M_E18.5_normal_CD45_2_DC35_D22   Mac IV  0.832520  0.107359  0.060121  \n",
            "M_P1_normal_CD45_1_DC35_M10     NK cell  0.862213  0.087000  0.050787  \n"
          ]
        }
      ],
      "source": [
        "cell_predictions.index = adata_test.obs_names  # Align predictions with `adata_test`\n",
        "adata_test.obs = adata_test.obs.join(cell_predictions, rsuffix='_pred')\n",
        "print(adata_test.obs.head())"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### **Step 4: Evaluate and visualize**\n",
        "Once we have predicted cell types, we can evaluate how well the model performed. Each of these steps is optional.\n",
        "\n",
        "#### `4.a` Calculate model accuracy\n",
        "We compute accuracy, which measures the proportion of correctly classified cells:   "
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 18,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Model Accuracy: 0.92\n"
          ]
        }
      ],
      "source": [
        "from sklearn.metrics import accuracy_score\n",
        "accuracy = accuracy_score(adata_test.obs[class_label], adata_test.obs[\"pred_0\"])\n",
        "print(f\"Model Accuracy: {accuracy:.2f}\")"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `4.b` Generate a classification report\n",
        "A classification report provides detailed performance metrics for each cell type, such as: \n",
        "- Precision – How many of the predicted cells are actually correct?\n",
        "- Recall – How many of the true cells were correctly classified?\n",
        "- F1-score – A balanced metric combining precision and recall."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 21,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "              precision    recall  f1-score   support\n",
            "\n",
            "      B cell       1.00      0.98      0.99       132\n",
            "        DC I       0.75      1.00      0.86         9\n",
            "       DC II       0.69      0.90      0.78        10\n",
            "      DC III       0.00      0.00      0.00         6\n",
            "     IL cell       0.53      0.89      0.67         9\n",
            "       Mac I       0.96      0.85      0.90       142\n",
            "      Mac II       0.69      0.92      0.79        65\n",
            "     Mac III       0.97      0.86      0.91        36\n",
            "      Mac IV       0.96      0.98      0.97        46\n",
            "       Mac V       0.99      0.95      0.97       152\n",
            "     NK cell       0.90      0.75      0.82        24\n",
            "      T cell       0.91      0.98      0.94        61\n",
            "    basophil       0.88      1.00      0.94        15\n",
            "   mast cell       0.00      0.00      0.00         2\n",
            "  neutrophil       0.99      0.99      0.99       102\n",
            "\n",
            "    accuracy                           0.92       811\n",
            "   macro avg       0.75      0.80      0.77       811\n",
            "weighted avg       0.93      0.92      0.92       811\n",
            "\n"
          ]
        }
      ],
      "source": [
        "from sklearn.metrics import classification_report\n",
        "\n",
        "report = classification_report(\n",
        "    adata_test.obs[class_label], \n",
        "    adata_test.obs[\"pred_0\"], \n",
        "    zero_division=0  # Set to 0 instead of raising a warning\n",
        ")\n",
        "print(report)\n"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `4.c` Compute and visualize confusion matrix\n",
        "To see how predictions compare to actual labels, we compute a confusion matrix, where: \n",
        "- Each row represents actual cell types.\n",
        "- Each column represents predicted cell types.\n",
        "- Diagonal values indicate correct classifications, while off-diagonal values show misclassifications."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 22,
      "metadata": {},
      "outputs": [
        {
          "data": {
            "image/png": "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",
            "text/plain": [
              "<Figure size 800x600 with 2 Axes>"
            ]
          },
          "metadata": {},
          "output_type": "display_data"
        }
      ],
      "source": [
        "from sklearn.metrics import confusion_matrix\n",
        "import matplotlib.pyplot as plt\n",
        "import seaborn as sns\n",
        "\n",
        "# Compute confusion matrix\n",
        "cm = confusion_matrix(adata_test.obs[class_label], adata_test.obs[\"pred_0\"])\n",
        "\n",
        "# Normalize by row (convert counts to percentages)\n",
        "cm_normalized = cm.astype(\"float\") / cm.sum(axis=1, keepdims=True)\n",
        "\n",
        "# Get all unique cell types\n",
        "labels = sorted(adata_test.obs[class_label].unique())\n",
        "\n",
        "# Plot normalized confusion matrix\n",
        "plt.figure(figsize=(8, 6))\n",
        "sns.heatmap(cm_normalized, annot=True, fmt=\".2f\", xticklabels=labels, yticklabels=labels, cmap=\"Blues\")\n",
        "\n",
        "# Add labels and title\n",
        "plt.xlabel(\"Predicted\")\n",
        "plt.ylabel(\"True\")\n",
        "plt.title(\"Normalized Confusion Matrix (Row Percentage)\")\n",
        "plt.show()"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "### **Step 5: View Explainability**\n",
        "\n",
        "Interpreting machine learning models is critical, especially in biological research, where understanding why a model makes predictions can reveal important biological insights. SIMS uses TabNet's built-in explainability to identify which genes contribute most to its predictions.\n",
        "\n",
        "The explainability matrix assigns an importance score to each gene based on how much it influenced the model's classification decisions. This allows us to determine the top contributing genes and assess whether they align with known biological markers.\n",
        "\n",
        "#### `5.a` Generate the Explainability Matrix\n",
        "We will use `sims.explain()` to compute feature importance scores for each gene. This produces an explainability matrix, where each value represents how much a specific gene contributed to the model’s classification decision for a given cell. We then convert it to a pandas DataFrame for easy manipulation and compute the average importance score for each gene across all cells."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 37,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Computing explainability matrix ...\n"
          ]
        },
        {
          "name": "stderr",
          "output_type": "stream",
          "text": [
            "100%|██████████| 26/26 [00:02<00:00, 10.52it/s]\n"
          ]
        }
      ],
      "source": [
        "# Run explainability analysis\n",
        "explainability_matrix = sims.explain(adata_test, num_workers=0, batch_size=32)[0]\n",
        "\n",
        "# Convert explainability matrix to a DataFrame\n",
        "explain_df = pd.DataFrame(explainability_matrix, columns=sims.model.genes)\n",
        "\n",
        "# Compute average gene importance\n",
        "gene_importance = explain_df.mean(axis=0)"
      ]
    },
    {
      "cell_type": "markdown",
      "metadata": {},
      "source": [
        "#### `5.b` View most influential genes\n",
        "Now that we have computed gene importance scores, we can identify and print the top n most influential genes (the ones that contributed the most to the model’s classification decisions)."
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 38,
      "metadata": {},
      "outputs": [
        {
          "name": "stdout",
          "output_type": "stream",
          "text": [
            "Top 10 most important genes:\n",
            "Lsr         1.061564\n",
            "Ddx19b      0.953902\n",
            "Bcas3os1    0.895592\n",
            "Mgat5       0.885213\n",
            "Snord32a    0.871906\n",
            "Shtn1       0.844958\n",
            "Otulin      0.811020\n",
            "Ltn1        0.740239\n",
            "Ear1        0.432400\n",
            "Lsm5        0.336838\n",
            "dtype: float64\n"
          ]
        }
      ],
      "source": [
        "\n",
        "top10_genes = gene_importance.nlargest(10) # Can increase to top 20, 30, etc.\n",
        "print(\"Top 10 most important genes:\")\n",
        "print(top10_genes)"
      ]
    }
  ],
  "metadata": {
    "colab": {
      "provenance": []
    },
    "kernelspec": {
      "display_name": "Python (sims_env)",
      "language": "python",
      "name": "sims_env"
    },
    "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.9.18"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 0
}