From 538e56afa9bfaac001868b7e7aa1367f419be61f Mon Sep 17 00:00:00 2001
From: Martin Proks <martin.proks@sund.ku.dk>
Date: Fri, 13 Sep 2024 10:38:51 +0200
Subject: [PATCH] docs: new api documentation

---
 docs/api.md                  |  32 +++-
 docs/conf.py                 |  12 +-
 docs/notebooks/Example.ipynb | 313 ++++++++++++++++++++++-------------
 3 files changed, 233 insertions(+), 124 deletions(-)

diff --git a/docs/api.md b/docs/api.md
index e223148..cde1922 100644
--- a/docs/api.md
+++ b/docs/api.md
@@ -1,5 +1,35 @@
 # API
 
+## scanvi_explainer
+
+### Utilities: `utils`
+
+```{eval-rst}
+.. currentmodule:: scanvi_explainer
+```
+
+```{eval-rst}
+.. autosummary::
+    :toctree: generated
+    :nosignatures:
+
+    utils.train_test_group_split
+```
+
+### Plots: `plots`
+
+```{eval-rst}
+.. currentmodule:: scanvi_explainer
+```
+
+```{eval-rst}
+.. autosummary::
+    :toctree: generated
+    :nosignatures:
+
+    plots.feature_plot
+```
+
 ## SCANVIDeep
 
 ```{eval-rst}
@@ -12,4 +42,4 @@
     :nosignatures:
 
     scanvi_deep
-```
\ No newline at end of file
+```
diff --git a/docs/conf.py b/docs/conf.py
index 156920a..209e1d5 100644
--- a/docs/conf.py
+++ b/docs/conf.py
@@ -84,10 +84,14 @@
 }
 
 intersphinx_mapping = {
-    "python": ("https://docs.python.org/3", None),
     "anndata": ("https://anndata.readthedocs.io/en/stable/", None),
-    "scanpy": ("https://scanpy.readthedocs.io/en/stable/", None),
+    "huggingface_hub": ("https://huggingface.co/docs/huggingface_hub/main/en", None),
+    "matplotlib": ("https://matplotlib.org/", None),
     "numpy": ("https://numpy.org/doc/stable/", None),
+    "pandas": ("https://pandas.pydata.org/docs/", None),
+    "python": ("https://docs.python.org/3", None),
+    "sklearn": ("https://scikit-learn.org/stable/", None),
+    "torch": ("https://pytorch.org/docs/master/", None),
 }
 
 # List of patterns, relative to source directory, that match files and
@@ -119,5 +123,5 @@
 nitpick_ignore = [
     # If building the documentation fails because of a missing link that is outside your control,
     # you can add an exception to this list.
-    #     ("py:class", "igraph.Graph"),
-]
\ No newline at end of file
+    ("optional"),
+]
diff --git a/docs/notebooks/Example.ipynb b/docs/notebooks/Example.ipynb
index 1da1fe4..879ced6 100644
--- a/docs/notebooks/Example.ipynb
+++ b/docs/notebooks/Example.ipynb
@@ -6,131 +6,62 @@
    "source": [
     "# scANVI Explainer demo\n",
     "\n",
-    "date: 12-09-2024\n",
+    "date: 13-09-2024\n",
     "\n",
     "author: Martin Proks"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 1,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "~/projects/data/Brickman/conda/envs/scvi-1.1.5/bin/pip\n"
+     ]
+    }
+   ],
    "source": [
     "!which pip"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 2,
    "metadata": {},
    "outputs": [],
    "source": [
     "import shap\n",
-    "import torch\n",
-    "import numpy as np\n",
-    "import pandas as pd\n",
-    "import seaborn as sns\n",
-    "import matplotlib.pyplot as plt\n",
-    "from anndata import AnnData\n",
     "from scvi.hub import HubModel\n",
-    "from scanvi_explainer import SCANVIDeep\n",
-    "from sklearn.model_selection import train_test_split\n",
-    "\n",
-    "import warnings\n",
-    "\n",
     "from numba.core.errors import NumbaDeprecationWarning\n",
-    "warnings.simplefilter('ignore', category=NumbaDeprecationWarning)\n",
-    "\n",
-    "\n",
-    "def train_test_group_split(adata: AnnData, groupby: str):\n",
-    "    \"\"\"\n",
-    "    Function to split anndata object 80/20 per group in format\n",
-    "    required for SCANVIDeep explainer.\n",
-    "    \"\"\"\n",
-    "    groups = adata.obs.groupby(groupby)\n",
-    "    train, test = [], []\n",
-    "    for _, cells in groups.groups.items():\n",
-    "        train_test = train_test_split(cells.values, test_size=0.2)\n",
-    "        \n",
-    "        train.append(train_test[0])\n",
-    "        test.append(train_test[1])\n",
-    "\n",
-    "    train, test = np.concatenate(train), np.concatenate(test)\n",
-    "\n",
-    "    X_train = {\n",
-    "        'X': torch.from_numpy(adata[train].layers['counts'].A).type(torch.DoubleTensor),\n",
-    "        'batch': torch.from_numpy(adata[train].obs.batch.cat.codes.values[:, np.newaxis]),\n",
-    "        'labels': torch.from_numpy(adata[train].obs.ct.cat.codes.values[:, np.newaxis])\n",
-    "    }\n",
-    "\n",
-    "    X_test = {\n",
-    "        'X': torch.from_numpy(adata[test].layers['counts'].A).type(torch.DoubleTensor),\n",
-    "        'batch': torch.from_numpy(adata[test].obs.batch.cat.codes.values[:, np.newaxis]),\n",
-    "        'labels': torch.from_numpy(adata[test].obs.ct.cat.codes.values[:, np.newaxis])\n",
-    "    }\n",
-    "    \n",
-    "    return X_train, X_test\n",
-    "\n",
-    "\n",
-    "def feature_plot(X_test, shap_values: np.ndarray, classes: pd.Index, features: np.ndarray, subset: bool = False):\n",
-    "    \"\"\"\n",
-    "    Prints feature contribution (absolute mean SHAP value) for each cell type (top 10).\n",
-    "\n",
-    "    X_test: \n",
-    "        test dataset\n",
-    "    shap_values: \n",
-    "        SHAP values\n",
-    "    classes: \n",
-    "        list of classifiers (cell types in this case)\n",
-    "    features: \n",
-    "        list of genes (HVGs)\n",
-    "    subset: \n",
-    "        If True calculate contribution by subsetting for test cells which belong to that particual classifier\n",
-    "        Else Be generic and return contributing features even when testing set has different cell types\n",
-    "    \"\"\"\n",
-    "    fig, ax = plt.subplots(8, 2, sharex=False, figsize=[20, 40])\n",
-    "    \n",
-    "    for idx, ct in enumerate(classes):\n",
-    "    \n",
-    "        shaps = pd.DataFrame(shap_values[idx], columns=features)\n",
-    "\n",
-    "        if subset:\n",
-    "            shaps['ct'] = X_test['labels']\n",
-    "            shaps = shaps.query('ct == @idx').iloc[:, :-1]\n",
     "\n",
-    "            tmp_avg = shaps\\\n",
-    "                .mean(axis=0)\\\n",
-    "                .sort_values(ascending=False)\\\n",
-    "                .reset_index()\\\n",
-    "                .rename(columns={'index':'feature',0:'weight'})\\\n",
-    "            \n",
-    "            positive = tmp_avg.query('weight > 0').head(5)\n",
-    "            negative = tmp_avg.query('weight < 0').tail(5)\n",
-    "\n",
-    "            avg = pd.concat([positive, negative])\n",
-    "            title = f'Mean(SHAP value average importance for: {ct}'\n",
-    "            \n",
-    "        else:\n",
-    "            avg = shaps\\\n",
-    "                .abs()\\\n",
-    "                .mean(axis=0)\\\n",
-    "                .sort_values(ascending=False)\\\n",
-    "                .reset_index()\\\n",
-    "                .rename(columns={'index':'feature',0:'weight'})\\\n",
-    "                .query('weight > 0')\\\n",
-    "                .head(10)\n",
-    "            title = f'Mean(|SHAP value|) average importance for: {ct}'\n",
-    "    \n",
-    "        sns.barplot(x='weight', y='feature', data=avg, ax=ax[idx // 2, idx % 2])\n",
-    "        ax[idx // 2, idx % 2].set_title(title)"
+    "import warnings\n",
+    "warnings.simplefilter('ignore', category=NumbaDeprecationWarning)"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 3,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "ec1c8cb52c134c028313cf16bd80d68b",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "Fetching 3 files:   0%|          | 0/3 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "hmo = HubModel.pull_from_huggingface_hub(\n",
     "    repo_name=\"brickmanlab/mouse-scanvi\",\n",
@@ -141,9 +72,71 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 4,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34mINFO    \u001b[0m Loading model\u001b[33m...\u001b[0m                                                                                          \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Trainer will use only 1 of 2 GPUs because it is running inside an interactive / notebook environment. You may try to set `Trainer(devices=2)` but please note that multi-GPU inside interactive / notebook environments is considered experimental and unstable. Your mileage may vary.\n"
+     ]
+    },
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\u001b[34mINFO    \u001b[0m File                                                                                                      \n",
+      "         \u001b[35m/tmp/mouse_scanvi/models--brickmanlab--mouse-scanvi/snapshots/122feddff5447c62e8a0b320650dbb6c7a1d764a/\u001b[0m\u001b[95mmod\u001b[0m\n",
+      "         \u001b[95mel.pt\u001b[0m already downloaded                                                                                  \n"
+     ]
+    },
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/home/fdb589/projects/data/Brickman/conda/envs/scvi-1.1.5/lib/python3.10/site-packages/lightning/fabric/plugins/environments/slurm.py:191: The `srun` command is available on your system but is not used. HINT: If your intention is to run Lightning on SLURM, prepend your python command with `srun` like so: srun python /home/fdb589/projects/data/Brickman/conda/envs/scvi- ...\n",
+      "/home/fdb589/projects/data/Brickman/conda/envs/scvi-1.1.5/lib/python3.10/site-packages/scvi/model/base/_utils.py:66: FutureWarning: You are using `torch.load` with `weights_only=False` (the current default value), which uses the default pickle module implicitly. It is possible to construct malicious pickle data which will execute arbitrary code during unpickling (See https://github.com/pytorch/pytorch/blob/main/SECURITY.md#untrusted-models for more details). In a future release, the default value for `weights_only` will be flipped to `True`. This limits the functions that could be executed during unpickling. Arbitrary objects will no longer be allowed to be loaded via this mode unless they are explicitly allowlisted by the user via `torch.serialization.add_safe_globals`. We recommend you start setting `weights_only=True` for any use case where you don't have full control of the loaded file. Please open an issue on GitHub for any issues related to this experimental feature.\n",
+      "  model = torch.load(model_path, map_location=map_location)\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">ScanVI Model with the following params: \n",
+       "unlabeled_category: Unknown, n_hidden: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">128</span>, n_latent: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">10</span>, n_layers: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">2</span>, dropout_rate: <span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0.1</span>, dispersion: gene, \n",
+       "gene_likelihood: nb\n",
+       "Training status: Trained\n",
+       "Model's adata is minified?: <span style=\"color: #ff0000; text-decoration-color: #ff0000; font-style: italic\">False</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "ScanVI Model with the following params: \n",
+       "unlabeled_category: Unknown, n_hidden: \u001b[1;36m128\u001b[0m, n_latent: \u001b[1;36m10\u001b[0m, n_layers: \u001b[1;36m2\u001b[0m, dropout_rate: \u001b[1;36m0.1\u001b[0m, dispersion: gene, \n",
+       "gene_likelihood: nb\n",
+       "Training status: Trained\n",
+       "Model's adata is minified?: \u001b[3;91mFalse\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
     "lvae = hmo.model\n",
     "lvae"
@@ -151,40 +144,111 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 11,
    "metadata": {},
    "outputs": [],
    "source": [
-    "background, test = train_test_group_split(lvae.adata, groupby='ct')"
+    "from scanvi_explainer import SCANVIDeep\n",
+    "from scanvi_explainer.plots import feature_plot"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 6,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "/maps/projects/dan1/data/Brickman/github/scanvi-explainer/src/scanvi_explainer/utils.py:104: UserWarning: The given NumPy array is not writable, and PyTorch does not support non-writable tensors. This means writing to this tensor will result in undefined behavior. You may want to copy the array to protect its data or make it writable before converting it to a tensor. This type of warning will be suppressed for the rest of this program. (Triggered internally at ../torch/csrc/utils/tensor_numpy.cpp:206.)\n",
+      "  REGISTRY_KEYS.BATCH_KEY: torch.from_numpy(\n"
+     ]
+    },
+    {
+     "data": {
+      "text/html": [
+       "<pre style=\"white-space:pre;overflow-x:auto;line-height:normal;font-family:Menlo,'DejaVu Sans Mono',consolas,'Courier New',monospace\">SCANVIDeep with the following parameters:\n",
+       "<span style=\"color: #808000; text-decoration-color: #808000\">train_size</span>=<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0.8</span>, <span style=\"color: #808000; text-decoration-color: #808000\">test_size</span>=<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">0.2</span>, <span style=\"color: #808000; text-decoration-color: #808000\">batch_size</span>=<span style=\"color: #008080; text-decoration-color: #008080; font-weight: bold\">128</span>, <span style=\"color: #808000; text-decoration-color: #808000\">labels_key</span>=<span style=\"color: #800080; text-decoration-color: #800080\">ct</span>, <span style=\"color: #808000; text-decoration-color: #808000\">layers_key</span>=<span style=\"color: #800080; text-decoration-color: #800080\">counts</span>\n",
+       "<span style=\"color: #808000; text-decoration-color: #808000\">training_on</span>=<span style=\"color: #800080; text-decoration-color: #800080\">cu</span><span style=\"color: #00ff00; text-decoration-color: #00ff00; font-weight: bold\">da</span><span style=\"color: #00ff00; text-decoration-color: #00ff00; font-weight: bold\">:0</span>\n",
+       "</pre>\n"
+      ],
+      "text/plain": [
+       "SCANVIDeep with the following parameters:\n",
+       "\u001b[33mtrain_size\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.8\u001b[0m, \u001b[33mtest_size\u001b[0m=\u001b[1;36m0\u001b[0m\u001b[1;36m.2\u001b[0m, \u001b[33mbatch_size\u001b[0m=\u001b[1;36m128\u001b[0m, \u001b[33mlabels_key\u001b[0m=\u001b[35mct\u001b[0m, \u001b[33mlayers_key\u001b[0m=\u001b[35mcounts\u001b[0m\n",
+       "\u001b[33mtraining_on\u001b[0m=\u001b[35mcu\u001b[0m\u001b[1;92mda\u001b[0m\u001b[1;92m:0\u001b[0m\n"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    },
+    {
+     "data": {
+      "text/plain": []
+     },
+     "execution_count": 6,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
    "source": [
-    "e = SCANVIDeep(lvae.module, background)"
+    "e = SCANVIDeep(lvae, train_size=0.8, batch_size=128)\n",
+    "e"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 7,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Allocated: 0.02 GB\n",
+      "Cached   : 0.04 GB\n",
+      "\n"
+     ]
+    },
+    {
+     "data": {
+      "application/vnd.jupyter.widget-view+json": {
+       "model_id": "7eafe5d2d84a4412b5680e5971d2ee73",
+       "version_major": 2,
+       "version_minor": 0
+      },
+      "text/plain": [
+       "  0%|          | 0/15 [00:00<?, ?it/s]"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "shap_values = e.shap_values(test)"
+    "shap_values = e.shap_values()"
    ]
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 8,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 800x950 with 1 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
     "shap.summary_plot(\n",
     "    shap_values, \n",
-    "    test['X'], \n",
+    "    e.test['X'], \n",
     "    feature_names=lvae.adata.var_names, \n",
     "    class_names=lvae.adata.obs.ct.cat.categories\n",
     ")"
@@ -192,11 +256,22 @@
   },
   {
    "cell_type": "code",
-   "execution_count": null,
+   "execution_count": 12,
    "metadata": {},
-   "outputs": [],
+   "outputs": [
+    {
+     "data": {
+      "image/png": "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",
+      "text/plain": [
+       "<Figure size 2000x4000 with 16 Axes>"
+      ]
+     },
+     "metadata": {},
+     "output_type": "display_data"
+    }
+   ],
    "source": [
-    "feature_plot(test, shap_values, classes=lvae.adata.obs.ct.cat.categories, features=lvae.adata.var_names, subset=True)"
+    "feature_plot(e, shap_values, subset=True, top_n=10)"
    ]
   },
   {
@@ -209,9 +284,9 @@
  ],
  "metadata": {
   "kernelspec": {
-   "display_name": "Python [conda env:conda-scvi-1.0.0]",
+   "display_name": "Python [conda env:conda-scvi-1.1.5]",
    "language": "python",
-   "name": "conda-env-conda-scvi-1.0.0-py"
+   "name": "conda-env-conda-scvi-1.1.5-py"
   },
   "language_info": {
    "codemirror_mode": {
@@ -223,7 +298,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.10.11"
+   "version": "3.10.13"
   }
  },
  "nbformat": 4,