visualization.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# COBRE Schizophrenia Data Visualization"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Welcome!\n",
    "This notebook contains some interactive visualizations of the data from the COBRE dataset available on Nilearn. Run the whole notebook to start the visualizations and use the drop-down menus to toggle between Schizophrenia Patients and Controls.\n",
    "\n",
    "**Note**: The call to the data below will load only 30 subjects in interest of time. If you would like to load more, change the `n_subjects` parameter. If you would like to load all 146, set this parameter to 'None'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/home/aalbury/miniconda3/lib/python3.7/site-packages/numpy/lib/npyio.py:2372: VisibleDeprecationWarning: Reading unicode strings without specifying the encoding argument is deprecated. Set the encoding, use None for the system default.\n",
      "  output = genfromtxt(fname, **kwargs)\n"
     ]
    }
   ],
   "source": [
    "#import data\n",
    "from nilearn import datasets\n",
    "data = datasets.fetch_cobre(n_subjects=30)\n",
    "\n",
    "#import atlas\n",
    "parcellations = datasets.fetch_atlas_basc_multiscale_2015(version='sym')\n",
    "atlas_filename = parcellations.scale064"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [],
   "source": [
    "#import phenotypic data\n",
    "import pandas\n",
    "pheno = pandas.DataFrame(data.phenotypic)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "#extract participant id from file paths\n",
    "file_names = []\n",
    "for path in data.func:\n",
    "    #note the string slicing below is not best practice and will need to change if file paths change\n",
    "    file_names.append(path[39:44])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "#create dataframe of file paths and ids\n",
    "files = pandas.DataFrame(data.func, columns = ['path'])\n",
    "files['id'] = file_names\n",
    "files['id'] = files.id.astype(int)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "#merge phenotypic data with file paths\n",
    "import pandas\n",
    "pheno = pandas.merge(pheno, files, on = 'id')\n",
    "\n",
    "#fix string decoding\n",
    "pheno['gender'] = pheno['gender'].map(lambda x: x.decode('utf-8'))\n",
    "pheno['handedness'] = pheno['handedness'].map(lambda x: x.decode('utf-8'))\n",
    "pheno['subject_type'] = pheno['subject_type'].map(lambda x: x.decode('utf-8'))\n",
    "pheno['diagnosis'] = pheno['diagnosis'].map(lambda x: x.decode('utf-8'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pandas as pd\n",
    "\n",
    "#create lists of filepaths for patients and controls\n",
    "patients = []\n",
    "controls = []\n",
    "\n",
    "for i in pheno.index:\n",
    "    if pheno.loc[i, 'subject_type']=='Patient':\n",
    "    \n",
    "        patients.append(pheno.loc[i, 'path'])\n",
    "    else:\n",
    "        controls.append(pheno.loc[i, 'path'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The cell below generates a plotly express app to show the age distribution of subjects in the data. Use the dropdown box to select between Patients and Controls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"800\"\n",
       "            height=\"650\"\n",
       "            src=\"http://127.0.0.1:8050/\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.IFrame at 0x7f11d4c1e450>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "import plotly.express as px\n",
    "from jupyter_dash import JupyterDash\n",
    "import dash_core_components as dcc\n",
    "import dash_html_components as html\n",
    "from dash.dependencies import Input, Output\n",
    "# Load Data\n",
    "df = pheno\n",
    "# Build App\n",
    "app = JupyterDash(__name__)\n",
    "app.layout = html.Div([\n",
    "    html.H1(\"Age\"),\n",
    "    dcc.Graph(id='graph'),\n",
    "    html.Label([\n",
    "        \"Participant type\",\n",
    "        dcc.Dropdown(\n",
    "            id='subject_type', clearable=False,\n",
    "            value='Patient', options=[\n",
    "                {'label': c, 'value': c}\n",
    "                for c in df.subject_type.unique() #get all unique values from column\n",
    "            ])\n",
    "    ]),\n",
    "])\n",
    "# Define callback to update graph\n",
    "@app.callback(\n",
    "    Output('graph', 'figure'),\n",
    "    [Input(\"subject_type\", \"value\")]\n",
    ")\n",
    "def update_figure(subject_type):\n",
    "    return px.histogram(\n",
    "        df[df[\"subject_type\"]==subject_type], x=\"current_age\", color=\"gender\"\n",
    "        \n",
    "    )\n",
    "# Run app and display result inline in the notebook\n",
    "app.run_server(mode='inline')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# function to plot average correlation matrix by subject type (Patient vs. Control)\n",
    "def corr_matrix(subset):\n",
    "\n",
    "    from nilearn.input_data import NiftiLabelsMasker\n",
    "    from nilearn.connectome import ConnectivityMeasure\n",
    "\n",
    "    func = []\n",
    "    conf = []\n",
    "\n",
    "    for i in range(len(data.func)):\n",
    "        if data.func[i] in subset:\n",
    "            func.append(data.func[i])\n",
    "\n",
    "            conf.append(data.confounds[i])\n",
    "\n",
    "    # ConenctivityMeasure from Nilearn uses simple 'correlation' to compute\n",
    "    # connectivity matrices for all subjects in a list\n",
    "    connectome_measure = ConnectivityMeasure(kind='correlation')\n",
    "\n",
    "    # useful for plotting connectivity interactions on glass brain\n",
    "    from nilearn import plotting\n",
    "\n",
    "    # create masker to extract functional data within atlas parcels\n",
    "    masker = NiftiLabelsMasker(labels_img=atlas_filename, \n",
    "                               standardize=True, \n",
    "                               memory='nilearn_cache', \n",
    "                               verbose=0)\n",
    "    # extract time series from all subjects and concatenate them\n",
    "    time_series = []\n",
    "    for func, confounds in zip(func, conf):\n",
    "        time_series.append(masker.fit_transform(func, confounds=confounds))\n",
    "    # calculate correlation matrices across subjects\n",
    "    correlation_matrices = connectome_measure.fit_transform(time_series)\n",
    "\n",
    "    # Mean correlation matrix across all subjects\n",
    "    mean_correlation_matrix = connectome_measure.mean_\n",
    "\n",
    "    # grab center coordinates for atlas labels\n",
    "    coordinates = plotting.find_parcellation_cut_coords(labels_img=atlas_filename)\n",
    "\n",
    "    import numpy as np\n",
    "    # Mask the main diagonal\n",
    "    np.fill_diagonal(mean_correlation_matrix, 0)\n",
    "\n",
    "    plotting.plot_matrix(mean_correlation_matrix, figure=(10, 8),\n",
    "                         vmax=0.8, vmin=-0.8, reorder=False, tri='lower')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Use the dropdown menu below to view an average correlation matrix for schizophrenia patients and healthy controls."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "application/vnd.jupyter.widget-view+json": {
       "model_id": "5462bf46740b493a8320b48edef6c477",
       "version_major": 2,
       "version_minor": 0
      },
      "text/plain": [
       "interactive(children=(Dropdown(description='subset', options=(('Patients', ['/home/aalbury/nilearn_data/cobre/…"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from ipywidgets import interact\n",
    "\n",
    "interact(corr_matrix, subset=[('Patients', patients), ('Controls', controls)]);"
   ]
  },
  {
   "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.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}