notebooks/hlca_lung_gpu_analysis-visualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# GPU-accelerated interactive visualization of single cells with RAPIDS, Scanpy and Plotly Dash"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Copyright (c) 2020, NVIDIA CORPORATION.\n",
    "\n",
    "Licensed under the Apache License, Version 2.0 (the \"License\") you may not use this file except in compliance with the License. You may obtain a copy of the License at\n",
    "\n",
    "    http://www.apache.org/licenses/LICENSE-2.0 \n",
    "\n",
    "Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In this notebook, we cluster cells based on a single-cell RNA-seq count matrix, and produce an interactive visualization of the clustered cells that allows for further analysis of the data in a browser window."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For demonstration purposes, we use a dataset of ~70,000 human lung cells from Travaglini et al. 2020 (https://www.biorxiv.org/content/10.1101/742320v2) and label cells using the ACE2, TMPRSS2, and EPCAM marker genes. See the README for instructions to download this dataset."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import requirements"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scanpy as sc\n",
    "import anndata\n",
    "\n",
    "import sys\n",
    "import time\n",
    "\n",
    "import os, wget\n",
    "\n",
    "import cudf\n",
    "import cupy as cp\n",
    "\n",
    "from cuml.decomposition import PCA\n",
    "from cuml.manifold import TSNE\n",
    "from cuml.cluster import KMeans\n",
    "\n",
    "import rapids_scanpy_funcs\n",
    "\n",
    "import warnings\n",
    "warnings.filterwarnings('ignore', 'Expected ')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use the RAPIDS memory manager on the GPU to control how memory is allocated."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import rmm\n",
    "\n",
    "rmm.reinitialize(\n",
    "    managed_memory=True, # Allows oversubscription\n",
    "    pool_allocator=False, # default is False\n",
    "    devices=0, # GPU device IDs to register. By default registers only GPU 0.\n",
    ")\n",
    "\n",
    "cp.cuda.set_allocator(rmm.rmm_cupy_allocator)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Input data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the cell below, we provide the path to the `.h5ad` file containing the count matrix to analyze. Please see the README for instructions on how to download the dataset we use here.\n",
    "\n",
    "We recommend saving count matrices in the sparse .h5ad format as it is much faster to load than a dense CSV file. To run this notebook using your own dataset, please see the README for instructions to convert your own count matrix into this format. Then, replace the path in the cell below with the path to your generated `.h5ad` file."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "input_file = \"../data/krasnow_hlca_10x.sparse.h5ad\"\n",
    "\n",
    "if not os.path.exists(input_file):\n",
    "    print('Downloading import file...')\n",
    "    os.makedirs('../data', exist_ok=True)\n",
    "    wget.download('https://rapids-single-cell-examples.s3.us-east-2.amazonaws.com/krasnow_hlca_10x.sparse.h5ad',\n",
    "                  input_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Set parameters"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# marker genes\n",
    "RIBO_GENE_PREFIX = \"RPS\" # Prefix for ribosomal genes to regress out\n",
    "markers = [\"ACE2\", \"TMPRSS2\", \"EPCAM\"] # Marker genes for visualization\n",
    "\n",
    "# filtering cells\n",
    "min_genes_per_cell = 200 # Filter out cells with fewer genes than this expressed \n",
    "max_genes_per_cell = 6000 # Filter out cells with more genes than this expressed \n",
    "\n",
    "# filtering genes\n",
    "n_top_genes = 5000 # Number of highly variable genes to retain\n",
    "\n",
    "# PCA\n",
    "n_components = 50 # Number of principal components to compute\n",
    "\n",
    "# KNN\n",
    "n_neighbors = 15 # Number of nearest neighbors for KNN graph\n",
    "knn_n_pcs = 50 # Number of principal components to use for finding nearest neighbors\n",
    "\n",
    "# UMAP\n",
    "umap_min_dist = 0.3 \n",
    "umap_spread = 1.0"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Load and Prepare Data"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We load the sparse count matrix from an `h5ad` file using Scanpy. The sparse count matrix will then be placed on the GPU. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 3.79 s, sys: 760 ms, total: 4.55 s\n",
      "Wall time: 4.55 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "adata = sc.read(input_file)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(65662, 26485)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adata.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 736 ms, sys: 804 ms, total: 1.54 s\n",
      "Wall time: 1.54 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "genes = cudf.Series(adata.var_names)\n",
    "barcodes = cudf.Series(adata.obs_names)\n",
    "sparse_gpu_array = cp.sparse.csr_matrix(adata.X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Preprocessing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Filter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We filter the count matrix to remove cells with an extreme number of genes expressed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 608 ms, sys: 590 ms, total: 1.2 s\n",
      "Wall time: 1.2 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sparse_gpu_array, barcodes = rapids_scanpy_funcs.filter_cells(sparse_gpu_array, min_genes=min_genes_per_cell, max_genes=max_genes_per_cell, barcodes=barcodes)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Some genes will now have zero expression in all cells. We filter out such genes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 895 ms, sys: 229 ms, total: 1.12 s\n",
      "Wall time: 1.12 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sparse_gpu_array, genes = rapids_scanpy_funcs.filter_genes(sparse_gpu_array, genes, min_cells=1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The size of our count matrix is now reduced."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(65462, 22058)"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sparse_gpu_array.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Normalize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We normalize the count matrix so that the total counts in each cell sum to 1e4."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1 ms, sys: 0 ns, total: 1 ms\n",
      "Wall time: 1.21 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sparse_gpu_array = rapids_scanpy_funcs.normalize_total(sparse_gpu_array, target_sum=1e4)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next, we log transform the count matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 61.2 ms, sys: 39.2 ms, total: 100 ms\n",
      "Wall time: 100 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sparse_gpu_array = sparse_gpu_array.log1p()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Select Most Variable Genes"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We convert the count matrix to an annData object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 274 ms, sys: 169 ms, total: 442 ms\n",
      "Wall time: 441 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "adata = anndata.AnnData(sparse_gpu_array.get())\n",
    "adata.var_names = genes.to_pandas()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using scanpy, we filter the count matrix to retain only the 5000 most variable genes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.59 s, sys: 36.1 ms, total: 1.63 s\n",
      "Wall time: 1.63 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sc.pp.highly_variable_genes(adata, n_top_genes=n_top_genes, flavor=\"cell_ranger\")\n",
    "adata = adata[:, adata.var.highly_variable]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Regress out confounding factors (number of counts, ribosomal gene expression)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now perform regression on the count matrix to correct for confounding factors -  for example purposes, we use the number of counts and the expression of ribosomal genes. Many workflows use the expression of mitochondrial genes (named starting with `MT-`).\n",
    "\n",
    "Before regression, we save the 'raw' expression values of the ACE2 and TMPRSS2 genes to use for labeling cells afterward. We will also store the expression of an epithelial marker gene (EPCAM)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 431 ms, sys: 178 ms, total: 609 ms\n",
      "Wall time: 609 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "tmp_norm = sparse_gpu_array.tocsc()\n",
    "raw_marker_expressions = {}\n",
    "for marker in markers:\n",
    "    raw_marker_expressions[marker] = tmp_norm[:, genes[genes == marker].index[0]].todense().ravel()\n",
    "\n",
    "del tmp_norm"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We now calculate the total counts and the percentage of ribosomal counts for each cell."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 985 ms, sys: 80.3 ms, total: 1.07 s\n",
      "Wall time: 1.06 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "genes = adata.var_names\n",
    "ribo_genes = adata.var_names.str.startswith(RIBO_GENE_PREFIX)\n",
    "\n",
    "n_counts = adata.X.sum(axis=1)\n",
    "percent_ribo = (adata.X[:,ribo_genes].sum(axis=1) / n_counts).ravel()\n",
    "\n",
    "n_counts = cp.array(n_counts).ravel()\n",
    "percent_ribo = cp.array(percent_ribo).ravel()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And perform regression:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 49.3 s, sys: 21 s, total: 1min 10s\n",
      "Wall time: 1min 10s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sparse_gpu_array = cp.sparse.csc_matrix(adata.X)\n",
    "sparse_gpu_array = rapids_scanpy_funcs.regress_out(sparse_gpu_array, n_counts, percent_ribo)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Scale"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we scale the count matrix to obtain a z-score and apply a cutoff value of 10 standard deviations, obtaining the preprocessed count matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 153 ms, sys: 80.5 ms, total: 234 ms\n",
      "Wall time: 236 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sparse_gpu_array = rapids_scanpy_funcs.scale(sparse_gpu_array, max_value=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Cluster & Visualize"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We store the preprocessed count matrix as an AnnData object, which is currently in host memory. \n",
    "We also add the barcodes of the filtered cells, and the expression levels of the marker genes, to the annData object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 269 ms, sys: 280 ms, total: 549 ms\n",
      "Wall time: 548 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "\n",
    "adata = anndata.AnnData(sparse_gpu_array.get())\n",
    "adata.var_names = genes\n",
    "adata.obs_names = barcodes.to_pandas()\n",
    "for marker in markers:\n",
    "    adata.obs[marker + \"_raw\"] = raw_marker_expressions[marker].get()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Reduce"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We use PCA to reduce the dimensionality of the matrix to its top 50 principal components."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 1.28 s, sys: 421 ms, total: 1.7 s\n",
      "Wall time: 1.7 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "adata.obsm[\"X_pca\"] = PCA(n_components=n_components, output_type=\"numpy\").fit_transform(adata.X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### UMAP + Louvain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We visualize the cells using the UMAP algorithm in Rapids. Before UMAP, we need to construct a k-nearest neighbors graph in which each cell is connected to its nearest neighbors. This can be done conveniently using rapids functionality already integrated into Scanpy.\n",
    "\n",
    "Note that Scanpy uses an approximation to the nearest neighbors on the CPU while the GPU version performs an exact search. While both methods are known to yield useful results, some differences in the resulting visualization and clusters can be observed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/raid/cnolet/miniconda3/envs/genomics-viz/lib/python3.7/site-packages/numba/np/ufunc/parallel.py:355: NumbaWarning: The TBB threading layer requires TBB version 2019.5 or later i.e., TBB_INTERFACE_VERSION >= 11005. Found TBB_INTERFACE_VERSION = 10005. The TBB threading layer is disabled.\n",
      "  warnings.warn(problem)\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 17.4 s, sys: 1.33 s, total: 18.8 s\n",
      "Wall time: 4.41 s\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sc.pp.neighbors(adata, n_neighbors=n_neighbors, n_pcs=knn_n_pcs, method='rapids')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The UMAP function from Rapids is also integrated into Scanpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "WARNING: .obsp[\"connectivities\"] have not been computed using umap\n",
      "CPU times: user 514 ms, sys: 333 ms, total: 847 ms\n",
      "Wall time: 845 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sc.tl.umap(adata, min_dist=umap_min_dist, spread=umap_spread, method='rapids')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally, we use the Louvain algorithm for graph-based clustering, once again using the `rapids` option in Scanpy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/raid/cnolet/miniconda3/envs/genomics-viz/lib/python3.7/site-packages/cugraph/structure/graph.py:333: UserWarning: add_adj_list will be deprecated in next release. Use from_cudf_adjlist instead\n",
      "  Use from_cudf_adjlist instead')\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "CPU times: user 276 ms, sys: 40.1 ms, total: 316 ms\n",
      "Wall time: 315 ms\n"
     ]
    }
   ],
   "source": [
    "%%time\n",
    "sc.tl.louvain(adata, flavor='rapids')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We plot the cells using the UMAP visualization, using the Louvain clusters as labels."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "sc.pl.umap(adata, color=[\"louvain\"])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Defining re-clustering function for interactive visualization "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we have shown above, the speed of RAPIDS allows us to run steps like dimension reduction, clustering and visualization in seconds or even less. In the sections below, we create an interactive visualization that takes advantage of this speed by allowing users to cluster and analyze selected groups of cells at the click of a button."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First, we create a function named `re_cluster`. This function can be called on selected groups of cells. According to the function defined below, PCA, KNN, UMAP and Louvain clustering will be re-computed upon the selected cells. You can customize this function for your desired analysis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [],
   "source": [
    "def re_cluster(adata):\n",
    "    \n",
    "    #### Function to repeat clustering and visualization on subsets of cells\n",
    "    #### Runs PCA, KNN, UMAP and Louvain clustering on selected cells.\n",
    "    adata.obsm[\"X_pca\"] = PCA(n_components=n_components).fit_transform(adata.X).get()\n",
    "    sc.pp.neighbors(adata, n_neighbors=n_neighbors, n_pcs=knn_n_pcs, method='rapids')\n",
    "    sc.tl.umap(adata, min_dist=umap_min_dist, spread=umap_spread, method='rapids')\n",
    "    sc.tl.louvain(adata, flavor='rapids')\n",
    "\n",
    "    return adata"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Creating an interactive visualization with Plotly Dash"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<img src=\"https://github.com/avantikalal/rapids-single-cell-examples/blob/visualization/images/dashboard.png?raw=true\" alt=\"Interactive Dashboard\" width=\"400\"/>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below, we create the interactive visualization using the `adata` object and the re-clustering function defined above. To learn more about how this visualization is built, see `visualize.py`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you run the cell below, it returns a link. Click on this link to access the interactive visualization within your browser. \n",
    "\n",
    "Once opened, click the `Directions` button for instructions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Running on http://10.33.227.161:5000/\n",
      "Debugger PIN: 792-062-558\n",
      " * Serving Flask app \"visualize\" (lazy loading)\n",
      " * Environment: production\n",
      "\u001b[31m   WARNING: This is a development server. Do not use it in a production deployment.\u001b[0m\n",
      "\u001b[2m   Use a production WSGI server instead.\u001b[0m\n",
      " * Debug mode: on\n",
      "WARNING: .obsp[\"connectivities\"] have not been computed using umap\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/raid/cnolet/miniconda3/envs/genomics-viz/lib/python3.7/site-packages/cugraph/structure/graph.py:333: UserWarning:\n",
      "\n",
      "add_adj_list will be deprecated in next release. Use from_cudf_adjlist instead\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import visualize\n",
    "import importlib\n",
    "importlib.reload(visualize)\n",
    "\n",
    "v = visualize.Visualization(adata, markers, re_cluster_callback=re_cluster)\n",
    "v.start('10.33.227.161')\n",
    "\n",
    "selected_cells = v.new_df "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Within the dashboard, you can select cells using a variety of methods. You can then cluster, visualize and analyze the selected cells using the tools provided. Click on the `Directions` button for details. \n",
    "\n",
    "To export the selected cells and the results of your analysis back to the notebook, click the `Export to Dataframe` button. This exports the results of your analysis back to this notebook, and closes the interactive dashboard. \n",
    "\n",
    "See the next section for instructions on how to use the exported data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exporting a selection of cells from the dashboard"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If you exported a selection cells from the interactive visualization, your selection will be available here as a data frame named `selected_cells`. The `labels` column of this dataframe contains the newly generated cluster labels assigned to these selected cells."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(1356, 14)\n"
     ]
    },
    {
     "data": {
      "text/html": [
       "<div>\n",
       "<style scoped>\n",
       "    .dataframe tbody tr th:only-of-type {\n",
       "        vertical-align: middle;\n",
       "    }\n",
       "\n",
       "    .dataframe tbody tr th {\n",
       "        vertical-align: top;\n",
       "    }\n",
       "\n",
       "    .dataframe thead th {\n",
       "        text-align: right;\n",
       "    }\n",
       "</style>\n",
       "<table border=\"1\" class=\"dataframe\">\n",
       "  <thead>\n",
       "    <tr style=\"text-align: right;\">\n",
       "      <th></th>\n",
       "      <th>x</th>\n",
       "      <th>y</th>\n",
       "      <th>labels</th>\n",
       "      <th>ACE2</th>\n",
       "      <th>ACE2_labels</th>\n",
       "      <th>TMPRSS2</th>\n",
       "      <th>TMPRSS2_labels</th>\n",
       "      <th>EPCAM</th>\n",
       "      <th>EPCAM_labels</th>\n",
       "      <th>point_index</th>\n",
       "      <th>barcode</th>\n",
       "      <th>ACE2_val</th>\n",
       "      <th>TMPRSS2_val</th>\n",
       "      <th>EPCAM_val</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>2.019700</td>\n",
       "      <td>-2.356979</td>\n",
       "      <td>2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>2</td>\n",
       "      <td>1.497347</td>\n",
       "      <td>2</td>\n",
       "      <td>0</td>\n",
       "      <td>P2_7_GACCAATAGATGCCTT</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.5</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>2.373997</td>\n",
       "      <td>-2.072870</td>\n",
       "      <td>2</td>\n",
       "      <td>0.0</td>\n",
       "      <td>2</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>2</td>\n",
       "      <td>1.809904</td>\n",
       "      <td>2</td>\n",
       "      <td>1</td>\n",
       "      <td>P2_7_GTAACTGAGACTAAGT</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>2.568377</td>\n",
       "      <td>2.342024</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>1.062123</td>\n",
       "      <td>0</td>\n",
       "      <td>1.565488</td>\n",
       "      <td>0</td>\n",
       "      <td>2</td>\n",
       "      <td>P2_1_ACACCCTTCGTTTGCC</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.1</td>\n",
       "      <td>1.6</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>2.310712</td>\n",
       "      <td>-1.650501</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.000000</td>\n",
       "      <td>0</td>\n",
       "      <td>1.831406</td>\n",
       "      <td>0</td>\n",
       "      <td>3</td>\n",
       "      <td>P2_1_ACATCAGAGGCGATAC</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>1.8</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>2.190978</td>\n",
       "      <td>0.202274</td>\n",
       "      <td>0</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0</td>\n",
       "      <td>0.588000</td>\n",
       "      <td>0</td>\n",
       "      <td>0.588000</td>\n",
       "      <td>0</td>\n",
       "      <td>4</td>\n",
       "      <td>P2_1_ACATGGTGTTATTCTC</td>\n",
       "      <td>0.0</td>\n",
       "      <td>0.6</td>\n",
       "      <td>0.6</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "          x         y  labels  ACE2  ACE2_labels   TMPRSS2  TMPRSS2_labels  \\\n",
       "0  2.019700 -2.356979       2   0.0            2  0.000000               2   \n",
       "1  2.373997 -2.072870       2   0.0            2  0.000000               2   \n",
       "2  2.568377  2.342024       0   0.0            0  1.062123               0   \n",
       "3  2.310712 -1.650501       0   0.0            0  0.000000               0   \n",
       "4  2.190978  0.202274       0   0.0            0  0.588000               0   \n",
       "\n",
       "      EPCAM  EPCAM_labels  point_index                barcode  ACE2_val  \\\n",
       "0  1.497347             2            0  P2_7_GACCAATAGATGCCTT       0.0   \n",
       "1  1.809904             2            1  P2_7_GTAACTGAGACTAAGT       0.0   \n",
       "2  1.565488             0            2  P2_1_ACACCCTTCGTTTGCC       0.0   \n",
       "3  1.831406             0            3  P2_1_ACATCAGAGGCGATAC       0.0   \n",
       "4  0.588000             0            4  P2_1_ACATGGTGTTATTCTC       0.0   \n",
       "\n",
       "   TMPRSS2_val  EPCAM_val  \n",
       "0          0.0        1.5  \n",
       "1          0.0        1.8  \n",
       "2          1.1        1.6  \n",
       "3          0.0        1.8  \n",
       "4          0.6        0.6  "
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "print(selected_cells.shape)\n",
    "selected_cells.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "You can link the selected cells to the original `adata` object using the cell barcodes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [],
   "source": [
    "adata_selected_cells = adata[selected_cells.barcode.to_array(),:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "View of AnnData object with n_obs × n_vars = 1356 × 5000\n",
       "    obs: 'ACE2_raw', 'TMPRSS2_raw', 'EPCAM_raw', 'louvain'\n",
       "    uns: 'neighbors', 'umap', 'louvain'\n",
       "    obsm: 'X_pca', 'X_umap'\n",
       "    obsp: 'distances', 'connectivities'"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "adata_selected_cells"
   ]
  }
 ],
 "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.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}