code/07_functional-connectivity-analysis.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introduction\n",
    "\n",
    "Now we have an idea of three important components to analyzing neuroimaging data:\n",
    "\n",
    "1. Data manipulation\n",
    "2. Cleaning and confound regression\n",
    "3. Parcellation and signal extraction\n",
    "\n",
    "In this notebook the goal is to integrate these 3 basic components and perform a full analysis of group data using **Intranetwork Functional Connectivity (FC)**.\n",
    "\n",
    "Intranetwork functional connectivity is essentially a result of performing correlational analysis on mean signals extracted from two ROIs. Using this method we can examine how well certain resting state networks, such as the **Default Mode Network (DMN)**, are synchronized across spatially distinct regions.\n",
    "\n",
    "ROI-based correlational analysis forms the basis of many more sophisticated kinds of functional imaging analysis.\n",
    "\n",
    "## Using Nilearn's High-level functionality to compute correlation matrices\n",
    "\n",
    "Nilearn has a built in function for extracting timeseries from functional files and doing all the extra signal processing at the same time. Let's walk through how this is done\n",
    "\n",
    "First we'll grab our imports as usual\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nilearn import image as nimg\n",
    "from nilearn import plotting as nplot\n",
    "import numpy as np\n",
    "import pandas as pd\n",
    "from bids import BIDSLayout"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's grab the data that we want to perform our connectivity analysis on using PyBIDS:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Use PyBIDS to parse BIDS data structure\n",
    "fmriprep_dir = \"../data/ds000030/derivatives/fmriprep/\"\n",
    "layout = BIDSLayout(fmriprep_dir,\n",
    "                   config=['bids','derivatives'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Get resting state data (preprocessed, mask, and confounds file)\n",
    "func_files = layout.get(datatype='func', task='rest',\n",
    "                        desc='preproc',\n",
    "                        space='MNI152NLin2009cAsym',\n",
    "                        extension='nii.gz',\n",
    "                        return_type='file')\n",
    "\n",
    "mask_files = layout.get(datatype='func', task='rest',\n",
    "                        desc='brain',\n",
    "                        suffix=\"mask\",\n",
    "                        space='MNI152NLin2009cAsym',\n",
    "                        extension='nii.gz',\n",
    "                        return_type='file')\n",
    "\n",
    "confound_files = layout.get(datatype='func',\n",
    "                            task='rest',\n",
    "                            desc='confounds',\n",
    "                            extension='tsv',\n",
    "                            return_type='file')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we have a list of subjects to peform our analysis on, let's load up our parcellation template file\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Load separated parcellation\n",
    "parcel_file = '../resources/rois/yeo_2011/Yeo_JNeurophysiol11_MNI152/relabeled_yeo_atlas.nii.gz'\n",
    "yeo_7 = nimg.load_img(parcel_file)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll import a package from <code>nilearn</code>, called <code>input_data</code> which allows us to pull data using the parcellation file, and at the same time applying data cleaning!\n",
    "\n",
    "We first create an object using the parcellation file <code>yeo_7</code> and our cleaning settings which are the following:\n",
    "\n",
    "Settings to use:\n",
    "- Confounds: trans_x, trans_y, trans_z, rot_x, rot_y, rot_z, white_matter, csf, global_signal\n",
    "- Temporal Derivatives: Yes\n",
    "- high_pass = 0.009\n",
    "- low_pass = 0.08\n",
    "- detrend = True\n",
    "- standardize = True"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The object <code>masker</code> is now able to be used on *any functional image of the same size*. The `input_data.NiftiLabelsMasker` object is a wrapper that applies parcellation, cleaning and averaging to an functional image. For example let's apply this to our first subject:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Pull the first subject's data\n",
    "func_file = func_files[0]\n",
    "mask_file = mask_files[0]\n",
    "confound_file = confound_files[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Before we go ahead and start using the <code>masker</code> that we've created, we have to do some preparatory steps. The following should be done prior to use the <code>masker</code> object:\n",
    "1. Make your confounds matrix (as we've done in Episode 06)\n",
    "2. Drop Dummy TRs that are to be excluded from our cleaning, parcellation, and averaging step\n",
    "\n",
    "To help us with the first part, let's define a function to help extract our confound regressors from the .tsv file for us. Note that we've handled pulling the appropriate `{confounds}_derivative1` columns for you! You just need to supply the base regressors!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Refer to part_06 for code + explanation\n",
    "def extract_confounds(confound_tsv,confounds,dt=True):\n",
    "    '''\n",
    "    Arguments:\n",
    "        confound_tsv                    Full path to confounds.tsv\n",
    "        confounds                       A list of confounder variables to extract\n",
    "        dt                              Compute temporal derivatives [default = True]\n",
    "        \n",
    "    Outputs:\n",
    "        confound_mat                    \n",
    "    '''\n",
    "    \n",
    "    if dt:    \n",
    "        dt_names = ['{}_derivative1'.format(c) for c in confounds]\n",
    "        confounds = confounds + dt_names\n",
    "    \n",
    "    #Load in data using Pandas then extract relevant columns\n",
    "    confound_df = pd.read_csv(confound_tsv,delimiter='\\t') \n",
    "    confound_df = confound_df[confounds]\n",
    "    \n",
    " \n",
    "    #Convert into a matrix of values (timepoints)x(variable)\n",
    "    confound_mat = confound_df.values \n",
    "    \n",
    "    #Return confound matrix\n",
    "    return confound_mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we'll set up our image file for confound regression (as we did in Episode 6). To do this we'll drop 4 TRs from *both our functional image and our confounds file*. Note that our <code>masker</code> object will not do this for us!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Load functional image\n",
    "\n",
    "\n",
    "#Remove the first 4 TRs\n",
    "\n",
    "\n",
    "#Use the above function to pull out a confound matrix\n",
    "\n",
    "\n",
    "#Drop the first 4 rows of the confounds matrix\n",
    " "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Using the masker\n",
    "Finally with everything set up, we can now use the masker to perform our:\n",
    "1. Confounds cleaning\n",
    "2. Parcellation\n",
    "3. Averaging within a parcel\n",
    "All in one step!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Apply cleaning, parcellation and extraction to functional data\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Just to be clear, this data is *automatically parcellated for you, and, in addition, is cleaned using the confounds you've specified!*\n",
    "\n",
    "The result of running <code>masker.fit_transform</code> is a matrix that has:\n",
    "- Rows matching the number of timepoints (148)\n",
    "- Columns, each for one of the ROIs that are extracted (43)\n",
    "\n",
    "**But wait!**\n",
    "\n",
    "We originally had **50 ROIs**, what happened to 7 of them? It turns out that <code>masker</code> drops ROIs that are empty (i.e contain no brain voxels inside of them), this means that 7 of our atlas' parcels did not correspond to any region with signal! To see which ROIs are kept after computing a parcellation you can look at the <code>labels_</code> property of <code>masker</code>:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(masker.labels_)\n",
    "print(\"Number of labels\", len(masker.labels_))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This means that our ROIs of interest (44 and 46) *cannot be accessed using the 44th and 46th columns directly*!\n",
    "\n",
    "There are many strategies to deal with this weirdness. What we're going to do is to create a new array that fills in the regions that were removed with <code>0</code> values. It might seem a bit weird now, but it'll simplify things when we start working with multiple subjects!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "First we'll identify all ROIs from the original atlas. We're going to use the <code>numpy</code> package which will provide us with functions to work with our image arrays:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Get the label numbers from the atlas\n",
    "\n",
    "\n",
    "# Get number of labels that we have\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we're going to create an array that contains:\n",
    "- A number of rows matching the number of timepoints\n",
    "- A number of columns matching the total number of regions"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Remember fMRI images are of size (x,y,z,t)\n",
    "# where t is the number of timepoints\n",
    "\n",
    "\n",
    "# Create an array of zeros that has the correct size\n",
    "\n",
    "\n",
    "# Get regions that are kept\n",
    "\n",
    "\n",
    "# Fill columns matching labels with signal values\n",
    "\n",
    "\n",
    "print(final_signal.shape)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "It's a bit of work, but now we have an array where:\n",
    "\n",
    "1. The column number matches the ROI label number\n",
    "2. Any column that is lost during the <code>masker.fit_transform</code> is filled with <code>0</code> values!\n",
    "\n",
    "\n",
    "To get the columns corresponding to the regions that we've kept, we can simply use the <code>regions_kept</code> variable to select columns corresponding to the regions that weren't removed:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is identical to the original output of <code>masker.fit_transform</code>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This might seem unnecessary for now, but as you'll see in a bit, it'll come in handy when we deal with multiple subjects!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Calculating Connectivity\n",
    "\n",
    "In fMRI imaging, connectivity typically refers to the *correlation of the timeseries of 2 ROIs*. Therefore we can calculate a *full connectivity matrix* by computing the correlation between *all pairs of ROIs* in our parcellation scheme! \n",
    "\n",
    "We'll use another nilearn tool called <code>ConnectivityMeasure</code> from <code>nilearn.connectome</code>. This tool will perform the full set of pairwise correlations for us"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Like the masker, we need to make an object that will calculate connectivity for us."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Try using <code>SHIFT-TAB</code> to see what options you can put into the <code>kind</code> argument of <code>ConnectivityMeasure</code>\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Then we use <code>correlation_measure.fit_transform()</code> in order to calculate the full correlation matrix for our parcellated data!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that we're using a list <code>[final_signal]</code>, this is because <code>correlation_measure</code> works on a *list of subjects*. We'll take advantage of this later!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "\n",
    "The result is a matrix which has:\n",
    "\n",
    "- A number of rows matching the number of ROIs in our parcellation atlas\n",
    "- A number of columns, that also matches the number of ROIs in our parcellation atlas\n",
    "\n",
    "You can read this correlation matrix as follows:\n",
    "\n",
    "Suppose we wanted to know the correlation between ROI 30 and ROI 40\n",
    "\n",
    "- Then Row 30, Column 40 gives us this correlation.\n",
    "- Row 40, Column 40 can also give us this correlation\n",
    "\n",
    "\n",
    "This is because the correlation of $A \\to B = B \\to A$\n",
    "\n",
    "***\n",
    "\n",
    "**NOTE**\n",
    "\n",
    "Remember we were supposed to lose 7 regions from the <code>masker.fit_transform</code> step. The correlations for these regions will be 0!\n",
    "\n",
    "***"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's try pulling the correlation for ROI 44 and 46!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that it'll be the same if we swap the rows and columns!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Exercise"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Apply the data extract process shown above to all subjects in our subject list and collect the results. Your job is to fill in the blanks!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# First we're going to create some empty lists to store all our data in!\n",
    "ctrl_subjects = []\n",
    "schz_subjects = []\n",
    "\n",
    "\n",
    "# We're going to keep track of each of our subjects labels here\n",
    "# pulled from masker.labels_\n",
    "labels_list = []\n",
    "\n",
    "# Get the number of unique labels in our parcellation\n",
    "# We'll use this to figure out how many columns to make (as we did earlier)\n",
    "atlas_labels = np.unique(yeo_7.get_fdata().astype(int))\n",
    "NUM_LABELS = len(atlas_labels)\n",
    "\n",
    "# Set the list of confound variables we'll be using\n",
    "confound_variables = ['trans_x','trans_y','trans_z',\n",
    "                               'rot_x','rot_y','rot_z',\n",
    "                               'global_signal',\n",
    "                               'white_matter','csf']\n",
    "\n",
    "# Number of TRs we should drop\n",
    "TR_DROP=4\n",
    "\n",
    "# Lets get all the subjects we have\n",
    "subjects = layout.get_subjects()\n",
    "for sub in subjects:\n",
    "    \n",
    "    #Get the functional file for the subject (MNI space)\n",
    "    func_file = layout.get(subject=??,\n",
    "                           datatype='??', task='rest',\n",
    "                           desc='??',\n",
    "                           space='??'\n",
    "                           extension=\"nii.gz\",\n",
    "                           return_type='file')[0]\n",
    "    \n",
    "    #Get the confounds file for the subject (MNI space)\n",
    "    confound_file=layout.get(subject=??, datatype='??',\n",
    "                             task='rest',\n",
    "                             desc='??',\n",
    "                             extension='tsv',\n",
    "                             return_type='file')[0]\n",
    "    \n",
    "    #Load the functional file in\n",
    "    func_img = nimg.load_img(??)\n",
    "    \n",
    "    #Drop the first 4 TRs\n",
    "    func_img = func_img.slicer[??,??,??,??]\n",
    "    \n",
    "    \n",
    "    #Extract the confound variables using the function\n",
    "    confounds = extract_confounds(confound_file,\n",
    "                                  confound_variables)\n",
    "    \n",
    "    #Drop the first 4 rows from the confound matrix\n",
    "    confounds = confounds[??]\n",
    "    \n",
    "    # Make our array of zeros to fill out\n",
    "    # Number of rows should match number of timepoints\n",
    "    # Number of columns should match the total number of regions\n",
    "    fill_array = np.zeros((func_img.shape[??], ??))\n",
    "    \n",
    "    #Apply the parcellation + cleaning to our data\n",
    "    #What function of masker is used to clean and average data?\n",
    "    time_series = masker.fit_transform(??,??)\n",
    "    \n",
    "    # Get the regions that were kept for this scan\n",
    "    regions_kept = np.array(masker.labels_)\n",
    "    \n",
    "    # Fill the array, this is what we'll use\n",
    "    # to make sure that all our array are of the same size\n",
    "    fill_array[:, ??] = time_series\n",
    "    \n",
    "    #If the subject ID starts with a \"1\" then they are control\n",
    "    if sub.startswith('1'):\n",
    "        ctrl_subjects.append(fill_array)\n",
    "    #If the subject ID starts with a \"5\" then they are case (case of schizophrenia)\n",
    "    if sub.startswith('5'):\n",
    "        schz_subjects.append(fill_array)\n",
    "        \n",
    "    labels_list.append(masker.labels_)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result of all of this code is that:\n",
    "\n",
    "1. Subjects who start with a \"1\" in their ID, are controls, and are placed into the `ctrl_subjects` list\n",
    "2. Subjects who start with a \"2\" in their ID, have schizophrenia, and are placed into the `schz_subjects` list\n",
    "\n",
    "What's actually being placed into the list? The cleaned, parcellated time series data for each subject (the output of <code>masker.fit_transform</code>)!\n",
    "\n",
    "A helpful trick is that we can re-use the <code>correlation_measure</code> object we made earlier and apply it to a *list of subject data*! "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "At this point, we have correlation matrices for each subject across two populations. The final step is to examine the differences between these groups in their correlation between ROI 44 and ROI 46.\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Visualizing Correlation Matrices and Group Differences\n",
    "\n",
    "An important step in any analysis is visualizing the data that we have. We've cleaned data, averaged data and calculated correlations but we don't actually know what it looks like! Visualizing data is important to ensure that we don't throw pure nonsense into our final statistical analysis\n",
    "\n",
    "To visualize data we'll be using a python package called <code>seaborn</code> which will allow us to create statistical visualizations with not much effort.\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns\n",
    "import matplotlib.pyplot as plt"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can view a single subject's correlation matrix by using <code>seaborn</code>'s <code>heatmap</code> function:\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Recall that cleaning and parcellating the data causes some ROIs to get dropped. We dealt with this by filling an array of zeros (<code>fill_array</code>) only for columns where the regions are kept (<code>regions_kept</code>). This means that we'll have some correlation values that are 0!\n",
    "\n",
    "This is more apparent if we plot the data slightly differently. For demonstrative purposes we've:\n",
    "- Taken the absolute value of our correlations so that the 0's are the darkest color\n",
    "- Used a different color scheme"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.heatmap(np.abs(ctrl_correlation_matrices[0]), cmap='viridis')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dark lines in the correlation matrix correspond to regions that were dropped and therefore have 0 correlation!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can now pull our ROI 44 and 46 by indexing our list of correlation matrices as if it were a 3D array (kind of like an MR volume). Take a look at the shape:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is of form:\n",
    "\n",
    "<code>ctrl_correlation_matrices[subject_index, row_index, column_index]</code>\n",
    "\n",
    "Now we're going to pull out just the correlation values between ROI 44 and 46 *across all our subjects*. This can be done using standard array indexing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Next we're going to arrange this data into a table. We'll create two tables (called dataframes in the python package we're using, `pandas`)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Create control dataframe\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Create the schizophrenia dataframe\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The result is:\n",
    "\n",
    "- `ctrl_df` a table containing the correlation value for each control subject, with an additional column with the group label, which is 'control'\n",
    "\n",
    "- `scz_df` a table containing the correlation value for each schizophrenia group subject, with an additional column with the group label, which is 'schizophrenia'\n",
    "\n",
    "For visualization we're going to stack the two tables together..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Stack the two dataframes together\n",
    "\n",
    "# Show some random samples from dataframe\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Finally we're going to visualize the results using the python package `seaborn`!\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#Visualize results\n",
    "\n",
    "# Create a figure canvas of equal width and height\n",
    "\n",
    "                  \n",
    "# Create a box plot, with the x-axis as group\n",
    "#the y-axis as the correlation value\n",
    "\n",
    "\n",
    "# Create a \"swarmplot\" as well, you'll see what this is..\n",
    "\n",
    "\n",
    "# Set the title and labels of the figure\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Although the results here aren't significant they seem to indicate that there might be three subclasses in our schizophrenia group - of course we'd need *a lot* more data to confirm this! The interpretation of these results should ideally be based on some *a priori* hypothesis! \n",
    "\n",
    "\n",
    "## Congratulations!\n",
    "\n",
    "Hopefully now you understand that:\n",
    "\n",
    "1. fMRI data needs to be pre-processed before analyzing\n",
    "2. Manipulating images in python is easily done using `nilearn` and `nibabel`\n",
    "3. You can also do post-processing like confound/nuisance regression using `nilearn`\n",
    "4. Parcellating is a method of simplifying and \"averaging\" data. The type of parcellation reflect assumptions you make about the structure of your data\n",
    "5. Functional Connectivity is really just time-series correlations between two signals!"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.8.0"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}