DataViz_Scatter-AllCode.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Data visualization with Matpotlib, Seaborn, & Nilearn (oh my!)\n",
    "\n",
    "**Created by: Kirstie Whitaker**\n",
    "<br>Adapted by: Katie Bottenhorn\n",
    "\n",
    "**Created on: 29 July 2019**\n",
    "<br>Edited on: 3 Feb 2021\n",
    "\n",
    "From a manuscript in preparation about how the functional organization of the brain is related to IQ in a sample of FIU students taking their first physics course.\n",
    "\n",
    "This tutorial is going to recreate a figure that presents some the brain-behavior results from our study of the relationship between brain organization and IQ.\n",
    "\n",
    "![](https://raw.githubusercontent.com/62442katieb/NH19-Visualization/master/figures/fig4_small.png)\n",
    "<br>**[Outdated]Figure 4. Post-instruction IQ and efficiency during physics reasoning.** And are there are differences with respect to students' sex and classroom environment?\n",
    "\n",
    "### Take what you need\n",
    "\n",
    "The philosophy of the tutorial is that I'll start by making some very simple plots, and then enhance them up to \"publication standard\".\n",
    "\n",
    "You should take _only the parts you need_ and leave the rest behind.\n",
    "If you don't care about fancy legends, or setting the number of minor x ticks, then you can stop before we get to that part.\n",
    "\n",
    "The goal is to have you leave the tutorial feeling like you know _how_ to get started writing code to visualize and customise your plots.\n",
    "\n",
    "## There are so many good resources available online!\n",
    "\n",
    "Seaborn has a [rich gallery](https://seaborn.pydata.org/examples/index.html) with example code & data for creating a wide variety of plots.\n",
    "\n",
    "Nilearn provides a [similar resource](http://nilearn.github.io/plotting/index.html) for making figures with brains."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Import modules\n",
    "\n",
    "We're importing everything up here.\n",
    "And they should all be listed in the [requirements.txt](requirements.txt) file in this repository.\n",
    "Checkout the [README](README.md) file for more information on installing these packages."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from IPython.display import display\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "%matplotlib inline\n",
    "import numpy as np\n",
    "import os\n",
    "import pandas as pd\n",
    "from statsmodels.formula.api import ols\n",
    "import seaborn as sns\n",
    "\n",
    "from nilearn import plotting\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The task\n",
    "\n",
    "In this study we asked introductory physics students at FIU to lie in an fMRI scanner and complete aseries of memory and reasoning tasks.\n",
    "\n",
    "The task we'll focus on here required students to engage in physics reasoning to answer conceptual questions about Newtonian mechanics from the Force Concept Inventory (FCI).\n",
    "\n",
    "* The **FCI** questions (shown on the left in the figure below) showed diagrams of  \n",
    "\n",
    "* The **control** questions (shown on the right in the figure below) were the control questions and the participants were simply asked asked perceptual questions, etc. that required little to no reasoning.\n",
    "\n",
    "![](https://raw.githubusercontent.com/62442katieb/NH19-Visualization/master/figures/FCI-example.png)\n",
    "\n",
    "The answers to the **FCI** question are demonstrate different conceptions about the laws of physics.\n",
    "\n",
    "The answers to the **control** questions are pretty straightforward.\n",
    "\n",
    "### Hypothesis\n",
    "1. There is a relationship between IQ and brain organization while students are answering reasoning questions, but not while students are answering control questions.\n",
    "2. These relationships are different with respect to the course type (active learning vs. lecture) in which the students were enrolled."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## With great power comes great responsibility\n",
    "\n",
    "I've listed some hypotheses above.\n",
    "We can't confirm or reject them by visualizing the data.\n",
    "\n",
    "Just because a line _looks_ like it is going up or down, doesn't mean it is statistically significantly doing so.\n",
    "\n",
    "You can tell many stories with a picture...including ones that mislead people very easily.\n",
    "\n",
    "Be careful!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The data\n",
    "\n",
    "The data is stored in the `data/small_data.csv` file, which a subset of the variables from the larger study.\n",
    "\n",
    "It contains a subset of variables from a much wider dataset, for ease of use.\n",
    "\n",
    "The important columns are:\n",
    "\n",
    "* `age_scan`\n",
    "* `start_level`\n",
    "* `female`\n",
    "* `modeling`\n",
    "* `post_phys_cpl`\n",
    "* `post_ctrl_cpl`\n",
    "* `head_size`\n",
    "* `post_phys_fd`\n",
    "* `post_ctrl_fd`\n",
    "* `post_fsiq`\n",
    "\n",
    "The first three variables are demographic information (age, year in school, and sex), the third, `modeling`, is the course type in which the student was enrolled (1: active learning class, 0: traditional lecture class).\n",
    "\n",
    "The `post_fsiq` variable contains post-instruction IQ scores.\n",
    "\n",
    "The `post_phys_cpl` and `post_ctrl_cpl` variable has each subject's post-instruction characteristic path length measure (describes ease of brain-wide functional integration) computed from fMRI data collected _while_ they performed the aforementioned task under FCI and control conditions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": false
   },
   "outputs": [],
   "source": [
    "# Read in the data\n",
    "df = pd.read_csv('data/small_data.csv', index_col=0)\n",
    "\n",
    "# Take a look at the first 5 rows\n",
    "print ('====== Here are the first 5 rows ======')\n",
    "display(df.head())\n",
    "\n",
    "# Print all of the columns - its a big wide file 😬\n",
    "print ('\\n\\n\\n====== Here are all the columns in the file======')\n",
    "display(df.columns)\n",
    "\n",
    "# And now lets see the summary information of this subset of the data\n",
    "print ('\\n\\n\\n====== Here are some summary statistics from the columns we need ======')\n",
    "\n",
    "display(df.describe())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# normalizing path length\n",
    "df['post_phys_cpl_norm'] = (df['post_phys_cpl'] - np.mean(df['post_phys_cpl'].values))/np.std(df['post_phys_cpl'].values)\n",
    "df['post_ctrl_cpl_norm'] = (df['post_ctrl_cpl'] - np.mean(df['post_ctrl_cpl'].values))/np.std(df['post_ctrl_cpl'].values)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## A quick scatter plot\n",
    "\n",
    "The first thing we'll do is take a look at our first hypothesis: that brain organization during physics reasoning, but not during control courses, is associated with IQ.\n",
    "\n",
    "Lets start by making a scatter plot with **IQ** on the x axis and **characteristic path length during physics reasoning** on the y axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(df['post_fsiq'], df['post_phys_cpl_norm'])  # <----- A simple scatter plot"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cool, what about the relationship between IQ and path length during the control condition?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm']) # <----- Update to pull from a differen column"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's nice, but it would probably be more useful if we put these two on the _same_ plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(df['post_fsiq'], df['post_phys_cpl_norm']) # <----- Both of the commands above\n",
    "plt.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm']) #        on consecutive lines"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Woah, that was very clever!\n",
    "\n",
    "Matplotlib didn't make two different plots, it assumed that I would want these two plots on the same axis because they were in the same cell.\n",
    "\n",
    "If I had called `plt.show()` inbetween the two lines above I would have ended up with two plots: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.scatter(df['post_fsiq'], df['post_phys_cpl_norm'])\n",
    "plt.show() # <---------------------------------------- Show plot in the middle of the two commands\n",
    "plt.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Being a little more explicit\n",
    "\n",
    "The scatter plot above shows how easy it is to plot some data - for example to check whether you have any weird outliers or if the pattern of results generally looks the way you'd expect.\n",
    "\n",
    "You can stop here if your goal is to explore the data ✨\n",
    "\n",
    "But some times you'll want to have a bit more control over the plots, and for that we'll introduce the concepts of a matplotlib `figure` and an `axis`.\n",
    "\n",
    "To be honest, we aren't really going to introduce them properly because that's a deeeeeep dive into the matplotlib object-orientated architecture.\n",
    "There's a nice tutorial at [https://matplotlib.org/users/artists.html](https://matplotlib.org/users/artists.html), but all you need to know is that a **figure** is a figure - the canvas on which you'll make your beautiful visualisation - and it can contain multiple **axes** displaying different aspects or types of data.\n",
    "\n",
    "In fact, that makes it a little easier to understand why the way that many people create a figure and an axis is to use the [`subplots`](https://matplotlib.org/api/_as_gen/matplotlib.pyplot.subplots.html#matplotlib.pyplot.subplots) command.\n",
    "(And here's a [stack overflow answer](https://stackoverflow.com/questions/34162443/why-do-many-examples-use-fig-ax-plt-subplots-in-matplotlib-pyplot-python) which explains it in a little more depth.)\n",
    "\n",
    "If you run the command all by itself, you'll make an empty axis which takes up the whole figure area:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots() # <--------- A simple set up"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets add our plots to a figure:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots() # <------------------------------- A simple set up\n",
    "ax.scatter(df['post_fsiq'], df['post_phys_cpl_norm']) # <------- The commands above\n",
    "ax.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'])\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Did you see that this time we changed `plt.scatter` to `ax.scatter`? \n",
    "\n",
    "That's because we're being more specific about _where_ we want the data to be plotted.\n",
    "Specifically, we want it on the first (only) axis in our figure.\n",
    "\n",
    "We also got explicit about telling jupyter to show the plot with `plt.show()`.\n",
    "You don't need this, but its good practice for when you start coding lots of plots all in one go and don't want them to all appear on the same axis 😂"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = df.sort_values(by='post_fsiq', axis=0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Let's add a regression line\n",
    "\n",
    "I used [`statsmodels`](https://www.statsmodels.org/stable/index.html) to fit the model and to get the predicted values. \n",
    "\n",
    "I'm gonna throw a few more variables in the mix, too, to make sure our differences in topology aren't related to head motion or head and IQ isn't confounded by head size."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FCI\n",
    "formula_phys = 'post_phys_cpl_norm ~ post_fsiq'\n",
    "mod_phys = ols(formula=formula_phys, data=df)\n",
    "results_phys = mod_phys.fit()\n",
    "print(results_phys.summary())\n",
    "predicted_phys = results_phys.predict()\n",
    "print('\\nPredicted Y, physics:\\n', predicted_phys)\n",
    "\n",
    "# Control\n",
    "formula_ctrl = 'post_ctrl_cpl_norm ~ post_fsiq'\n",
    "mod_ctrl = ols(formula=formula_ctrl, data=df)\n",
    "results_ctrl = mod_ctrl.fit()\n",
    "print(results_ctrl.summary())\n",
    "predicted_ctrl = results_ctrl.predict()\n",
    "print('\\nPredicted Y, control:\\n', predicted_ctrl)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lets plot that modelled pattern on our scatter plot. But with added regression lines! And for that, we'll use `ax.plot` instead of `ax.scatter`, and the good 'ol `y = mx + b`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df['post_fsiq'], df['post_phys_cpl_norm'])\n",
    "ax.plot(df['post_fsiq'], predicted_phys)\n",
    "ax.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'])\n",
    "ax.plot(df['post_fsiq'], predicted_ctrl)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That looks fine, but the lines are a little thin... let's bump things up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df['pred_phys_cpl'] = predicted_phys\n",
    "df['pred_ctrl_cpl'] = predicted_ctrl"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df['post_fsiq'], df['post_phys_cpl_norm'])\n",
    "ax.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'])\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_phys_cpl'], \n",
    "        linewidth = 5) # <----- Add linewidth arguement\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_ctrl_cpl'], \n",
    "        linewidth = 5) # <----- Add linewidth arguement\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Add a legend\n",
    "\n",
    "These two lines aren't labelled!\n",
    "We don't know which one is which.\n",
    "\n",
    "So lets add a legend to the plot.\n",
    "\n",
    "The function is called `ax.legend()` and we don't tell it the labels directly, we actually add those as _attributes_ of the scatter plots by adding `label`s."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "ax.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_phys_cpl'], \n",
    "        linewidth = 5)\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_ctrl_cpl'], \n",
    "        linewidth = 5)\n",
    "ax.legend() # <------- Add legend\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Except I don't want the lines labeled, because that's redundant."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "ax.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_phys_cpl'], \n",
    "        linewidth = 5, label='')\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_ctrl_cpl'], \n",
    "        linewidth = 5, label='') # <------- Add empty label\n",
    "ax.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Woah! The label moved!\n",
    "\n",
    "The legend positioning is very clever, matplotlib has put it in the location with the fewest dots, which changed based on its size!\n",
    "\n",
    "Here's the [documentation](https://matplotlib.org/3.1.1/api/_as_gen/matplotlib.pyplot.legend.html) that shows you how to be explicit about where to put the legend.\n",
    "The default value for `loc` is `best`, and we can happily keep that for the rest of this notebook.\n",
    "\n",
    "If you really wanted to put it somewhere else, you can set the location explicitly.\n",
    "For example, in the center on the right hand side."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "ax.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_phys_cpl'], \n",
    "        linewidth = 5, label='')\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_ctrl_cpl'], \n",
    "        linewidth = 5, label='')\n",
    "ax.legend(loc='center right') # <-------- Move the legend\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Oof, that's terrible.\n",
    "\n",
    "Where's a good place to put it?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "ax.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_phys_cpl'], \n",
    "        linewidth = 5, label='')\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_ctrl_cpl'], \n",
    "        linewidth = 5, label='')\n",
    "ax.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Change the colors\n",
    "\n",
    "The fact that our physics reasoning data (dots) and regression line are both blue, and that the control data are both orange, is a consequence of the order in which we've asked matplotlib to plot the data.\n",
    "\n",
    "At the moment, matplotlib is coloring the first scatter plot with its first default color, and the second with the second default color.\n",
    "\n",
    "Then when we give it a different type of plot (`plot` vs `scatter`) it starts the color cycle again.\n",
    "(You can see the order of the colours in the [documentation of when they were introduced](https://matplotlib.org/3.1.1/users/dflt_style_changes.html#colors-in-default-property-cycle).)\n",
    "\n",
    "If we move the order of the two regression lines the colours will change:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.scatter(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_phys_cpl'], \n",
    "        linewidth = 5, label='')\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_ctrl_cpl'], \n",
    "        linewidth = 5, label='') # <----- switched the order of phys & ctrl\n",
    "ax.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "So that's no good!\n",
    "\n",
    "Let's explicitly set the colors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df['post_fsiq'], df['post_phys_cpl_norm'],\n",
    "           label = 'Physics', color = 'red') # <--------- Add the color\n",
    "ax.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'],\n",
    "           label = 'Control', color = 'blue') # <--------- Add the color\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_phys_cpl'], \n",
    "        linewidth = 5, label='', color='red')\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_ctrl_cpl'], \n",
    "        linewidth = 5, label='', color='blue')\n",
    "ax.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Cool....the colours are fixed....but wow those aren't nice to look at 😕"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Introducing Seaborn!\n",
    "[Seaborn](https://seaborn.pydata.org) is a Python data visualization library based on matplotlib.\n",
    "It provides a high-level interface for drawing attractive and informative statistical graphics.\n",
    "\n",
    "It does many beautiful things (a few of which we're going to explore) but it can sometimes be so clever that it becomes a little opaque.\n",
    "\n",
    "If in doubt, remember that seaborn will almost always return an `axis` object for you, and you can change those settings just as you would in matplotlib.\n",
    "\n",
    "In fact, all that work we just did with matplot lib could be done _very_ simply with Seaborn's `regplot`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import seaborn as sns"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Color management with Seaborn\n",
    "\n",
    "One of the very nice things that seaborn does is manage colors easily.\n",
    "\n",
    "The red and blue that I used in the published figure came from the [\"Set1\" Brewer color map](http://colorbrewer2.org/#type=qualitative&scheme=Set1&n=5).\n",
    "\n",
    "We can get the RGB values for the colors in this qualitative color map from seaborn's `color_palette` function, and visualize them using the \"palette plot\" (`palplot`) function."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "color_list = sns.color_palette(\"Set1\", n_colors=5)\n",
    "\n",
    "for color in color_list:\n",
    "    print(color)\n",
    "\n",
    "sns.palplot(color_list)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Ok, now that we have our much nicer colors, let's change the red and blue in our accuracy plot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "ax.scatter(df['post_fsiq'], df['post_phys_cpl_norm'],\n",
    "           label = 'Physics', color = color_list[0]) # <--------- Update color\n",
    "ax.scatter(df['post_fsiq'], df['post_ctrl_cpl_norm'],\n",
    "           label = 'Control', color = color_list[1]) # <---------- Update color\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_phys_cpl'], \n",
    "        linewidth = 5, label='', color = color_list[0]) # <----------------- Update color\n",
    "ax.plot(df['post_fsiq'], \n",
    "        df['pred_ctrl_cpl'], \n",
    "        linewidth = 5, label='', color = color_list[1]) # <----------------- Update color\n",
    "\n",
    "ax.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But, wait! There's more! Seaborn makes pretty plots, we can use the `reglplot()` function to replace the `scatter()` and `plot()` above!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig,ax = plt.subplots()\n",
    "sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics', color = color_list[0])\n",
    "sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control', color = color_list[1])\n",
    "ax.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Really jazzing up the plot with seaborn\n",
    "\n",
    "1. I don't like those colors and I really liked the Seaborn `regplot` more than these matplotlib plots.\n",
    "2. Seaborn has _so many_ cooler color options. Even if we stick with red & blue (see: [crayon_palette](https://seaborn.pydata.org/generated/seaborn.crayon_palette.html#seaborn.crayon_palette)).\n",
    "3. Another other two really beautiful things that seaborn can do is set the **context** of the plot, and the figure **style**.\n",
    "\n",
    "There are lots of great examples in the [aesthetics tutorial](https://seaborn.pydata.org/tutorial/aesthetics.html) which I really encourage you to have a play around with.\n",
    "\n",
    "Let's check out the `poster` context, with a `darkgrid` background."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_context(\"poster\", font_scale=1)\n",
    "sns.set_style('darkgrid')\n",
    "sns.set_palette(color_list) # <--- now we don't have to manually set colors anymore"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now that we've run the code above, lets re-make our scatter plot:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wowzers trousers. \n",
    "That's no good 😬\n",
    "\n",
    "How about `notebook` context with a `ticks` background?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_context(\"notebook\", font_scale=1)\n",
    "sns.set_style('ticks')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Fun, we've got back to the matplotlib default!\n",
    "\n",
    "I think my favorite style setting is `notebook` context with a `font_scale` of 1.5 and the `whitegrid` style."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_context(\"notebook\", font_scale=1.5)\n",
    "sns.set_style('whitegrid')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And I'm picky about colors. Luckily, Seaborn's got [options](https://seaborn.pydata.org/tutorial/color_palettes.html). Two of my favorite color paletting options are `crayon_palette` and `husl_palette`. \n",
    "\n",
    "You can use Crayola crayon names to make a palette:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "crayola = sns.crayon_palette(['Red Orange', 'Cerulean'])\n",
    "sns.palplot(crayola)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.set_palette(crayola)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.legend(loc='best')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When you run the `set_context` and `set_style` commands they become global settings for all plots that you subsequently make in the same notebook (or script).\n",
    "\n",
    "Personally I load them in at the top of all my notebooks because I think they make the plots look nicer 💁‍♀️\n",
    "\n",
    "Oh, and I like the plots [despined](https://seaborn.pydata.org/tutorial/aesthetics.html#removing-axes-spines) too, so lets do that real quick:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.legend(loc='best')\n",
    "sns.despine() # <------------------ Despine the plot\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Axis labels, limits and tick placement\n",
    "\n",
    "### Labels\n",
    "\n",
    "Our plots have ugly axis labels!\n",
    "Nobody should have to interpret our ugly variable names.\n",
    "\n",
    "Let's go ahead and label them 😸"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.set_xlabel('Full-scale IQ (normalized)') # <--------------- Set x axis label\n",
    "ax.set_ylabel('Path length (normalized)') # <--------- Set y axis label\n",
    "ax.legend(loc='best')\n",
    "sns.despine()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Limits\n",
    "\n",
    "One of the things that's really nice to do is to be able to set the min and max values for a figure.\n",
    "\n",
    "At the moment, matplotlib is guessing at a good place to start and stop the axes.\n",
    "And it's doing a great job...but what if you wanted to show a subset of the data?\n",
    "If the minimum or maxium age or reaction time values were different then you'd end up with slightly different dimensions on the x and y axes.\n",
    "\n",
    "Let's see what it's guessing:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "print ('X min and max: {:2.2f}, {:2.2f}'.format(*ax.get_xlim())) # <------ Print x axis limits\n",
    "print ('Y min and max: {:2.2f}, {:2.2f}'.format(*ax.get_ylim())) # <------ Print y axis limits\n",
    "ax.set_xlabel('Full-scale IQ (normalized)') # <--------------- Set x axis label\n",
    "ax.set_ylabel('Path length (normalized)')\n",
    "ax.legend(loc='best')\n",
    "sns.despine()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Tick placement\n",
    "\n",
    "Seaborn and matplotlib have made a good guess at where to put the x and y ticks, and in this case, the ticks work.\n",
    "\n",
    "But for the sake of illustration, let's shake things up."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.set_xticks([80, 90, 100, 110, 120, 130, 140, 150]) # <----------------------- Set x tick positions \n",
    "ax.set_xlabel('Full-scale IQ (normalized)') # <--------------- Set x axis label\n",
    "ax.set_ylabel('Path length (normalized)')\n",
    "ax.legend(loc='best')\n",
    "sns.despine()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Yeah, that looks a little busy. But now you know!\n",
    "\n",
    "For the y ticks we can use the ticker `locator_params` to put them in the best place for getting a maximum of 6 ticks.\n",
    "\n",
    "This is basically what matplotlib is already doing, but I'll show you the command just in case you want to use it in the future.\n",
    "\n",
    "For example, if you wanted to force the plot to have 4 bins, you'd set `nbins` to 4:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.locator_params(nbins=4, axis='y') # <----------------------- Set y tick positions \n",
    "ax.set_xlabel('Full-scale IQ (normalized)') # <--------------- Set x axis label\n",
    "ax.set_ylabel('Path length (normalized)')\n",
    "ax.legend(loc='best')\n",
    "sns.despine()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And note that even when we set `nbins` to 6 (as I wrote in the original figure code), it actually only gives us 5 ticks, because matplotlib - correctly - can't find a sensible way to parse the range to give us 6 evenly spaced ticks on they y axis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics')\n",
    "sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control')\n",
    "ax.locator_params(nbins=6, axis='y') # <----------------------- Set y tick positions \n",
    "ax.set_xlabel('Full-scale IQ (normalized)')\n",
    "ax.set_ylabel('Path length (normalized)')\n",
    "ax.legend(loc='best')\n",
    "sns.despine()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "One quick point to remember here: the x and y axis **limits** are not the same as the **tick locations**.\n",
    "The limits are the edges of the plot.\n",
    "The tick locations are where the markers sit on the axes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Remember our second hypothesis, though?\n",
    "\n",
    "A second hypothesis that these relationships between the brain & IQ are different with respect to the course type (active learning vs. lecture) in which the students were enrolled.\n",
    "\n",
    "Let's beef up our regressions..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# FCI\n",
    "formula_phys = '''post_phys_cpl_norm ~ \n",
    "                    post_fsiq + post_fsiq * modeling + post_fsiq * female + \n",
    "                    post_fsiq * female * modeling + female * modeling + \n",
    "                    head_size + post_phys_fd + age_scan + start_level'''\n",
    "mod_phys = ols(formula=formula_phys, data=df)\n",
    "results_phys = mod_phys.fit()\n",
    "print(results_phys.summary())\n",
    "\n",
    "# Control\n",
    "formula_ctrl = '''post_ctrl_cpl_norm ~ \n",
    "                    post_fsiq + post_fsiq * modeling + post_fsiq * female + \n",
    "                    post_fsiq * female * modeling + female * modeling + \n",
    "                    head_size + post_ctrl_fd + age_scan + start_level'''\n",
    "mod_ctrl = ols(formula=formula_ctrl, data=df)\n",
    "results_ctrl = mod_ctrl.fit()\n",
    "print(results_ctrl.summary())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `plt.subplots`, we can actually add panels (or subplots) to a single figure. I'm going to separate FCI and control conditions so we can dive into class effects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=2, sharey=True, sharex=True)\n",
    "g = sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics', ax=ax[0])\n",
    "h = sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control', ax=ax[1])\n",
    "\n",
    "g.set_xlabel('Full-scale IQ') \n",
    "g.set_ylabel('Path length (FCI)')\n",
    "h.set_xlabel('Full-scale IQ') \n",
    "h.set_ylabel('Path length (Control)')\n",
    "sns.despine()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots(nrows=1, ncols=2, sharey=True, sharex=True, figsize=(10,5)) # Make it  bigger\n",
    "g = sns.regplot(df['post_fsiq'], df['post_phys_cpl_norm'], label = 'Physics', ax=ax[0])\n",
    "h = sns.regplot(df['post_fsiq'], df['post_ctrl_cpl_norm'], label = 'Control', ax=ax[1])\n",
    "\n",
    "g.set_xlabel('Full-scale IQ') \n",
    "g.set_ylabel('Path length (FCI)')\n",
    "h.set_xlabel('Full-scale IQ') \n",
    "h.set_ylabel('Path length (Control)')\n",
    "sns.despine()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "🚀🌟🚀🌟🚀🌟🚀🌟🚀🌟🚀🌟\n",
    "\n",
    "Fantastic!\n",
    "We've made a two-panel plot!\n",
    "Just like that.\n",
    "\n",
    "Seaborn has really neat ways to make multi-paneled plots, though. So we're going to switch from `regplot` to `lmplot`, which further simplifies our code.\n",
    "\n",
    "However, seaborn handles data a little differently. What we have right now is _wide_ data, with lots of columns and only one row per participant. Some Seaborn functions want _long_ data, which can get a little tricky..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can make our data long by just manipulating this dataframe a bit. \n",
    "\n",
    "Manipulating dataframes is a little tricky, but a valuable skill that you'll end up using much more frequently than you'd like to admit..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_long = df.melt(id_vars=['modeling', 'female', 'post_fsiq'], value_vars=['post_phys_cpl_norm', 'post_ctrl_cpl_norm'],\n",
    "                 var_name='condition')\n",
    "df_long.replace(to_replace='post_phys_cpl_norm', value='Physics', inplace=True)\n",
    "df_long.replace(to_replace='post_ctrl_cpl_norm', value='Control', inplace=True)\n",
    "\n",
    "df_long.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And now we're replacing `1` and `0` in our `modeling` and `female` variables, because we're done running stats, now we're just on to visualizing. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df_long.replace({'modeling':{0: 'Lecture', 1:'Active'}, \n",
    "                 'female': {0: 'Male', 1: 'Female'}}, inplace=True)\n",
    "df_long.rename({'modeling': 'Class type',\n",
    "                'female': 'Sex'}, axis=1, inplace=True)\n",
    "df_long.head()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Using `lmplot` instead of `regplot`, we'll plot our two conditions (FCI, Control) next to each other in one figure in only one line of code! 😱<br><br>While `regplot()` and `lmplot()` are closely related functions, the former is an axes-level function while the latter is a figure-level function that combines `regplot()` and `FacetGrid`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.lmplot('post_fsiq', 'value', df_long, col='condition')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now let's see what the relationships between path length and IQ look like during fci and control conditions in the two separate classes using the `hue` flag, which separates data by color along the categorical variable specified (`'Class type'`, in this case)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.lmplot('post_fsiq', 'value', df_long, col='condition', row='Sex', hue='Class type')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "That's all well and good, but the spacing and the axes are a little off. That's because `lmplot` and other Seaborn grid plots wrap the `fig,ax = plt.subplots()` line we had been including, and they have their own defaults. Let's adjust some of these defaults..."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sns.lmplot('post_fsiq', 'value', df_long, col='condition', hue='Class type', row='Sex',\n",
    "           sharex=False, sharey=False) # <---- now we're not constraining the axes\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And let's fix the labels again. It's a little trickier, now, because we're not directly manipulating the axes, we're manipulating an object that contains the axes. This means instead of `ax.set_ylabel` and `ax.set_xlabel`, we have to use the functions associated with `lmplot()`. In this case, these are `set_titles()` and `set_axis_labels`, which are pretty self-explanatory."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "j = sns.lmplot('post_fsiq', 'value', df_long, col='condition', hue='Class type', row='Sex',\n",
    "               sharex=False, sharey=False)\n",
    "j.set_titles(template='{row_name} students, {col_name}')\n",
    "j.set_axis_labels('Path Length (normalized)', 'Full-scale IQ')\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And, dear friends, what good would making all these pretty plots be if we couldn't save them?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "j.savefig('figures/finished_fig.png', dpi=300) #<---- can also save as an .svg, if you like vectors"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Seaborn has many more options for plotting, and very helpful galleries & tutorials for creating beautiful & descriptive plots.<br>\n",
    "\n",
    "<p>\n",
    "    <h3>Distributions and kernel density plots</h3>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/kde_ridgeplot.png\" style=\"height: 200px; float: left;\"/>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/histogram_stacked.png\" style=\"height: 200px; float: left;\" display=\"block\"/>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/palette_generation.png\" style=\"height: 200px; float: left;\"display=\"block\"/>\n",
    "</p>\n",
    "<br><br><br><br><br><br><br><br><br><br>\n",
    "<p>\n",
    "    <h3>Line plots (with error bands!)</h3>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/errorband_lineplots.png\" style=\"height: 200px;\" align=\"left\"/>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/wide_data_lineplot.png\" style=\"height: 200px;\" align=\"left\"/>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/timeseries_facets.png\" style=\"height: 200px;\" align=\"left\"/>\n",
    "</p>\n",
    "<br><br><br><br><br><br><br><br><br><br>\n",
    "<p>\n",
    "    <h3>Box, swarm, and violin/rainfall plots</h3>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/grouped_boxplot.png\" style=\"height: 200px;\" align=\"left\"/>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/scatterplot_categorical.png\" style=\"height: 200px;\" align=\"left\"/>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/grouped_violinplots.png\" style=\"height: 200px;\" align=\"left\"/>\n",
    "</p>\n",
    "<br><br><br><br><br><br><br><br><br><br>\n",
    "<p>\n",
    "    <h3>Radial plots!</h3><br>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/radial_facets.png\" style=\"height: 200px;\" align=\"left\"/>\n",
    "</p>\n",
    "<br><br><br><br><br><br><br><br><br><br>\n",
    "<p>\n",
    "    <h3>And heatmaps!</h3><br>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/many_pairwise_correlations.png\" style=\"height: 200px;\" align=\"left\"/>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/spreadsheet_heatmap.png\" style=\"height: 200px;\" align=\"left\"/>\n",
    "    <img src=\"https://seaborn.pydata.org/_images/structured_heatmap.png\" style=\"height: 200px;\" align=\"left\"/>\n",
    "</p>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Brain plot?\n",
    "\n",
    "We've talked a lot about brains, but... all I've made are scatter plots?\n",
    "\n",
    "You can spend as much time making brain plots as I just have making scatter plots. I'm just going to show you one two that make brain slices and surfaces, respectively, but there's a whole gallery of different options available from [nilearn](http://nilearn.github.io/plotting/index.html), which has a while module of `plotting` functions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nilearn import plotting"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Nilearn's basic plotting functions (for displaying results) are:\n",
    "- `plot_anat()`: plots structural/T1w images\n",
    "- `plot_epi()`: plots functional/epi images\n",
    "- `plot_stat_map()`: plots statistical images on a structural template\n",
    "- `plot_glass_brain()`: plots statistical images on a glass brain template\n",
    "- `plot_connectome()`: plots connectivity between brain regions on a glass brain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nilearn has a lot of good, good data you can import directly into a jupyter notebook or python script. We're going to use the `fetch_haxby()` function to grab a block-design fMRI dataset from a study on face and object representation in human ventral temporal cortex.\n",
    "\n",
    "You can also use local files in any of these plotting functions by just using the file path as an argument, which is just so convenient."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nilearn import datasets\n",
    "\n",
    "# haxby dataset to have EPI images and masks\n",
    "haxby_dataset = datasets.fetch_haxby()\n",
    "\n",
    "# print basic information on the dataset\n",
    "print('First subject anatomical nifti image (3D) is at: %s' %\n",
    "      haxby_dataset.anat[0])\n",
    "print('First subject functional nifti image (4D) is at: %s' %\n",
    "      haxby_dataset.func[0])  # 4D data\n",
    "\n",
    "haxby_anat_filename = haxby_dataset.anat[0]\n",
    "haxby_mask_filename = haxby_dataset.mask_vt[0]\n",
    "haxby_func_filename = haxby_dataset.func[0]\n",
    "\n",
    "# one motor contrast map from NeuroVault\n",
    "motor_images = datasets.fetch_neurovault_motor_task()\n",
    "stat_img = motor_images.images[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can visualize results from a motor task used with this dataset either on an MNI template brain or on a glass brain: "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotting.plot_stat_map(stat_img, threshold=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotting.plot_glass_brain(stat_img, threshold=3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotting.plot_stat_map(stat_img, display_mode='z') # <---- change display mode, cut coodinates, # slices"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotting.plot_stat_map(stat_img, display_mode='z', cmap='magma') # <---- change colors!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "But I really like visualizing things on brain surfaces. Nilearn's got a function for that!\n",
    "\n",
    "First, we need a brain surface model. I'm going to grab Freesurfer's average surface and an example statistical map. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fsaverage = datasets.fetch_surf_fsaverage()\n",
    "stat_img = motor_images.images[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we'll resample these stats results to this surface."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nilearn import surface\n",
    "\n",
    "texture = surface.vol_to_surf(stat_img, fsaverage.pial_right)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "k = plotting.plot_surf_stat_map(fsaverage.infl_right, texture, hemi='right',\n",
    "                            title='Surface right hemisphere', colorbar=True,\n",
    "                            bg_map=fsaverage.sulc_right, threshold=1.)\n",
    "k.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's compare to a plot of slices?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l = plotting.plot_stat_map(stat_img, display_mode='z', threshold=1.)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "And, finally, you can use Nilearn's `plotting.view_surf()` for an interactive, surface-based figure!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "view = plotting.view_surf(fsaverage.infl_right, texture, threshold='90%',\n",
    "                          bg_map=fsaverage.sulc_right)\n",
    "view"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The end. Well done 💖"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}