blp-analysis-functional-mri-functional-connectivity.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "d000a44f",
   "metadata": {},
   "source": [
    "# Brainlife analyses using Jupyter Notebooks and Python3\n",
    "\n",
    "This example notebook will guide the user through grabbing data for their project from the secondary warehouse, compiling data across the entire project, and analyzing and visualizing the compiled results on brainlife.io via the 'Analysis' tab. This example is written for python3, and uses one of the Python3 notebook types.\n",
    "\n",
    "Within this notebook, I will guide the user through analyses comprising derivatives generated from one of the three main datatypes available on brainlife.io, specifically neuro/dwi. Specifically, I will guide the user through:\n",
    "        \n",
    "    1. Analyze functional connectivity properties derived from functional network matricies generated from fMRI using the Yeo 17 atlas.\n",
    "        \n",
    "The functions provided in this notebook were designed for performing the many experiments provided in Hayashi & Caron et al (in prep), but should be a good starting point for you to get started on analyzing your project on brainlife.io!\n",
    "\n",
    "### Important Note regarding assumptions of data structures, both inputs and outputs\n",
    "\n",
    "Before we get started, it is important to note at the begging that the code in this notebook was designed mostly with a stereotypical data structure format in mind. For many of the datatypes, specifically the csv datatypes, follow the tidy format [https://www.jstatsoft.org/article/view/v059i10], where \"each column is a variable, every row is an observation, and every cell is a singular value\"[https://cran.r-project.org/web/packages/tidyr/vignettes/tidy-data.html]. There will be a few common columns, specifically 'subjectID' denoting the brainlife subject ID, 'sessionID' denoting the session ID on brainlife (will be 1 if there is no session ID data available), 'structureID' denoting the tissue structure of interest (ex. white matter tract, cortical parcel, eeg node), and 'nodeID' denoting the sample number of the structure. 'nodeID' is included across many .csv-based datatypes to conform with profilometry data, which has multiple samples or nodes per structure. For single measures of a given structure, the nodeID for all structures will be 1. \n",
    "\n",
    "However, this is not the case for network adjacency matrices. Specifically with the network.json.gz files that come within the generic/network datatype, the resulting compiled data structure will be compiled as a json structure with a numpy array of the matrix for each subject and session. \n",
    "\n",
    "I will provide examples of these resulting structures later on in the notebook.\n",
    "\n",
    "I bring this up now to note that if you are not a fan of the style of the resulting data structures, or your data doesn't confirm to this style, you are free to alter this code to your deepest desires! I've attempted to do my best to comment and explain everything as much as possible for each section, function, and analysis. If there are any points where something is not working or you are not sure what the code is doing, feel free to email me at [bacaron245@gmail.com!]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "623ec1ae",
   "metadata": {},
   "source": [
    "# With that, let's get started!\n",
    "\n",
    "## Install packages\n",
    "The first things we need to do are to install some software packages using python's pip package manager, and then to load all of the necessary modules into our notebook.\n",
    "\n",
    "Specifically, we will install the python-import of the brain connectivity toolbox (BCT; ) known as bctpy [], jgf to load json packages (for our network matrices), and nilearn to make some pretty network plots!\n",
    "\n",
    "We will also be loading some other packages, including matplotlib, seaborn, and nilearn for plotting, numpy for numerical calculations and array manipulations, itertools and scipy for statistical testing, pandas, json, and jgf for loading various datat strucutres, and scikit-learn's mean_squared_error function to compute root-mean-square-error for some of the final analyses. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "f2d27821",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Requirement already satisfied: bctpy in /home/brad/.local/lib/python3.8/site-packages (0.5.2)\n",
      "Requirement already satisfied: jgf in /home/brad/.local/lib/python3.8/site-packages (0.2.2)\n",
      "Requirement already satisfied: nilearn in /home/brad/.local/lib/python3.8/site-packages (0.6.2)\n",
      "Requirement already satisfied: numpy in /home/brad/.local/lib/python3.8/site-packages (from bctpy) (1.21.5)\n",
      "Requirement already satisfied: scipy in /home/brad/.local/lib/python3.8/site-packages (from bctpy) (1.4.1)\n",
      "Requirement already satisfied: nibabel>=2.0.2 in /home/brad/.local/lib/python3.8/site-packages (from nilearn) (3.0.2)\n",
      "Requirement already satisfied: scikit-learn>=0.19 in /home/brad/.local/lib/python3.8/site-packages (from nilearn) (0.22.2.post1)\n",
      "Requirement already satisfied: joblib>=0.11 in /home/brad/.local/lib/python3.8/site-packages (from nilearn) (1.1.0)\n",
      "Requirement already satisfied: sklearn in /home/brad/.local/lib/python3.8/site-packages (from nilearn) (0.0)\n",
      "Note: you may need to restart the kernel to use updated packages.\n"
     ]
    }
   ],
   "source": [
    "pip install bctpy jgf nilearn"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2cbb1577",
   "metadata": {},
   "source": [
    "## Importing packages\n",
    "The first things we need to do is to load python packages in order to perform actions on the processed data, including matplotlib and seaborn for plotting, numpy for numerical calculations and array manipulations, itertools and scipy for statistical testing, pandas, and scikit-learn's mean_squared_error function to compute root-mean-square-error for some of the final analyses. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "9951cac1",
   "metadata": {},
   "outputs": [],
   "source": [
    "import os,sys,glob\n",
    "import requests\n",
    "from matplotlib import colors as mcolors\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import json\n",
    "import seaborn as sns\n",
    "from itertools import combinations\n",
    "from sklearn.metrics import mean_squared_error\n",
    "from scipy import stats\n",
    "import bct\n",
    "import jgf\n",
    "from nilearn import plotting\n",
    "from scipy.signal import resample"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "edb690f4",
   "metadata": {},
   "source": [
    "## Let's define and load some useful functions!\n",
    "\n",
    "This next section loads many functions for loading, compiling, analyzing, and visualizing some common datatypes on brainlife.io. To make it easier to load, I've provided all the functions used throughout the rest of the notebook in a single cell. However, for each function, I've provided comments that attempt to explain what the function does and what the inputs and outputs are. I've sectioned off the code into multiple sections: 1) data loading, compilation, and storage, 2) data analysis, manipulation and statistical computations, and 3) visualizations."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2407a774",
   "metadata": {
    "tags": []
   },
   "source": [
    "### Data loading, compilation, and storage\n",
    "The first section of functions deals with collecting data from secondary warehouse and compiling the data into a useful structures for further analysis. The main function the user will call from this section is the wrapper 'collect_data', which will identify the appropriate data from the secondary warehouse based on user input and compile that data into a structure the user can use for analysis. This function makes a couple of important assumptions. Specifically:\n",
    "\n",
    "    1. If there are duplicate datatypes that meet all of the specifications and filters, this function will only collect the data that was most recent to finish\n",
    "    \n",
    "    2. If the data can be formatted to a csv-file, it will be formatted to a csv-file. The only exception is network adjacency matrices.\n",
    "    \n",
    "    3. Users can control what data is grabbed and compiled by being specific with datatype_tags and tags.\n",
    "    \n",
    "The remaining functions perform other useful tasks, such as adding subjectID and sessionID data if missing, checking for duplicate entries of the same datatype (assumption 1), and append and compile data into the output data structure.\n",
    "\n",
    "As previously mentioned, the resulting csv-file structures will be in the tidy format, and network adjacency matricies will be stored as a json-structure with the matricies stored as numpy arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "bc58a7e2",
   "metadata": {},
   "outputs": [],
   "source": [
    "## this will add a subjectID and sessionID column to the output data\n",
    "def add_subjects_sessions(subject,session,path,data):\n",
    "    \n",
    "    if 'subjectID' not in data.keys():\n",
    "        data['subjectID'] = [ str(subject) for f in range(len(data)) ]\n",
    "    \n",
    "    if 'sessionID' not in data.keys():\n",
    "        data['sessionID'] = [ str(session) for f in range(len(data)) ]\n",
    "        \n",
    "    return data\n",
    "\n",
    "## this function calles check_for_duplicates and attempts to find duplicates. then uses that output, sets a dumby sessionID if not present,\n",
    "## and appends the object data\n",
    "def append_data(subjects,sessions,paths,finish_dates,obj,filename):\n",
    "        \n",
    "    # check for duplicates. if so, remove\n",
    "    finish_dates, subjects, sessions, paths = check_for_duplicates(obj,finish_dates,subjects,sessions,paths)\n",
    "\n",
    "    # append data to appropriate lists\n",
    "    subjects = np.append(subjects,str(obj['output']['meta']['subject']))\n",
    "    if 'session' in obj['output']['meta'].keys():\n",
    "        sessions = np.append(sessions,obj['output']['meta']['session'])\n",
    "    else:\n",
    "        sessions = np.append(sessions,'1')\n",
    "    paths = np.append(paths,\"input/\"+obj[\"path\"]+\"/\"+filename)\n",
    "    finish_dates = np.append(finish_dates,obj['finish_date'])\n",
    "    \n",
    "    return finish_dates, subjects, sessions, paths\n",
    "\n",
    "## this function will call add_subjects_sessions to add the appropriate columns and will append the object data to a study-wide dataframe\n",
    "def compile_data(paths,subjects,sessions,data):\n",
    "    # loops through all paths\n",
    "    for i in range(len(paths)):\n",
    "        # if network, load json. if not, load csv\n",
    "        if '.json.gz' in paths[i]:\n",
    "            tmpdata = pd.read_json(paths[i],orient='index').reset_index(drop=True)\n",
    "            tmpdata = add_subjects_sessions(subjects[i],sessions[i],paths[i],tmpdata)\n",
    "        else:\n",
    "            if '.tsv' in paths[i]:\n",
    "                sep = '\\t'\n",
    "            else:\n",
    "                sep = ','\n",
    "            tmpdata = pd.read_csv(paths[i],sep=sep)\n",
    "            tmpdata = add_subjects_sessions(subjects[i],sessions[i],paths[i],tmpdata)\n",
    "\n",
    "        data = data.append(tmpdata,ignore_index=True)\n",
    "\n",
    "    # replace empty spaces with nans\n",
    "    data = data.replace(r'^\\s+$', np.nan, regex=True)\n",
    "    \n",
    "    return data\n",
    "\n",
    "# this function will comile network adjacency matrices into a dictionary structure\n",
    "def compile_network_adjacency_matrices(paths,subjects,sessions,data):\n",
    "    \n",
    "    # loop through paths and append adjacency matrix to dictionary\n",
    "    for i in range(len(paths)):\n",
    "        data[subjects[i]+'_sess'+sessions[i]] = jgf.conmat.load(paths[i],compressed=True)[0]\n",
    "\n",
    "    return data\n",
    "\n",
    "### load data\n",
    "## this function is useful for identifying duplicate datatypes. if it finds one, it will update the data with the latest finishing dataset.\n",
    "def check_for_duplicates(obj,finish_dates,subjects,sessions,paths):\n",
    "    \n",
    "    # first checks if there is a session id available in the keys of the object. if finds one, then checks if the subject and session ID \n",
    "    # were already looped over. if so, will delete position in list and update with appropriate path. if it doesn't find a session ID, it\n",
    "    # just attempts to find if the subject has already been looped over\n",
    "    if 'session' in obj['output']['meta'].keys():\n",
    "        if (obj['output']['meta']['subject'] in subjects) and (obj['output']['meta']['session'] in sessions):\n",
    "            index = np.where(np.logical_and(subjects == obj['output']['meta']['subject'],sessions == obj['output']['meta']['session']))\n",
    "            if finish_dates[index] <= obj[\"finish_date\"]:\n",
    "                subjects = np.delete(subjects,index)\n",
    "                paths = np.delete(paths,index)\n",
    "                sessions = np.delete(sessions,index)\n",
    "                finish_dates = np.delete(finish_dates,index)\n",
    "    else:\n",
    "        if (obj['output']['meta']['subject'] in subjects):\n",
    "            index = np.where(subjects == obj['output']['meta']['subject'])\n",
    "            if finish_dates[index] <= obj[\"finish_date\"]:\n",
    "                subjects = np.delete(subjects,index)\n",
    "                paths = np.delete(paths,index)\n",
    "                sessions = np.delete(sessions,index)\n",
    "                finish_dates = np.delete(finish_dates,index)\n",
    "\n",
    "    return finish_dates, subjects, sessions, paths\n",
    "\n",
    "# this will check to see if the datatype tags or tags of the datatype object exists within the filtered ('!') tags\n",
    "def check_for_filter_tags(input_tags,obj,tagOrDatatypeTag):\n",
    "    \n",
    "    filter_checks = 0\n",
    "    for i in input_tags:\n",
    "        if i.replace('!','') not in obj['output'][tagOrDatatypeTag]:\n",
    "            filter_checks = filter_checks+1\n",
    "\n",
    "    return filter_checks\n",
    "\n",
    "## this function is the wrapper function that calls all the prevouis functions to generate a dataframe for the entire project of the appropriate datatype\n",
    "def collect_data(datatype,datatype_tags,tags,filename,outPath,net_adj):\n",
    "\n",
    "    # grab path and data objects\n",
    "    objects = requests.get('https://brainlife.io/api/warehouse/secondary/list/%s'%os.environ['PROJECT_ID']).json()\n",
    "\n",
    "    # subjects and paths\n",
    "    subjects = []\n",
    "    sessions = []\n",
    "    paths = []\n",
    "    finish_dates = []\n",
    "    obj_datatype_tags = []\n",
    "    obj_tags = []\n",
    "\n",
    "    # set up output\n",
    "    data = pd.DataFrame()\n",
    "\n",
    "    # loop through objects and find appropriate objects based on datatype, datatype_tags, and tags. can include drop tags ('!'). this logic could probably be simplified\n",
    "    for obj in objects:\n",
    "        if obj['datatype']['name'] == datatype:\n",
    "            # if datatype_tags is set, identify data using this info. if not, just use tag data. if no tags either, just append if meets datatype criteria. will check for filter with a not tag (!)\n",
    "            if datatype_tags:\n",
    "                # if the input datatype_tags are included in the object's datatype_tags, look for appropriate tags. if no tags, just append\n",
    "                if 'datatype_tags' in list(obj['output'].keys()) and len(obj['output']['datatype_tags']) != 0:\n",
    "                    if '!' in str(datatype_tags):\n",
    "                        datatype_tags_to_drop = [ f for f in datatype_tags if '!' in str(f) ]\n",
    "                        datatype_tag_keep = [ f for f in datatype_tags if f not in datatype_tags_to_drop ]\n",
    "\n",
    "                        if set(datatype_tag_keep).issubset(obj['output']['datatype_tags']):\n",
    "                            datatype_tag_checks = check_for_filter_tags(datatype_tags_to_drop,obj,'datatype_tags')\n",
    "                            if datatype_tag_checks == len(datatype_tags_to_drop):\n",
    "                                datatype_tag_filter = True\n",
    "                            else:\n",
    "                                datatype_tag_filter = False\n",
    "                        else:\n",
    "                            datatype_tag_filter = False\n",
    "                    else:\n",
    "                        if set(datatype_tags).issubset(obj['output']['datatype_tags']):\n",
    "                            datatype_tag_filter = True\n",
    "                        else:\n",
    "                            datatype_tag_filter = False\n",
    "                else:\n",
    "                    datatype_tag_filter = False\n",
    "            else:\n",
    "                datatype_tag_filter = True\n",
    "\n",
    "            if tags:\n",
    "                if 'tags' in list(obj['output'].keys()) and len(obj['output']['tags']) != 0:\n",
    "                    if '!' in str(tags):\n",
    "                        tags_drop = [ f for f in tags if '!' in str(f) ]\n",
    "                        tags_keep = [ f for f in tags if f not in tags_drop ]\n",
    "\n",
    "                        if set(tags_keep).issubset(obj['output']['tags']):\n",
    "                            tag_checks = checkcheck_for_filter_tagsForFilterTags(tags_drop,obj,'tags')\n",
    "                            if tag_checks == len(tags_drop):\n",
    "                                tag_filter = True\n",
    "                            else:\n",
    "                                tag_filter = False\n",
    "                        else:\n",
    "                            tag_filter = False\n",
    "                    else:\n",
    "                        if set(tags).issubset(obj['output']['tags']):\n",
    "                            tag_filter = True\n",
    "                        else:\n",
    "                            tag_filter = False\n",
    "                else:\n",
    "                    tag_filter = False\n",
    "            else:\n",
    "                tag_filter = True\n",
    "\n",
    "            if datatype_tag_filter == True & tag_filter == True:\n",
    "                obj_datatype_tags = np.append(obj_datatype_tags,obj['output']['datatype_tags'])\n",
    "                obj_tags = np.append(obj_tags,obj['output']['tags'])\n",
    "                finish_dates, subjects, sessions, paths = append_data(subjects,sessions,paths,finish_dates,obj,filename)\n",
    "\n",
    "    # shuffle data so subjects are in order\n",
    "    paths = [z for _,_,z in sorted(zip(subjects,sessions,paths))]\n",
    "    subjects = [x for x,_,_ in sorted(zip(subjects,sessions,paths))]\n",
    "    sessions = [y for _,y,_ in sorted(zip(subjects,sessions,paths))]\n",
    "\n",
    "    # check if tab separated or comma separated by looking at input filename\n",
    "    if '.tsv' in filename:\n",
    "        sep = '\\t'\n",
    "    else:\n",
    "        sep = ','\n",
    "\n",
    "    # compile data\n",
    "    if net_adj:\n",
    "        data = {}\n",
    "        data = compile_network_adjacency_matrices(paths,subjects,sessions,data)\n",
    "        if outPath:\n",
    "            np.save(outPath,data)\n",
    "    else:\n",
    "        data = compile_data(paths,subjects,sessions,data)\n",
    "\n",
    "    # output data structure for records and any further analyses\n",
    "    if outPath:\n",
    "        data.to_csv(outPath,sep=sep,index=False)\n",
    "\n",
    "    return data\n",
    "\n",
    "### subjects dataframe generation\n",
    "## this function will make a dataframe from a list of subjects and groups. will also add a color column for easy plotting\n",
    "def collect_subject_data(topPath,dataPath,groups,subjects,colors):\n",
    "\n",
    "    # set up variables\n",
    "    data_columns = ['subjectID','classID','colors']\n",
    "    data =  pd.DataFrame([],columns=data_columns)\n",
    "\n",
    "    # populate structure\n",
    "    data['subjectID'] = [ f for g in groups for f in subjects[g] ]\n",
    "    data['classID'] = [ g for g in groups for f in range(len(subjects[g]))]\n",
    "    data['colors'] = [ colors[c] for c in colors for f in subjects[c]]\n",
    "\n",
    "    # output data structure for records and any further analyses\n",
    "    if not os.path.exists(dataPath):\n",
    "        os.mkdir(dataPath)\n",
    "\n",
    "    data.to_csv(dataPath+'subjects.csv',index=False)\n",
    "\n",
    "    return data\n",
    "\n",
    "## this will create a subject-specific color for each subject in the subjects dataframe\n",
    "def create_color_dictionary(data,measure,colorPalette):\n",
    "\n",
    "    # Create subject keys and color values\n",
    "    keys = data[measure].unique()\n",
    "    values = sns.color_palette(colorPalette,len(keys))\n",
    "    values = values.as_hex()\n",
    "\n",
    "    # zip dictionary together\n",
    "    colors_dict = dict(zip(keys,values))\n",
    "\n",
    "    return colors_dict"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b27af75e",
   "metadata": {},
   "source": [
    "### Data analysis, manipulation and statistical computations\n",
    "This next section contains functions for manipulating, analysing, and computing statistics from the data collected using the functions previously described. This includes many different manipulations and computations, including trimming nodes off profilometry data, computing mean dataframes, computing outliers and generating reference datasets, and some simple network adjacency matrix manipulations including binarizing, thresholding, and computing the mean witihin-network functional connectivity. \n",
    "\n",
    "The bulk of these functions are devoted to identifying outliers and generating reference datasets. My approach for this included identifying outliers for each structure and measure across a given project  by computing the mean distribution and identifying those with distances from that point greater than a percentile threshold. I then removed those data points, and recomputed the reference dataset. The references generated have been built-into many of the verification steps following Apps. The resulting dataframes are formatted in both csv and json structures."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "1767b9ca",
   "metadata": {},
   "outputs": [],
   "source": [
    "### dataframe manipulations\n",
    "## cut nodes for profilometry / timeseries data\n",
    "def cut_nodes(data,num_nodes,dataPath,foldername,savename):\n",
    "\n",
    "    # identify inner n nodes based on num_nodes input\n",
    "    total_nodes = len(data['nodeID'].unique())\n",
    "    cut_nodes = int((total_nodes - num_nodes) / 2)\n",
    "\n",
    "    # remove cut_nodes from dataframe\n",
    "    data = data[data['nodeID'].between((cut_nodes)+1,(num_nodes+cut_nodes))]\n",
    "\n",
    "    # replace empty spaces with nans\n",
    "    data = data.replace(r'^\\s+$', np.nan, regex=True)\n",
    "\n",
    "    # output data structure for records and any further analyses\n",
    "    if not os.path.exists(dataPath):\n",
    "        os.mkdir(dataPath)\n",
    "\n",
    "    data.to_csv(dataPath+'/'+foldername+'-'+savename+'.csv',index=False)\n",
    "\n",
    "    return data\n",
    "\n",
    "## will compute mean dataframe \n",
    "def compute_mean_data(dataPath,data,outname):\n",
    "\n",
    "    # make mean data frame\n",
    "    data_mean =  data.groupby(['subjectID','classID','structureID']).mean().reset_index()\n",
    "    data_mean['nodeID'] = [ 1 for f in range(len(data_mean['nodeID'])) ]\n",
    "\n",
    "    # output data structure for records and any further analyses\n",
    "    if not os.path.exists(dataPath):\n",
    "        os.mkdir(dataPath)\n",
    "\n",
    "    data_mean.to_csv(dataPath+outname+'.csv',index=False)\n",
    "\n",
    "    return data_mean\n",
    "\n",
    "### scripts related to outlier detection and reference dataframe generation\n",
    "## this function will compute distance measures from input data and reference data\n",
    "def compute_distance(data,references_data,measures,metric):\n",
    "\n",
    "    # imports important distance functions\n",
    "    from sklearn.metrics.pairwise import euclidean_distances\n",
    "    from scipy.stats import wasserstein_distance\n",
    "\n",
    "    # if distance metric desired is euclidean distance (i.e. for profiles), computes distance of profile from reference profile. else, just computes difference using emd\n",
    "    if metric == 'euclidean':\n",
    "        dist = data.groupby('subjectID',sort=False).apply(lambda x: euclidean_distances([x[measures].values.tolist(),references_data[measures].values.tolist()])[0][1]).values\n",
    "    else:\n",
    "        dist = data.groupby('subjectID',sort=False).apply(lambda x: wasserstein_distance(x[measures],[references_data[measures].values[0]]))\n",
    "\n",
    "    return dist\n",
    "\n",
    "## this function will compute simple average references for a given input data\n",
    "def compute_references(x,groupby_measures,index_measure,diff_measures):\n",
    "    \n",
    "    # computes mean and sd of the measures in a dataframe\n",
    "    references_mean = x.groupby(groupby_measures).mean().reset_index(index_measure)\n",
    "    references_sd = x.groupby(groupby_measures).std().reset_index(index_measure)\n",
    "    references_sd[diff_measures] = references_sd[diff_measures] * 2\n",
    "    \n",
    "    return references_mean, references_sd\n",
    "\n",
    "## this function calls compute_references and compute_distance to create a dataframe of distance measures\n",
    "def create_distance_dataframe(data,structures,groupby_measure,measures,dist_metric):\n",
    "    \n",
    "    # set up output lists that we will append to\n",
    "    dist = []\n",
    "    subj = []\n",
    "    meas = []\n",
    "    struc = []\n",
    "\n",
    "    # loop through appropriate structures\n",
    "    for i in structures:\n",
    "        print(i)\n",
    "        # set data for a given structure\n",
    "        subj_data = data.loc[data['structureID'] == i]\n",
    "        # compute reference for given structure\n",
    "        references_data = compute_references(subj_data,groupby_measure,groupby_measure,measures)\n",
    "        # loop through measures and compute distance from reference\n",
    "        for m in measures:\n",
    "            if dist_metric == 'euclidean':\n",
    "                dist = np.append(dist,compute_distance(subj_data,references_data[0],m,'euclidean'))\n",
    "            else:\n",
    "                dist = np.append(dist,compute_distance(subj_data,references_data[0],m,'emd'))\n",
    "            \n",
    "            # append data to appropriate lists\n",
    "            subj = np.append(subj,subj_data.subjectID.unique().tolist())\n",
    "            meas = np.append(meas,[ m for f in range(len(subj_data.subjectID.unique().tolist())) ])\n",
    "            struc = np.append(struc,[ i for f in range(len(subj_data.subjectID.unique().tolist())) ])\n",
    "\n",
    "    # create distance dataframe\n",
    "    dist_dataframe = pd.DataFrame()\n",
    "    dist_dataframe['subjectID'] = subj\n",
    "    dist_dataframe['structureID'] = struc\n",
    "    dist_dataframe['measures'] = meas\n",
    "    dist_dataframe['distance'] = dist\n",
    "    \n",
    "    return dist_dataframe\n",
    "\n",
    "## this function is useful for saving reference.jsons for a given structure\n",
    "def output_reference_json(ref_data,measures,profile,resample_points,sourceID,data_dir,filename):\n",
    "    \n",
    "    # loop through structures in dataframe\n",
    "    for st in ref_data.structureID.unique():\n",
    "        # set up important measures\n",
    "        reference_json = []\n",
    "        tmp = {}\n",
    "        tmp['structurename'] = st\n",
    "        tmp['source'] = sourceID\n",
    "        # loop through measures\n",
    "        for meas in measures:\n",
    "            # grab data\n",
    "            tmp[meas] = {}\n",
    "            if profile:\n",
    "                gb_frame = ref_data.loc[ref_data['structureID'] == st][['nodeID',meas]].dropna().groupby('nodeID')[meas]\n",
    "            else:\n",
    "                gb_frame = ref_data.loc[ref_data['structureID'] == st][[meas]].dropna()[meas]\n",
    "            \n",
    "            # if resample_points is a value, resamples references and computes multiple summary measures.\n",
    "            # else, will just output the entire data. this second option is really only useful for non-profile/series data\n",
    "            data_tmp = []\n",
    "            if resample_points:                \n",
    "                mean_tmp = resample(gb_frame.mean().values.tolist(),resample_points).tolist()\n",
    "                min_tmp = resample(gb_frame.min().values.tolist(),resample_points).tolist()\n",
    "                max_tmp = resample(gb_frame.max().values.tolist(),resample_points).tolist()\n",
    "                sd_tmp = resample(gb_frame.std().values.tolist(),resample_points).tolist()\n",
    "                five_tmp = resample(gb_frame.quantile(q=.05).values.tolist(),resample_points).tolist()\n",
    "                twofive_tmp = resample(gb_frame.quantile(q=.25).values.tolist(),resample_points).tolist()\n",
    "                sevenfive_tmp = resample(gb_frame.quantile(q=.75).values.tolist(),resample_points).tolist()\n",
    "                ninefive_tmp = resample(gb_frame.quantile(q=.95).values.tolist(),resample_points).tolist()\n",
    "                tmp[meas]['mean'] = mean_tmp\n",
    "                tmp[meas]['min'] = min_tmp\n",
    "                tmp[meas]['max'] = max_tmp\n",
    "                tmp[meas]['sd'] = sd_tmp\n",
    "                tmp[meas]['5_percentile'] = five_tmp\n",
    "                tmp[meas]['25_percentile'] = twofive_tmp\n",
    "                tmp[meas]['75_percentile'] = sevenfive_tmp\n",
    "                tmp[meas]['95_percentile'] = ninefive_tmp\n",
    "            else:\n",
    "                data_tmp = gb_frame.values.tolist()\n",
    "                tmp[meas]['data'] = data_tmp\n",
    "        reference_json.append(tmp)\n",
    "\n",
    "        with open(data_dir+'/'+filename+'_'+st+'.json','w') as ref_out_f:\n",
    "            json.dump(reference_json,ref_out_f)\n",
    "    \n",
    "    return reference_json\n",
    "\n",
    "## this function is used to build the reference dataset removing any subjects identified as outliers. the dataframe may or may not be useful\n",
    "def build_reference_data(data,outliers,profile,data_dir,filename):\n",
    "    \n",
    "    # set up dataframe\n",
    "    reference_data = pd.DataFrame()\n",
    "\n",
    "    # loop through structures and measures and set data\n",
    "    for s in outliers.structureID.unique():\n",
    "        for m in outliers.measures.unique():\n",
    "            if profile:\n",
    "                meas = ['structureID','subjectID','nodeID',m]\n",
    "            else:\n",
    "                meas = ['structureID','subjectID',m]\n",
    "            tmpdata = data[(data[\"structureID\"] == s) & (~data['subjectID'].isin(outliers.loc[outliers['structureID'] == s].loc[outliers['measures'] == m].subjectID.unique()))][meas].reset_index(drop=True)\n",
    "            reference_data = pd.concat([reference_data,tmpdata])\n",
    "    # if not profile, will compute average\n",
    "    if not profile:\n",
    "        reference_data = reference_data.groupby(['structureID','subjectID']).mean().reset_index()\n",
    "\n",
    "    reference_data.to_csv(data_dir+'/'+filename+'.csv',index=False)\n",
    "\n",
    "    return reference_data\n",
    "\n",
    "## this function will identify if a given subjects' data is an outlier based on distance from reference and a threshold percentage\n",
    "def compute_outliers(distances,threshold):\n",
    "    \n",
    "    # set up dataframe\n",
    "    outliers = pd.DataFrame()\n",
    "    \n",
    "    # loop through structureas and measures and identify outliers based on thereshold distance\n",
    "    for i in distances.structureID.unique():\n",
    "        for m in distances.measures.unique():\n",
    "            tmpdata = distances.loc[distances['structureID'] == i].loc[distances['measures'] == m]\n",
    "            outliers = pd.concat([outliers,tmpdata[tmpdata['distance'] > np.percentile(tmpdata['distance'],threshold)]])\n",
    "            \n",
    "    return outliers\n",
    "\n",
    "## this function calls compute_outliers, create_distance_dataframe, and build_reference_data and output_reference_json to actually generate the outliers\n",
    "## and final reference datasets\n",
    "def outlier_detection(data,structures,groupby_measure,measures,threshold,dist_metric,build_outliers,profile,resample_points,sourceID,data_dir,filename):\n",
    "    \n",
    "    # set up important lists\n",
    "    outliers_subjects = []\n",
    "    outliers_structures = []\n",
    "    outliers_measures = []\n",
    "    outliers_metrics = []\n",
    "\n",
    "    # compute distances and identify outliers\n",
    "    distances = create_distance_dataframe(data,structures,groupby_measure,measures,dist_metric)\n",
    "    outliers_dataframe = compute_outliers(distances,threshold)\n",
    "    \n",
    "    # if building references, build the reference data. otherwise, output a blank array\n",
    "    if build_outliers:\n",
    "        reference_dataframe = build_reference_data(data,outliers_dataframe,profile,data_dir,filename)\n",
    "        reference_json = output_reference_json(reference_dataframe,measures,profile,resample_points,sourceID,data_dir,filename)\n",
    "    else:\n",
    "        reference_dataframe = []\n",
    "        reference_json = []\n",
    "        \n",
    "    return distances, outliers_dataframe, reference_dataframe, reference_json\n",
    "\n",
    "## this function is useful in identifying subjects who may have had a flipped profile as compared to a reference profile.\n",
    "## calls compute_references, compute_distance.\n",
    "## logic: if the distance of a subject's tract profile from a reference profile is positive and greater than a threshold percentage, then it's likely\n",
    "## the data has been flipped. needs more work for all use cases. works well for easy examples like uncinate\n",
    "def profile_flip_check(data,subjects,structures,test_measure,flip_measures,dist_metric,threshold,outPath):\n",
    "    \n",
    "    # set up important lists\n",
    "    flipped_subjects = []\n",
    "    flipped_structures = []\n",
    "    distance = []\n",
    "    flipped_distance = []\n",
    "\n",
    "    # loop through structures\n",
    "    for i in structures:\n",
    "        print(i)\n",
    "        # set data frame for structure, including a copy that has the test_measure flipped\n",
    "        struc_data = data.loc[data['structureID'] == i]\n",
    "        flipped_struc_data = struc_data.copy()\n",
    "        flipped_struc_data[test_measure] = flipped_struc_data.groupby('subjectID',sort=False).apply(lambda x: np.flip(x['fa'])).tolist()\n",
    "\n",
    "        # build reference data\n",
    "        references_data = compute_references(struc_data,'nodeID','nodeID',flip_measures)\n",
    "\n",
    "        # compute distances for normal data and for flipped. then compute difference\n",
    "        dist = compute_distance(struc_data,references_data[0],test_measure,dist_metric)\n",
    "        dist_flipped = compute_distance(flipped_struc_data,references_data[0],test_measure,dist_metric)\n",
    "        differences = dist - dist_flipped\n",
    "\n",
    "        # identify threshold of distances based on percentile. identify those that have positive differences and are greater than the threshold.\n",
    "        # if so, append information\n",
    "        percentile_threshold = np.percentile(differences,threshold)\n",
    "        for m in range(len(differences)):\n",
    "            if differences[m] > 0 and differences[m] > percentile_threshold:\n",
    "                flipped_subjects = np.append(flipped_subjects,subjects[m])\n",
    "                flipped_structures = np.append(flipped_structures,i)\n",
    "                distance = np.append(distance,dist[m])\n",
    "                flipped_distance = np.append(flipped_distance,dist_flipped[m])\n",
    "\n",
    "    # generate ouput dataframe containing flipped subject data\n",
    "    output_summary = pd.DataFrame()\n",
    "    output_summary['flipped_subjects'] = flipped_subjects\n",
    "    output_summary['flipped_structures'] = flipped_structures\n",
    "    output_summary['distance'] = distance\n",
    "    output_summary['flipped_distance'] = flipped_distance\n",
    "\n",
    "    if outPath:\n",
    "        output_summary.to_csv(outPath+'_flipped_profiles.csv',index=False)\n",
    "        \n",
    "# this function will merge the structural and diffusion data for the reference datasets\n",
    "def merge_structural_diffusion_json(data,structuralPath,diffusionPath,outPath):\n",
    "    for i in data.structureID.unique():\n",
    "        print(i)\n",
    "        with open(structuralPath+'_'+i+'.json','r') as structural_f:\n",
    "            structural = json.load(structural_f)\n",
    "\n",
    "        with open(diffusionPath+'_'+i+'.json','r') as diffusion_f:\n",
    "            diffusion = json.load(diffusion_f)\n",
    "\n",
    "        merged = [{**structural[0],**diffusion[0]}]\n",
    "\n",
    "        with open(outPath+'_'+i+'.json','w') as out_f:\n",
    "            json.dump(merged,out_f)\n",
    "\n",
    "### adjacency-matrix related fuctions for computing network values locally\n",
    "# this function will binarize an adjacency matrix\n",
    "def binarize_matrices(data):\n",
    "    \n",
    "    # use brain connectivity toolbox to binarize data\n",
    "    bin_data = [ bct.utils.binarize(data[f]) for f in data.keys() ]\n",
    "    \n",
    "    return bin_data\n",
    "\n",
    "# this function will threshold an adjacency matrix based on a percentage threshold of subjects with a binary 1 in that node pair\n",
    "def threshold_matrices(data,bin_data,thresholdPercentageSubjects):\n",
    "    \n",
    "    # compute sum of matrices\n",
    "    sum_mat = np.zeros(np.shape(bin_data)[1:])\n",
    "    \n",
    "    for i in bin_data:\n",
    "        sum_mat = sum_mat + i\n",
    "        \n",
    "    # compute threshold value\n",
    "    thrs = thresholdPercentageSubjects*len(bin_data)\n",
    "    \n",
    "    # loop through data and make those nodes that dont meet threshold 0\n",
    "    for i in data.keys():\n",
    "        data[i][sum_mat < thrs] = 0\n",
    "        \n",
    "    return data\n",
    "\n",
    "# this function will compute the mean within-node functional connectivity\n",
    "def compute_mean_network_connectivity(data,networks,indices,out_path):\n",
    "\n",
    "    mean_data = []\n",
    "    subs = []\n",
    "    nets = []\n",
    "\n",
    "    for l in data.keys():\n",
    "        for n in networks:\n",
    "            tmpdata = []\n",
    "            subs = np.append(subs,l)\n",
    "            nets = np.append(nets,n)\n",
    "            for i in indices[n]:\n",
    "                for j in indices[n]:\n",
    "                    if i != j:\n",
    "                        tmpdata = np.append(tmpdata,data[l][int(i)][int(j)])\n",
    "            mean_data = np.append(mean_data,np.mean(tmpdata))\n",
    "\n",
    "    out_df = pd.DataFrame()\n",
    "    out_df['subjectID'] = [ f.split('_sess1')[0] for f in subs ]\n",
    "    out_df['FC'] = mean_data\n",
    "    out_df = pd.merge(out_df,subjects_data,on='subjectID')\n",
    "    out_df['structureID'] = nets\n",
    "\n",
    "    if out_path:\n",
    "        out_df.to_csv(out_path,index=False)\n",
    "        \n",
    "    return out_df\n",
    "\n",
    "# this function will compute the mean network matrix\n",
    "def compute_mean_network(data):\n",
    "    \n",
    "    mean_network = np.array(np.zeros(np.shape(data[list(data.keys())[0]])))\n",
    "    \n",
    "    for i in data.keys():\n",
    "        mean_network = mean_network + data[i]\n",
    "        \n",
    "    mean_network = mean_network / len(data.keys())\n",
    "    \n",
    "    return mean_network"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "e5299fc5",
   "metadata": {},
   "source": [
    "### Visualizations\n",
    "The final set of functions deals with generating many useful visualizations and plots of the data, including scatterplots, violin plots, and tract profile plots. Within this are many useful wrapper functions that organize the data into useful structures for plotting. These scripts are very 'baked in', in that they are in a style that I like. However, many of these visualizations can be changed with simple alterations to the code. Many of the plots use packages like seaborn or matplotlib to make the visualizations, which both have extensive documentation to guide and help!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3104a191",
   "metadata": {},
   "outputs": [],
   "source": [
    "### visualization related scripts\n",
    "# groups data by input measure and computes mean for each value in that column. x_stat is a pd dataframe, with each row being a single value, and each column being a different ID value or measure\n",
    "def average_within_column(x_stat,y_stat,x_measure,y_measure,measure):\n",
    "\n",
    "    X = x_stat.groupby(measure).mean()[x_measure].tolist()\n",
    "    Y = y_stat.groupby(measure).mean()[y_measure].tolist()\n",
    "\n",
    "    return X,Y\n",
    "\n",
    "# groups data by input measure and creates an array by appending data into x and y arrays. x_stat and y_stat are pd dataframes, with each row being a single value, and each column being a different ID value or measure\n",
    "# designed for test retest. x_stat and y_stat should have the same number of rows. but more importantly, should correspond to the same source (i.e. subject)\n",
    "# can be same pd.dataframe, but indexing of specific subject groups\n",
    "def append_within_column(x_stat,y_stat,x_measure,y_measure,measure):\n",
    "\n",
    "    X,Y = [np.array([]),np.array([])]\n",
    "    for i in range(len(x_stat[measure].unique())):\n",
    "        x = x_stat[x_stat[measure] == x_stat[measure].unique()[i]][x_measure]\n",
    "        y = y_stat[y_stat[measure] == y_stat[measure].unique()[i]][y_measure]\n",
    "\n",
    "        if np.isnan(x).any() or np.isnan(y).any():\n",
    "            print(\"skipping %s due to nan\" %x_stat[measure].unique()[i])\n",
    "        else:\n",
    "            # checks to make sure the same data\n",
    "            if len(x) == len(y):\n",
    "                X = np.append(X,x)\n",
    "                Y = np.append(Y,y)\n",
    "\n",
    "    return X,Y\n",
    "\n",
    "# unravels networks. x_stat and y_stat should be S x M, where S is the number of subjects and M is the adjacency matrix for that subject\n",
    "def ravel_network(x_stat,y_stat):\n",
    "\n",
    "    import numpy as np\n",
    "\n",
    "    X = np.ravel(x_stat).tolist()\n",
    "    Y = np.ravel(y_stat).tolist()\n",
    "\n",
    "    return X,Y\n",
    "\n",
    "# unravels nonnetwork data. x_stat and y_stat should be pd dataframes. x_measure and y_measure are the measure to unrvavel. \n",
    "# designed for test retest. x_stat and y_stat should have the same number of rows. but more importantly, should correspond to the same source (i.e. subject)\n",
    "# can be same pd.dataframe, but indexing of specific subject groups\n",
    "def ravel_non_network(x_stat,y_stat,x_measure,y_measure):\n",
    "\n",
    "    X = x_stat[x_measure].to_list()\n",
    "    Y = y_stat[y_measure].to_list()\n",
    "\n",
    "    return X,Y\n",
    "\n",
    "# wrapper function to call either of the above scripts based on user input\n",
    "def setup_data(x_data,y_data,x_measure,y_measure,ravelAverageAppend,isnetwork,measure):\n",
    "\n",
    "    x_stat = x_data\n",
    "    y_stat = y_data\n",
    "\n",
    "    if ravelAverageAppend == 'average':\n",
    "        X,Y = average_within_column(x_stat,y_stat,x_measure,y_measure,measure)\n",
    "    elif ravelAverageAppend == 'append':\n",
    "        X,Y = append_within_column(x_stat,y_stat,x_measure,y_measure,measure)\n",
    "    elif ravelAverageAppend == 'ravel':\n",
    "        if isnetwork == True:\n",
    "            X,Y = ravel_network(x_stat,y_stat)\n",
    "        else:\n",
    "            X,Y = ravel_non_network(x_stat,y_stat,x_measure,y_measure)\n",
    "\n",
    "    return x_stat,y_stat,X,Y\n",
    "\n",
    "# function to shuffle data and colors\n",
    "def shuffle_data_alg(X,Y,hues):\n",
    "\n",
    "    from sklearn.utils import shuffle\n",
    "\n",
    "    X,Y,hues = shuffle(X,Y,hues)\n",
    "\n",
    "    return X,Y,hues\n",
    "\n",
    "# simple display or figure save function\n",
    "def save_or_show_img(dir_out,x_measure,y_measure,img_name):\n",
    "    import os,sys \n",
    "    import matplotlib.pyplot as plt\n",
    "    import warnings\n",
    "    \n",
    "    with warnings.catch_warnings():\n",
    "        # this will suppress all warnings in this block\n",
    "        warnings.simplefilter(\"ignore\")\n",
    " \n",
    "        # save or show plot\n",
    "        if dir_out:\n",
    "            if not os.path.exists(dir_out):\n",
    "                os.mkdir(dir_out)\n",
    "\n",
    "            if x_measure == y_measure:\n",
    "                img_name_eps = img_name+'_'+x_measure+'.eps'\n",
    "                img_name_png = img_name+'_'+x_measure+'.png'\n",
    "                img_name_svg = img_name+'_'+x_measure+'.svg'\n",
    "            else:\n",
    "                img_name_eps = img_name+'_'+x_measure+'_vs_'+y_measure+'.eps'\n",
    "                img_name_png = img_name+'_'+x_measure+'_vs_'+y_measure+'.png'\n",
    "                img_name_svg = img_name+'_'+x_measure+'_vs_'+y_measure+'.svg'\n",
    "\n",
    "            plt.savefig(os.path.join(dir_out, img_name_eps),transparent=True)\n",
    "            plt.savefig(os.path.join(dir_out, img_name_png))     \n",
    "        else:\n",
    "            plt.show()\n",
    "\n",
    "        # plt.close()\n",
    "    \n",
    "# uses seaborn's relplot function to plot data for each unique value in a column of a pandas dataframe (ex. subjects, structureID). useful for supplementary figures or sanity checking or preliminary results\n",
    "# column measure is the measure within which each unique value will have its own plot. hue_measure is the column to use for coloring the data. column_wrap is how many panels you want per row\n",
    "# trendline, depending on user input, can either be the linear regression between x_data[x_measure] and y_data[y_measure] or the line of equality\n",
    "# dir_out and img_name are the directory where the figures should be saved and the name for the image. will save .eps and .png\n",
    "# if want to view plot instead of save, set dir_out=\"\"\n",
    "def relplot_scatter(x_data,y_data,x_measure,y_measure,column_measure,hue_measure,column_wrap,trendline,dir_out,img_name):\n",
    "\n",
    "    import os,sys\n",
    "    import numpy as np\n",
    "    import matplotlib.pyplot as plt\n",
    "    import seaborn as sns\n",
    "    from sklearn.metrics import mean_squared_error\n",
    "\n",
    "    # grab data: CANNOT BE AVERAGE\n",
    "    [x_stat,y_stat,X,Y] = setup_data(x_data,y_data,x_measure,y_measure,'ravel',False,hue_measure)\n",
    "\n",
    "    p = sns.relplot(x=X,y=Y,col=x_stat[column_measure],hue=x_stat[hue_measure],kind=\"scatter\",s=100,col_wrap=column_wrap)\n",
    "\n",
    "    # setting counter. looping through axes to add important info and regression lines\n",
    "    i = 0\n",
    "    for ax in p.axes.flat:\n",
    "        x_lim,y_lim = [ax.get_xlim(),ax.get_ylim()]\n",
    "\n",
    "        if trendline == 'equality':\n",
    "            ax.plot(x_lim,y_lim,ls=\"--\",c='k')\n",
    "        elif trendline == 'linreg':\n",
    "            m,b = np.polyfit(p.data[p.data[column_measure] == x_stat[column_measure].unique()[i]]['x'],p.data[p.data[column_measure] == y_stat[column_measure].unique()[i]]['y'],1)\n",
    "            ax.plot(ax.get_xticks(),m*ax.get_xticks() + b)\n",
    "            plt.text(0.1,0.7,'y = %s x + %s' %(str(np.round(m,4)),str(np.round(b,4))),fontsize=12,verticalalignment=\"top\",horizontalalignment=\"left\",transform=ax.transAxes)\n",
    "\n",
    "        ax.set_xlim(x_lim)\n",
    "        ax.set_ylim(y_lim)\n",
    "        ax.set_xlabel(x_measure)\n",
    "        ax.set_ylabel(y_measure)\n",
    "\n",
    "        # compute correlation for each subject and add to plots\n",
    "        corr = np.corrcoef(p.data[p.data[column_measure] == x_stat[column_measure].unique()[i]]['x'],p.data[p.data[column_measure] == y_stat[column_measure].unique()[i]]['y'])[1][0]\n",
    "        plt.text(0.1,0.9,'r = %s' %str(np.round(corr,4)),fontsize=12,verticalalignment=\"top\",horizontalalignment=\"left\",transform=ax.transAxes)\n",
    "\n",
    "        # compute rmse for each subject and add to plots\n",
    "        rmse = np.sqrt(mean_squared_error(p.data[p.data[column_measure] == x_stat[column_measure].unique()[i]]['x'],p.data[p.data[column_measure] == y_stat[column_measure].unique()[i]]['y']))\n",
    "        plt.text(0.1,0.8,'rmse = %s' %str(np.round(rmse,4)),fontsize=12,verticalalignment=\"top\",horizontalalignment=\"left\",transform=ax.transAxes)\n",
    "\n",
    "        # update counter\n",
    "        i = i+1\n",
    "\n",
    "    # save image or show image\n",
    "    save_or_show_img(dir_out,x_measure,y_measure,img_name)\n",
    "\n",
    "# uses seaborn's scatter function to plot data from x_data[x_measure] and y_data[y_measure]. useful for publication worthy figure\n",
    "# column measure is the measure within which data will be summarized. hue_measure is the column to use for coloring the data. \n",
    "# ravelAverageAppend is a string value of either 'append' to use the append function, 'ravel' to use the ravel function, or 'average' to use the average function\n",
    "# trendline, depending on user input, can either be the linear regression between x_data[x_measure] and y_data[y_measure] or the line of equality\n",
    "# dir_out and img_name are the directory where the figures should be saved and the name for the image. will save .eps and .png\n",
    "# if want to view plot instead of save, set dir_out=\"\"\n",
    "def singleplot_scatter(colors_dict,x_data,y_data,x_measure,y_measure,logX,column_measure,hue_measure,ravelAverageAppend,trendline,shuffleData,colorDistance,perfectOrSlope,subsample_percentage,dir_out,img_name):\n",
    "\n",
    "    import os,sys\n",
    "    import numpy as np\n",
    "    import matplotlib.pyplot as plt\n",
    "    import seaborn as sns\n",
    "    from sklearn.metrics import mean_squared_error\n",
    "\n",
    "    # grab data\n",
    "    [x_stat,y_stat,X,Y] = setup_data(x_data,y_data,x_measure,y_measure,ravelAverageAppend,False,column_measure)\n",
    "    \n",
    "    # compute corr and rmse first in case data gets subsampled later\n",
    "    corr = np.corrcoef(X,Y)[1][0]\n",
    "    rmse = np.sqrt(mean_squared_error(X,Y))\n",
    "    \n",
    "    # map trendlines before subsampling\n",
    "    if trendline == 'linreg':\n",
    "        m,b = np.polyfit(X,Y,1)\n",
    "    elif trendline == 'groupreg':\n",
    "        for g in range(len(groups)):\n",
    "            if stat_name == 'volume':\n",
    "                slope, intercept, r_value, p_value, std_err = stats.linregress(np.log10(stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name]),stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm])\n",
    "            else:\n",
    "                slope, intercept, r_value, p_value, std_err = stats.linregress(stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name],stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm])\n",
    "\n",
    "    if subsample_percentage:\n",
    "        X,Y = subsample_data(X,Y,subsample_percentage)\n",
    "    \n",
    "    if colorDistance:\n",
    "        category = color_distance_scatter(X,Y,perfectOrSlope)\n",
    "    else:\n",
    "        colors = sns.color_palette('colorblind',len(x_stat[hue_measure]))\n",
    "\n",
    "    if ravelAverageAppend == 'average':\n",
    "        if isinstance(x_stat[hue_measure].unique()[0],str):\n",
    "            hues = x_stat[hue_measure].unique().tolist()\n",
    "        else:\n",
    "            hues = x_stat.groupby(column_measure).mean()[hue_measure].tolist()\n",
    "    else:\n",
    "        hues = list(x_stat[hue_measure])\n",
    "\n",
    "    if shuffleData == True:\n",
    "        X,Y,hues = shuffle_data_alg(X,Y,hues)\n",
    "\n",
    "    if logX == True:\n",
    "        X = np.log10(X)\n",
    "\n",
    "    if colors_dict:\n",
    "        p = sns.scatterplot(x=X,y=Y,hue=hues,s=100,palette=colors_dict,legend=False)\n",
    "    elif colorDistance:\n",
    "        p = sns.scatterplot(x=X,y=Y,hue=category,hue_order=['two-sd','one-sd','lt-one-sd'],palette=['red','green','blue'],s=100)\n",
    "    else:\n",
    "        p = sns.scatterplot(x=X,y=Y,hue=hues,s=100)\n",
    "\n",
    "    # set x and ylimits, plot line of equality, and legend\n",
    "    if x_measure == y_measure:\n",
    "        p.axes.axis('square')\n",
    "        y_ticks = p.axes.get_yticks()\n",
    "        p.axes.set_xticks(y_ticks)\n",
    "        p.axes.set_yticks(p.axes.get_xticks())\n",
    "        p.axes.set_ylim(p.axes.get_xlim())\n",
    "        p.axes.set_xlim(p.axes.get_xlim())\n",
    "\n",
    "    x_lim,y_lim = [p.axes.get_xlim(),p.axes.get_ylim()]\n",
    "\n",
    "    # trendline: either equality or linear regression\n",
    "    if trendline == 'equality':\n",
    "        p.plot(x_lim,y_lim,ls=\"--\",c='k')\n",
    "        ax = plt.gca()\n",
    "        ax.get_legend().remove()\n",
    "    elif trendline == 'linreg':\n",
    "        m,b = np.polyfit(X,Y,1)\n",
    "        p.plot(p.get_xticks(),m*p.get_xticks() + b,c='k')\n",
    "        plt.text(0.1,0.7,'y = %s x + %s' %(str(np.round(m,4)),str(np.round(b,4))),fontsize=16,verticalalignment=\"top\",horizontalalignment=\"left\",transform=p.axes.transAxes)\n",
    "        ax = plt.gca()\n",
    "        ax.get_legend().remove()\n",
    "\n",
    "    elif trendline == 'groupreg':\n",
    "        for g in range(len(groups)):\n",
    "            if stat_name == 'volume':\n",
    "                slope, intercept, r_value, p_value, std_err = stats.linregress(np.log10(stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name]),stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm])\n",
    "                ax = sns.regplot(x=np.log10(stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name]),y=stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm],color=colors[groups[g]],scatter=True,line_kws={'label':\"y={0:.5f}x+{1:.4f}\".format(slope,intercept)})\n",
    "\n",
    "            else:\n",
    "                slope, intercept, r_value, p_value, std_err = stats.linregress(stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name],stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm])\n",
    "                ax = sns.regplot(x=stat[['structureID',stat_name]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[stat_name],y=stat[['structureID',dm]][stat['subjectID'].str.contains('%s_' %str(g+1))].groupby('structureID',as_index=False).mean()[dm],color=colors[groups[g]],scatter=True,line_kws={'label':\"y={0:.5f}x+{1:.4f}\".format(slope,intercept)})\n",
    "\n",
    "            ax.legend()\n",
    "\n",
    "    # compute correlation for each subject and add to plots\n",
    "    plt.text(0.1,0.9,'r = %s' %str(np.round(corr,4)),fontsize=16,verticalalignment=\"top\",horizontalalignment=\"left\",transform=p.axes.transAxes)\n",
    "\n",
    "    # compute rmse for each subject and add to plots\n",
    "    plt.text(0.1,0.8,'rmse = %s' %str(np.round(rmse,4)),fontsize=16,verticalalignment=\"top\",horizontalalignment=\"left\",transform=p.axes.transAxes)\n",
    "\n",
    "    # set title and x and y labels\n",
    "    plt.title('%s vs %s' %(x_measure,y_measure),fontsize=20)\n",
    "    plt.xlabel(x_measure,fontsize=18)\n",
    "    plt.ylabel(y_measure,fontsize=18)\n",
    "    plt.xticks(fontsize=16)\n",
    "    plt.yticks(fontsize=16)\n",
    "\n",
    "    # remove top and right spines from plot\n",
    "    p.axes.spines[\"top\"].set_visible(False)\n",
    "    p.axes.spines[\"right\"].set_visible(False)\n",
    "\n",
    "    # save image or show image\n",
    "    save_or_show_img(dir_out,x_measure,y_measure,img_name)\n",
    "    \n",
    "# this function will plot group summarized tract profile data, but can also be used with any timeseries-like data\n",
    "def plot_profiles(structures,stat,diffusion_measures,summary_method,error_method,dir_out,img_name):\n",
    "\n",
    "    # loop through all structures\n",
    "    for t in structures:\n",
    "        print(t)\n",
    "        # loop through all measures\n",
    "        for dm in diffusion_measures:\n",
    "            print(dm)\n",
    "\n",
    "            imgname=img_name+\"_\"+t+\"_\"+dm\n",
    "\n",
    "            # generate figures\n",
    "            fig = plt.figure(figsize=(15,15))\n",
    "\n",
    "            # fig.patch.set_visible(False)\n",
    "            p = plt.subplot()\n",
    "            \n",
    "            # set title and catch array for legend handle\n",
    "            plt.title(\"%s Profiles %s: %s\" %(summary_method,t,dm),fontsize=20)\n",
    "\n",
    "            # loop through groups and plot profile data\n",
    "            for g in range(len(stat.classID.unique())):\n",
    "                # x is nodes\n",
    "                x = stat['nodeID'].unique()\n",
    "\n",
    "                # y is summary (mean, median, max, main) profile data\n",
    "                if summary_method == 'mean':\n",
    "                    y = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).mean()[dm][t]\n",
    "                elif summary_method == 'median':\n",
    "                    y = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).median()[dm][t]\n",
    "                elif summary_method == 'max':\n",
    "                    y = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).max()[dm][t]\n",
    "                elif summary_method == 'min':\n",
    "                    y = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).min()[dm][t]\n",
    "\n",
    "                # error bar is either: standard error of mean (sem), standard deviation (std)\n",
    "                if error_method == 'sem':\n",
    "                    err = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).std()[dm][t] / np.sqrt(len(stat[stat['classID'] == stat.classID.unique()[g]]['subjectID'].unique()))\n",
    "                else:\n",
    "                    err = stat[stat['classID'] == stat.classID.unique()[g]].groupby(['structureID','nodeID']).std()[dm][t]\n",
    "\n",
    "                # plot summary\n",
    "                plt.plot(x,y,color=stat[stat['classID'] == stat.classID.unique()[g]]['colors'].unique()[0],linewidth=5,label=stat.classID.unique()[g])\n",
    "\n",
    "                # plot shaded error\n",
    "                plt.fill_between(x,y-err,y+err,alpha=0.2,color=stat[stat['classID'] == stat.classID.unique()[g]]['colors'].unique()[0],label='1 %s %s' %(error_method,stat.classID.unique()[g]))\n",
    "\n",
    "            # set up labels and ticks\n",
    "            plt.xlabel('Location',fontsize=18)\n",
    "            plt.ylabel(dm,fontsize=18)\n",
    "            plt.xticks([x[0],x[-1]],['Begin','End'],fontsize=16)\n",
    "            plt.legend(fontsize=16)\n",
    "            y_lim = plt.ylim()\n",
    "            plt.yticks([np.round(y_lim[0],2),np.mean(y_lim),np.round(y_lim[1],2)],fontsize=16)\n",
    "\n",
    "            # remove top and right spines from plot\n",
    "            p.axes.spines[\"top\"].set_visible(False)\n",
    "            p.axes.spines[\"right\"].set_visible(False)\n",
    "\n",
    "            # save image or show image\n",
    "            save_or_show_img(dir_out,dm,dm,imgname)\n",
    "            \n",
    "# this function will identify data within 1 sd, between 1 and 2sd, and 2 sd or greater within a scatter distrbution. intended to be used when comparing a/b\n",
    "# like analyses (i.e. test retest, validity, etc)\n",
    "def color_distance_scatter(x,y,perfectOrSlope):\n",
    "    from scipy import stats\n",
    "    import numpy as np\n",
    "    import math\n",
    "\n",
    "    ### this process creates a list of sd categories by rotating the x,y distribution\n",
    "    ### by 45 degrees (to make the slope essentially zero) and computing the standard\n",
    "    ### deviation along the y-axis. then, it identifies whether the y-data falls either\n",
    "    ### within 1 sd, within 1-2 sd, and greater than 2 sds\n",
    "    \n",
    "    # if users want to compute distribution around perfect 45 deg equality line or around\n",
    "    # the actual data slope\n",
    "    if perfectOrSlope == True:\n",
    "        m = 1\n",
    "    else:\n",
    "        m,b = np.polyfit(x,y,1)\n",
    "    \n",
    "    # compute theta as the clockwise atan rotation along m\n",
    "    theta = -math.atan(m)\n",
    "    \n",
    "    # generate rotation matrix\n",
    "    r = np.array([[np.cos(theta),-np.sin(theta)],[np.sin(theta),np.cos(theta)]])\n",
    "    \n",
    "    # compute rotation\n",
    "    [x_dif,y_dif] = r.dot(np.array([x,y]))\n",
    "\n",
    "    # set output variable (category)\n",
    "    category = []\n",
    "    \n",
    "    # compute standard deviation thresholds for difference values\n",
    "    one_sd = np.std(np.abs(y_dif))\n",
    "    two_sd = one_sd * 2\n",
    "\n",
    "    # loop through each data point and determine category (one sd: within 1 and 2 sds, two-sd: greater or equal to 2 sds, lt-one-sd: within one sd)\n",
    "    category = [ 'one-sd' if one_sd <= f < two_sd else 'two-sd' if f >= two_sd else 'lt-one-sd' for f in np.abs(y_dif) ]\n",
    "    \n",
    "    return category\n",
    "\n",
    "# this function will randomly subsample the data to make lighter visualization images\n",
    "def subsample_data(x,y,percentage):\n",
    "    \n",
    "    data = np.array([x,y])\n",
    "    subsample = np.random.choice(data.shape[1],int(len(data[0])*(percentage/100)),replace=False)\n",
    "    \n",
    "    sub_x = data[0,subsample]\n",
    "    sub_y = data[1,subsample]\n",
    "    \n",
    "    return sub_x, sub_y"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "57bc8a02",
   "metadata": {},
   "source": [
    "## Generating subject demographic dataframe\n",
    "Now that we've loaded all the functions needed, but before we get started collecting and analyzing our data, we first need to generate a subjects demographic database. This can include information stored in the participants.json file stored in the Project's Detail tab, but can also be user-generated. This is so we can then append that relevant information to each of the data structures we collect, compile, and generate for analysis. This makes it easier to build models and to perform statistical analyses with co-variates.\n",
    "\n",
    "In the case of Hayashi & Caron et al (in prep), since I was using data from multiple Big Data repositories including the Human Connectome Project, the Cambridge Centre for Ageing and Neuroscience (Cam-CAN), and the Pediatric Imaging, Neurocognition, and Genetics (PING) Dataset  I uploaded the important subject identification and demographic data directly from each project's respective repository. I scrubbed the data of most of the relevant demographic information, as I was mostly only concerned with the participant's subject ID, age, and gender.\n",
    "\n",
    "In order to ensure participant anonymity, I've only included the subjectID in the example subjects_data.csv dataframe.\n",
    "\n",
    "Within this dataframe, I've also added a classID column corresponding to the project identification name (i.e. hcp, camcan, ping) and a colors column corresponding to the color I assigned to each project (hcp: green, camcan: orange, ping: purple).\n",
    "\n",
    "After this, I then created a color dictionary with a unique color for each participant in the project. This can make outlier detection a bit easier.\n",
    "\n",
    "In this example notebook, I will be using the HCP dataset!\n",
    "\n",
    "Finally, within this section we will also set up our data and image directories."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "bb3717c8",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "setting up variables\n",
      "setting up variables complete\n",
      "grabbing demographic data\n",
      "grabbing demographic data complete\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "/tmp/ipykernel_26417/1637281729.py:28: DeprecationWarning: `np.float` is a deprecated alias for the builtin `float`. To silence this warning, use `float` by itself. Doing this will not modify any behavior and is safe. If you specifically wanted the numpy scalar type, use `np.float64` here.\n",
      "Deprecated in NumPy 1.20; for more details and guidance: https://numpy.org/devdocs/release/1.20.0-notes.html#deprecations\n",
      "  subjects_data['subjectID'] = [ str(int(np.float(f))) for f in subjects_data.subjectID ]\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>subjectID</th>\n",
       "      <th>classID</th>\n",
       "      <th>colors</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100004</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>100206</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100307</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>100408</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>100610</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1201</th>\n",
       "      <td>992774</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1202</th>\n",
       "      <td>993675</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1203</th>\n",
       "      <td>994273</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1204</th>\n",
       "      <td>995174</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1205</th>\n",
       "      <td>996782</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>1206 rows × 3 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     subjectID classID colors\n",
       "0       100004     hcp   blue\n",
       "1       100206     hcp   blue\n",
       "2       100307     hcp   blue\n",
       "3       100408     hcp   blue\n",
       "4       100610     hcp   blue\n",
       "...        ...     ...    ...\n",
       "1201    992774     hcp   blue\n",
       "1202    993675     hcp   blue\n",
       "1203    994273     hcp   blue\n",
       "1204    995174     hcp   blue\n",
       "1205    996782     hcp   blue\n",
       "\n",
       "[1206 rows x 3 columns]"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### setting up variables and adding paths\n",
    "print(\"setting up variables\")\n",
    "topPath = \"./\"\n",
    "os.chdir(topPath)\n",
    "data_dir = topPath+'/data/'\n",
    "if not os.path.exists(data_dir):\n",
    "    os.mkdir(data_dir)\n",
    "img_dir = topPath+'/img/'\n",
    "if not os.path.exists(img_dir):\n",
    "    os.mkdir(img_dir)\n",
    "\n",
    "# set up project identification (groups) and the project color (green)\n",
    "groups = ['hcp']\n",
    "colors_array = ['green']\n",
    "diff_micro_measures = ['ad','fa','md','rd','ndi','odi','isovf']\n",
    "print(\"setting up variables complete\")\n",
    "\n",
    "### grabbing subjects demographic data\n",
    "print(\"grabbing demographic data\")\n",
    "if os.path.isfile(data_dir+'/subjects_data.csv'):\n",
    "    subjects_data = pd.read_csv(data_dir+'/subjects_data.csv')\n",
    "else:\n",
    "    subjects_data = pd.read_json('input/participants.json')\n",
    "print(\"grabbing demographic data complete\")\n",
    "\n",
    "# hcp stored their subject IDs as integers instead of strings. changing that here\n",
    "if subjects_data['subjectID'].dtype == 'int':\n",
    "    subjects_data['subjectID'] = [ str(int(np.float(f))) for f in subjects_data.subjectID ]\n",
    "\n",
    "# create column for classID and colors\n",
    "subjects_data['classID'] = [ 'hcp' for f in subjects_data['subjectID'] ]\n",
    "subjects_data['colors'] = [ 'blue' for f in subjects_data['subjectID'] ]\n",
    "\n",
    "### generate colors dictionary with a unique color for each subject\n",
    "colors = {}\n",
    "subjects = {}\n",
    "\n",
    "# loop through groups and identify subjects and set color schema for each group\n",
    "for g in range(len(groups)):\n",
    "    # set subjects array\n",
    "    subjects[groups[g]] =  subjects_data['subjectID']\n",
    "    subjects[groups[g]].sort_values()\n",
    "    \n",
    "    # set colors array\n",
    "    colors_name = colors_array[g]\n",
    "    colors[groups[g]] = colors_array[g]\n",
    "\n",
    "# create subjects color dictionary\n",
    "colors_dict = create_color_dictionary(subjects_data,'subjectID','colorblind')\n",
    "\n",
    "## here's what the subjects_data dataframe looks like!\n",
    "subjects_data"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "17ce22bd",
   "metadata": {},
   "source": [
    "## Collecting functional network adjacency matrices\n",
    "The next step of the analysis pipeline for me is to collect and analyze the functional connectivity matrices generated from functional MRI. To do this, I created matrices of the functional connectivity between parcels in the Yeo17 atlas for each participant. I then computed the 'within-network' average functional connectivity for each resting-state network in the Yeo atlas within each participant. This followed procedures outlined in This data was then used in Betzel et al (2014)[https://pubmed.ncbi.nlm.nih.gov/25109530/]. This data was used in Figure XX to identify the relationship between average within-network functional connectivity and participant age."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "9998dcbd",
   "metadata": {},
   "outputs": [
    {
     "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>subjectID</th>\n",
       "      <th>FC</th>\n",
       "      <th>classID</th>\n",
       "      <th>colors</th>\n",
       "      <th>structureID</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>100307</td>\n",
       "      <td>0.256095</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "      <td>VisCent</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>100307</td>\n",
       "      <td>0.692158</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "      <td>VisPeri</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>100307</td>\n",
       "      <td>0.940064</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "      <td>SomMotA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>100307</td>\n",
       "      <td>0.535629</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "      <td>SomMotB</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>100307</td>\n",
       "      <td>0.581255</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "      <td>DorsAttnA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>...</th>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "      <td>...</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9085</th>\n",
       "      <td>329844</td>\n",
       "      <td>0.480598</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "      <td>ContB</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9086</th>\n",
       "      <td>329844</td>\n",
       "      <td>0.517073</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "      <td>ContC</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9087</th>\n",
       "      <td>329844</td>\n",
       "      <td>0.512753</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "      <td>DefaultA</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9088</th>\n",
       "      <td>329844</td>\n",
       "      <td>0.361030</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "      <td>DefaultB</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9089</th>\n",
       "      <td>329844</td>\n",
       "      <td>0.494148</td>\n",
       "      <td>hcp</td>\n",
       "      <td>blue</td>\n",
       "      <td>DefaultC</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "<p>9090 rows × 5 columns</p>\n",
       "</div>"
      ],
      "text/plain": [
       "     subjectID        FC classID colors structureID\n",
       "0       100307  0.256095     hcp   blue     VisCent\n",
       "1       100307  0.692158     hcp   blue     VisPeri\n",
       "2       100307  0.940064     hcp   blue     SomMotA\n",
       "3       100307  0.535629     hcp   blue     SomMotB\n",
       "4       100307  0.581255     hcp   blue   DorsAttnA\n",
       "...        ...       ...     ...    ...         ...\n",
       "9085    329844  0.480598     hcp   blue       ContB\n",
       "9086    329844  0.517073     hcp   blue       ContC\n",
       "9087    329844  0.512753     hcp   blue    DefaultA\n",
       "9088    329844  0.361030     hcp   blue    DefaultB\n",
       "9089    329844  0.494148     hcp   blue    DefaultC\n",
       "\n",
       "[9090 rows x 5 columns]"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "#### fmri yeo networks - max node degree vs age replication\n",
    "if os.path.isfile(data_dir+'/'+groups[0]+'_fmri_yeo_preclean_adjacency.npy'):\n",
    "    fmri_yeo_networks_adjacency = np.load(data_dir+'/'+groups[0]+'_fmri_yeo_preclean_adjacency.npy',allow_pickle=True).item()\n",
    "else:\n",
    "    fmri_yeo_networks_adjacency = collect_data('generic/network',[\"time series\"],['yeo-mni','final'],'network.json.gz',data_dir+'/'+groups[0]+'_fmri_yeo_preclean_adjacency',True)\n",
    "\n",
    "# grab label indices\n",
    "networks = ['VisCent','VisPeri','SomMotA','SomMotB','DorsAttnA','DorsAttnB','SalVentAttnA','SalVentAttnB','Limbic','ContA','ContB','ContC','DefaultA','DefaultB','DefaultC']\n",
    "with open(data_dir+'/label.json','r') as label_f:\n",
    "    labels = json.load(label_f)\n",
    "\n",
    "indices = {}\n",
    "for n in range(len(networks)):\n",
    "    indices[networks[n]] = []\n",
    "    for i in range(len(labels)):\n",
    "        netname = labels[i]['name']\n",
    "        if networks[n] in netname:\n",
    "                indices[networks[n]] = np.append(indices[networks[n]],int(i))\n",
    "\n",
    "# create average matrix\n",
    "if os.path.isfile(data_dir+'/'+groups[0]+'_fmri_yeo_preclean_adjacency_mean.npy'):\n",
    "    fmri_yeo_networks_adjacency_mean = np.load(data_dir+'/'+groups[0]+'_fmri_yeo_preclean_adjacency_mean.npy')\n",
    "else:\n",
    "    # compute mean\n",
    "    fmri_yeo_networks_adjacency_mean = compute_mean_network(fmri_yeo_networks_adjacency)\n",
    "    \n",
    "    # save dataframe\n",
    "    np.save(data_dir+'/'+groups[0]+'_fmri_yeo_preclean_adjacency_mean.npy',fmri_yeo_networks_adjacency_mean)\n",
    "    \n",
    "# compute average functional connectivity (within network) for each network in yeo17\n",
    "fmri_yeo_networks_adjacency_mean_fc = compute_mean_network_connectivity(fmri_yeo_networks_adjacency,networks,indices,\"\")\n",
    "\n",
    "fmri_yeo_networks_adjacency_mean_fc"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "84185ac9",
   "metadata": {},
   "source": [
    "## Visualizing functional connectivity matrixes\n",
    "Now that the data is collected and cleaned, the next step for me is to visualize the connectivity matrices. To do this, I'll look at functional connectivity adjacency matrix single subject (103818), and then average across all subjects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "bcded69f",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "# generate heatmap of single subject\n",
    "plt.figure()\n",
    "sns.heatmap(fmri_yeo_networks_adjacency['103818_sess1'],cmap='jet',vmin=-0.8,vmax=0.8)\n",
    "plt.savefig(img_dir+'/103818-'+groups[0]+'-functional-network-connectivity.png')\n",
    "plt.savefig(img_dir+'/103818-'+groups[0]+'-functional-network-connectivity.eps',transparent=True)\n",
    "\n",
    "# generate heatmap of average network\n",
    "plt.figure()\n",
    "sns.heatmap(fmri_yeo_networks_adjacency_mean,cmap='jet',vmin=-0.8,vmax=0.8)\n",
    "plt.savefig(img_dir+'/'+groups[0]+'-mean-functional-network-connectivity.png')\n",
    "plt.savefig(img_dir+'/'+groups[0]+'-mean-functional-network-connectivity.eps',transparent=True)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5a56a36b",
   "metadata": {},
   "source": [
    "## Removing outliers and creating reference datasets\n",
    "Once all of the appropriate data was collected, collated, and cleaned, I was now able to generate useful 'reference datasets' that can be used to identify potentially problematic participant data. I adopted a similar methodology as in the Pestilli et al (2014) LiFE paper which created \"reference datasets\", i.e. dataset of values of high-quality and high-diverse data, of properties derived from the LiFE model. The authors of this publication have released this data in the backend of the LiFE app here on brainlife.io, allowing users to directly compare their newly generated results with previously currated results.\n",
    "\n",
    "For this project, I took a similar approach across three large and diverse datasets: PING, HCP, and CAMCAN. For each data modality and structure, I computed the average value across many different models and measures including structural statistics derived from Freesurfer, diffusion microsturctural statistics derived from the DTI and NODDI models, quality assurance statistics (SNR), and network measures such as max node degree from structural connectivity measures and average functional connectivity derived from fMRI. I then identified those data points that were outside the top and bottom p% of the distribution, removed them, and recomputed the distribution. This newly cleaned distribution is the 'reference dataset' for that datatype, measure, and dataset.\n",
    "\n",
    "Following iterating through many datatypes, measures, structures, and projects, I released the final reference datasets on github and we have incorporated the data into the validators for the apps that generate those particular datatypes! This way users can directly compare their newly generated data with those I processed, analyzed, and curated!!\n",
    "\n",
    "This code can also be used to remove outliers from individual study designs, as the methods for identifying outliers and removing them from the data involves simple distribution sampling and percentile thresholding.\n",
    "\n",
    "For this notebook, I will demonstrate how to create reference dataframes from the functional parcels found in the Yeo17 atlas across all participants in the HCP."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "efcb193c",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "creating references for within-network average functional connectivity data\n",
      "DefaultA\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>structureID</th>\n",
       "      <th>subjectID</th>\n",
       "      <th>FC</th>\n",
       "    </tr>\n",
       "  </thead>\n",
       "  <tbody>\n",
       "    <tr>\n",
       "      <th>0</th>\n",
       "      <td>DefaultA</td>\n",
       "      <td>100307</td>\n",
       "      <td>0.637499</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>1</th>\n",
       "      <td>DefaultA</td>\n",
       "      <td>101915</td>\n",
       "      <td>0.602869</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>2</th>\n",
       "      <td>DefaultA</td>\n",
       "      <td>102008</td>\n",
       "      <td>0.410641</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>3</th>\n",
       "      <td>DefaultA</td>\n",
       "      <td>102109</td>\n",
       "      <td>0.477340</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>4</th>\n",
       "      <td>DefaultA</td>\n",
       "      <td>102311</td>\n",
       "      <td>0.369014</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>5</th>\n",
       "      <td>DefaultA</td>\n",
       "      <td>102513</td>\n",
       "      <td>0.470280</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>6</th>\n",
       "      <td>DefaultA</td>\n",
       "      <td>102614</td>\n",
       "      <td>0.520173</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>7</th>\n",
       "      <td>DefaultA</td>\n",
       "      <td>102715</td>\n",
       "      <td>0.461611</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>8</th>\n",
       "      <td>DefaultA</td>\n",
       "      <td>102816</td>\n",
       "      <td>0.486394</td>\n",
       "    </tr>\n",
       "    <tr>\n",
       "      <th>9</th>\n",
       "      <td>DefaultA</td>\n",
       "      <td>103010</td>\n",
       "      <td>0.476899</td>\n",
       "    </tr>\n",
       "  </tbody>\n",
       "</table>\n",
       "</div>"
      ],
      "text/plain": [
       "  structureID subjectID        FC\n",
       "0    DefaultA    100307  0.637499\n",
       "1    DefaultA    101915  0.602869\n",
       "2    DefaultA    102008  0.410641\n",
       "3    DefaultA    102109  0.477340\n",
       "4    DefaultA    102311  0.369014\n",
       "5    DefaultA    102513  0.470280\n",
       "6    DefaultA    102614  0.520173\n",
       "7    DefaultA    102715  0.461611\n",
       "8    DefaultA    102816  0.486394\n",
       "9    DefaultA    103010  0.476899"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "### creating reference datasets\n",
    "print(\"creating references for within-network average functional connectivity data\")\n",
    "\n",
    "# if empty, create references directory\n",
    "if not os.path.isdir(data_dir+'/references'):\n",
    "    os.mkdir(data_dir+'/references')\n",
    "\n",
    "# set threshold\n",
    "thrs = 99\n",
    "\n",
    "# set structure and measure\n",
    "structure = ['DefaultA']\n",
    "measure = ['FC']\n",
    "\n",
    "if os.path.isfile(data_dir+'/references/fmri_within_network_fc_'+structure[0]+'_'+groups[0]+'_'+str(thrs)+'.csv'):\n",
    "    fmri_within_network_fc_reference_dataframe = pd.read_csv(data_dir+'/references/fmri_within_network_fc_'+structure[0]+'_'+groups[0]+'_'+str(thrs)+'.csv')\n",
    "else:\n",
    "    # compute reference dataset of fmri within network FC\n",
    "    fmri_within_network_fc_measures = ['FC']\n",
    "    fmri_within_network_fc_distances, fmri_within_network_fc_outliers, fmri_within_network_fc_reference_dataframe, fmri_within_network_fc_reference_json = outlier_detection(fmri_yeo_networks_adjacency_mean_fc,structure,'structureID',measure,thrs,'emd',True,False,'',groups[0],data_dir+'/references','fmri_within_network_fc_'+structure[0]+'_'+groups[0]+'_'+str(thrs))\n",
    "\n",
    "# show datatframe\n",
    "fmri_within_network_fc_reference_dataframe.head(10)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "0cc23ddc",
   "metadata": {},
   "source": [
    "### Generating visualizations and plots of reference data\n",
    "These are visualizations describing the reference dataframe generation. For the sake of this notebook, I will just show the figures for the within-network' functional connectivity reference dataframe results from within the Default Mode - A network!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "9481ad57",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#### generate figures documenting outlier detection capabilities\n",
    "# fmri networks - average degree: DMN\n",
    "# grab default mode a network nodes and average\n",
    "default_a_preclean_df = fmri_yeo_networks_adjacency_mean_fc.loc[fmri_yeo_networks_adjacency_mean_fc['structureID'] == structure[0]]\n",
    "\n",
    "# generate distribution of volume pre outliers\n",
    "plt.figure()\n",
    "sns.violinplot(x='FC',data=default_a_preclean_df,scale='count',inner='points')\n",
    "axes = plt.gca()\n",
    "x_lim = axes.get_xlim()\n",
    "y_lim = axes.get_ylim()\n",
    "plt.savefig('./img/default_a_fc_pre_outliers_example.png')\n",
    "plt.savefig('./img/default_a_fc_pre_outliers_example.eps')\n",
    "# plt.close()\n",
    "\n",
    "# generate outliers and reference plot\n",
    "default_a_reference = fmri_within_network_fc_reference_dataframe\n",
    "\n",
    "# generate distribution of node degree with outliers\n",
    "outliers_subs = fmri_within_network_fc_outliers['subjectID'].unique()\n",
    "default_a_outliers = default_a_preclean_df.loc[default_a_preclean_df['subjectID'].isin(outliers_subs)]\n",
    "\n",
    "# plot\n",
    "plt.figure()\n",
    "sns.violinplot(x='FC',data=default_a_preclean_df,scale='count',inner='points')\n",
    "sns.swarmplot(x='FC',data=default_a_outliers,color='red')\n",
    "axes = plt.gca()\n",
    "axes.set_xlim(x_lim)\n",
    "axes.set_ylim(y_lim)\n",
    "plt.savefig('./img/default_a_fc_outliers_example.png')\n",
    "plt.savefig('./img/default_a_fc_outliers_example.eps')\n",
    "\n",
    "# generate reference\n",
    "plt.figure()\n",
    "sns.violinplot(x='FC',data=default_a_reference,scale='count',inner='points')\n",
    "axes = plt.gca()\n",
    "axes.set_xlim(x_lim)\n",
    "axes.set_ylim(y_lim)\n",
    "plt.savefig('./img/default_a_fc_reference_example.png')\n",
    "plt.savefig('./img/default_a_fc_reference_example.eps')"
   ]
  }
 ],
 "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.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}