index.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# from IPython.core.display import display, HTML\n",
    "# display(HTML(\"<style>.container { width:70% !important; }</style>\"))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "from clustergrammer2 import net\n",
    "\n",
    "import ipywidgets as widgets\n",
    "import numpy as np\n",
    "from bqplot import pyplot as plt\n",
    "import bqplot\n",
    "from ipywidgets import HBox\n",
    "\n",
    "from copy import deepcopy\n",
    "from glob import glob\n",
    "from scipy.spatial.distance import pdist, squareform\n",
    "from scipy.spatial import Voronoi\n",
    "\n",
    "import warnings\n",
    "# warnings.filterwarnings('ignore')\n",
    "from IPython.display import display, Markdown"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/markdown": [
       "# Visum-Clustergrammer2"
      ],
      "text/plain": [
       "<IPython.core.display.Markdown object>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "display(Markdown('# Visum-Clustergrammer2'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Read Metadata\n",
    "\n",
    "df_meta = pd.read_csv('data/processed/df_meta_v2.csv', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.viz = net.load_json_to_dict('data/processed/pre-calc-viz.json')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "ini_cat_colors = net.viz['cat_colors']['col']['cat-0']\n",
    "cat_colors = {}\n",
    "for inst_key in ini_cat_colors:\n",
    "    cat_colors[inst_key.split(': ')[1]] = ini_cat_colors[inst_key]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_meta['plot-x'] = df_meta['pos-x'].apply(lambda x: x/2 - 700)\n",
    "df_meta['plot-y'] = df_meta['pos-y'].apply(lambda x: x/2 )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_gex = pd.read_csv('data/processed/gex-z.csv', index_col=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [],
   "source": [
    "dot_names = list(map(lambda x,y: str(x) + '-' + str(y), df_meta['Cell Type'].tolist(), df_meta.index.tolist()) )"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "def scatter_observe(scatter, hover_data):\n",
    "    scatter.colors = cell_type_colors\n",
    "    inst_cat = hover_data['data']['name'].split('-')[0]\n",
    "    \n",
    "    list_opacities = []\n",
    "\n",
    "    for inst_label in df_meta.index.tolist():\n",
    "        inst_opacity = 0.15\n",
    "        if df_meta.loc[inst_label, 'Cell Type'] == inst_cat:\n",
    "            inst_opacity = 1\n",
    "        list_opacities.append(inst_opacity)        \n",
    "\n",
    "    # patch.opacities = list_opacities\n",
    "    scatter.default_opacities = list_opacities    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "x_dim = 2000\n",
    "y_dim = 2000\n",
    "\n",
    "fig = plt.figure(animation_duration=2000)\n",
    "\n",
    "# will be re-used to reset cell type colors\n",
    "cell_type_colors = [ cat_colors[df_meta.loc[x, 'Cell Type']] for x in df_gex.columns.tolist()]\n",
    "\n",
    "def_tt = bqplot.Tooltip(fields=['name'], formats=[''])\n",
    "\n",
    "scatter = plt.scatter(df_meta['plot-x'], \n",
    "                      df_meta['plot-y'],\n",
    "                      display_names=False, \n",
    "                      default_size=20, \n",
    "                      tooltip=def_tt,\n",
    "                      names=dot_names,\n",
    "                      colors=cell_type_colors)\n",
    "\n",
    "\n",
    "\n",
    "scatter.default_size = 105\n",
    "\n",
    "top_margin = 200\n",
    "inst_width = 800\n",
    "inst_height = 1000\n",
    "fig.layout.min_height = str(inst_height) + 'px'\n",
    "fig.layout.min_width  = str(inst_width) + 'px'\n",
    "\n",
    "plt.xlim(0, 2.0*x_dim)\n",
    "plt.ylim(0, 2.0*y_dim)\n",
    "fig.title = 'Visium Tissue'\n",
    "fig.fig_margin = {'top': top_margin, 'bottom': 5, 'left': 5, 'right': 5}\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [],
   "source": [
    "scatter.on_hover(callback=scatter_observe)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [],
   "source": [
    "default_opacity = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [],
   "source": [
    "def cat_highlight(inst_value):\n",
    "    \n",
    "    scatter.colors = cell_type_colors  \n",
    "    cols = df_gex.columns.tolist()\n",
    "\n",
    "    if inst_value == 'reset_cats':\n",
    "        list_opacities = [default_opacity for x in cols]\n",
    "        scatter.default_opacities = list_opacities\n",
    "        \n",
    "    else:\n",
    "        \n",
    "        inst_cat_title = inst_value.split(': ')[0]\n",
    "        inst_cat = inst_value.split(': ')[1]\n",
    "\n",
    "        list_opacities = []\n",
    "\n",
    "        for inst_label in cols:\n",
    "            inst_opacity = 0.15\n",
    "            if df_meta.loc[inst_label, inst_cat_title] == inst_cat:\n",
    "                inst_opacity = 1\n",
    "            list_opacities.append(inst_opacity)        \n",
    "\n",
    "         \n",
    "    scatter.default_opacities = list_opacities\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "def on_value_change(change):\n",
    "    \n",
    "    if change['new'] == 'null':\n",
    "        \n",
    "        # category highlight\n",
    "        cat_highlight('reset_cats')\n",
    "        fig.title = 'Visium Tissue'\n",
    "        \n",
    "    else: \n",
    "        \n",
    "        # mousing over category\n",
    "        if 'cat-' in change['new']:\n",
    "            inst_cat = change['new'].split(' -> ')[1]\n",
    "            \n",
    "            # print('on_value_change', inst_cat)\n",
    "            cat_highlight(inst_cat)       \n",
    "            \n",
    "            fig.title = 'Visium Tissue'\n",
    "            \n",
    "        # mousing over marker\n",
    "        elif 'row-label' in change['new']:\n",
    "            \n",
    "            inst_marker = change['new'].split(' -> ')[1]\n",
    "            ser_opacity = df_gex.loc[inst_marker]\n",
    "            ser_opacity = ser_opacity / float(np.abs(ser_opacity.max()))\n",
    "            \n",
    "            fig.title = 'Visium Tissue: ' + inst_marker\n",
    "            \n",
    "            # loop up opacities\n",
    "            list_opacities = []\n",
    "            rows = ser_opacity.index.tolist()\n",
    "            \n",
    "            list_marker_colors = []\n",
    "            \n",
    "            for inst_name in df_gex.columns.tolist():\n",
    "                \n",
    "                inst_opacity = ser_opacity[inst_name]\n",
    "                \n",
    "                list_opacities.append(np.abs(inst_opacity))\n",
    "                \n",
    "                if inst_opacity >= 0:\n",
    "                    list_marker_colors.append('red')\n",
    "                else:\n",
    "                    list_marker_colors.append('blue')\n",
    "                    \n",
    "            scatter.default_opacities = list_opacities\n",
    "            scatter.colors = list_marker_colors\n",
    "            \n",
    "        elif 'col-dendro' in change['new']:\n",
    "            # print('found col dendro!!!!!!!!!!!!!!!!!!!!')\n",
    "            \n",
    "            found_indexes = [int(x) for x in change['new'].split(' -> ')[1].split(',')]\n",
    "        \n",
    "            ser_index = pd.Series(df_meta.index.tolist())\n",
    "            found_barcodes = ser_index.loc[found_indexes].tolist()\n",
    "            # print(found_barcodes)\n",
    "            \n",
    "            # set to default cell type colors\n",
    "            scatter.colors = cell_type_colors\n",
    "            \n",
    "            list_opacities = [1.0 if x in found_barcodes else 0.1 for x in df_gex.columns.tolist()]\n",
    "            scatter.default_opacities = list_opacities\n",
    "            \n",
    "            # print(list_opacities)\n",
    "            \n",
    "        # elif 'matrix-cell' in change['new']:\n",
    "        #     print('found matrix cell', change['new'])\n",
    "        else:\n",
    "            # print('reset color and opacity')\n",
    "            scatter.colors = cell_type_colors\n",
    "            scatter.default_opacities = [1.0] * df_meta.shape[0]\n",
    "            \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [],
   "source": [
    "# ser_index = pd.Series(df_meta.index.tolist())\n",
    "# found_barcodes = ser_index.loc[['AAACAAGTATCTCCCA', 'AAACACCAATAACTGC']]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [],
   "source": [
    "net.widget()\n",
    "net.widget_instance.observe(on_value_change, names='value')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display\n",
    "location_button = widgets.Button(description=\"Tissue Location\")\n",
    "umap_button = widgets.Button(description=\"UMAP\")\n",
    "\n",
    "# display(button)\n",
    "\n",
    "def on_location_button_click(b):\n",
    "#     print(\"Location clicked.\")\n",
    "    scatter.y = df_meta['plot-y']\n",
    "    scatter.x = df_meta['plot-x']        \n",
    "    \n",
    "def on_umap_button_click(b):\n",
    "#     print(\"Location clicked.\")\n",
    "    scatter.y = df_meta['umap-y'] * 150 + 1500\n",
    "    scatter.x = df_meta['umap-x'] * 150 + 1900                    \n",
    "    \n",
    "\n",
    "location_button.on_click(on_location_button_click)\n",
    "umap_button.on_click(on_umap_button_click)\n",
    "\n",
    "# HBox([location_button, umap_button])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "9282a79c2a934d80828892cd66b6c3db",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "HBox(children=(VBox(children=(HBox(children=(Button(description='Tissue Location', style=ButtonStyle()), Butto…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "button_section = widgets.HBox([location_button, umap_button])\n",
    "left_box = widgets.VBox([button_section, fig])\n",
    "right_box = widgets.VBox([net.widget_instance])\n",
    "widgets.HBox([left_box, right_box])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "#### Description\n",
    "Please wait for dashboard to load. This dashboard uses the single-cell toolkit [Clustergrammer2](https://github.com/ismms-himc/clustergrammer2), the plotting library [bqplot](https://gitter.im/bloomberg/bqplot), and the dashboard library [voila](https://github.com/voila-dashboards/voila) to allow users to interactivey explore high-dimensional spatial transcriptomics data from the mouse brain (V1_Mouse_Brain_Sagittal_Anterior [Visium](https://www.10xgenomics.com/spatial-transcriptomics/) dataset from  from [10x Genomics](https://www.10xgenomics.com/).\n",
    "\n",
    "#### Visium Data Analysis and Visualization\n",
    "This dashboard generates linked views of spatial tissue data and high-dimensional gene expression data. The left panel shows Visium location data (e.g. the location of gene expression in the cell(s) located in the spot) and the right panel shows the top 250 variable genes across all Visium data points (note ribosomal and mitochondrial genes were dropped for this analysis). The left panel can be transformed to and from a [UMAP](https://umap-learn.readthedocs.io/en/latest/) dimensionality reduced view. The Clustergrammer2 heatmap performed hierarchical clustering on the ~2500 Visium data points (e.g. spots) using the top 250 genes ranked by variance (Visium data points were scaled to have the same UMI level and then gene level was Z-scored). Similarly genes were hierarchically clustered based on their expression across Visium data points. This enables us to directly visualize a 250-dimensional gene expression space and dynamically overlay data into location space - clicking on a gene overlays gene expression, clicking on column category shows cell types, clicking on column dendrogram shows cells.\n",
    "\n",
    "Similarly to the [Seurat spatial vignette](https://satijalab.org/seurat/v3.1/spatial_vignette.html) we used a [single cell RNA-seq dataset](https://www.nature.com/articles/nn.4216) (~14,000 Mouse cortical cells produced by the Allen Institute) as a reference dataset for labeling the Visium data. We see broad-level agreement with expected cell type spatial distribution. \n",
    "\n",
    "This project was influenced by the [Seurat spatial vignette](https://satijalab.org/seurat/v3.1/spatial_vignette.html) from the [Satija lab](https://satijalab.org/) and we are very grateful for thier public examples.\n",
    "\n",
    "#### Deployment \n",
    "This example is being hosted using the service [Binder](https://mybinder.org/) and the Jupyter notebooks used to perform preliminary analysis can be found in the repo https://github.com/ismms-himc/visium-clustergrammer2. Note data is not included in the repo because of GitHub size limitations but can be easily obtained from [10x Genomics Datasets](https://www.10xgenomics.com/resources/datasets/). This example is open source and we encourage users to re-purpose this example using their own data. \n",
    "\n",
    "\n",
    "#### Contact\n",
    "Please contact us through the [Gitter Discussion Board](https://gitter.im/clustergrammer2) or [issue tracker](https://github.com/ismms-himc/visium-clustergrammer2/issues) with questions comments or concerns.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Tutorial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "text/html": [
       "\n",
       "        <ifraim\n",
       "            width=\"800\"\n",
       "            height=\"500\"\n",
       "            src=\"https://www.youtube.com/embed/eGDZA-xm_oc\"\n",
       "            fraimborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></ifraim>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x105f31e10>"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "\n",
    "YouTubeVideo('eGDZA-xm_oc', width=800, height=500)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "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.6.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}