Nilearn_tutorial_2018_1_Nilearn101.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "%matplotlib inline"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Goals of today's tutorial\n",
    "==============\n",
    "\n",
    "This tutorial will cover the basics of using Nilearn to do machine learning with neuroimages. It is meant for people who do not necessarily have a background in programming. \n",
    "\n",
    "Because the tutorial is at a Resting-State and Brain Connectivity conference, we will focus primarily on using resting-state brain connectivity data.\n",
    "\n",
    "The specific goals of the day are broken into three sections:\n",
    "\n",
    "### Section 1: Nilearn 101\n",
    "* Use Python in a Jupyter notebook\n",
    "* Learn about the Nilearn API\n",
    "* Understand the difference between data stored in memory and data stored on disk\n",
    "* Load, plot and save 3D images\n",
    "\n",
    "### Section 2: Extracting features with Nilearn\n",
    "* Load and plot 4D images\n",
    "* Learn to extract rs-fmri data into connectivity features for machine learning\n",
    "\n",
    "### Section 3: Machine learning with Nilearn\n",
    "* Prepare a dataset for machine learning (i.e. train/test splits)\n",
    "* Build and validate a machine learning model\n",
    "* Use machine learning to predict unseen data\n",
    "* Interpret the features of a machine learning model"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A few housekeeping notes:\n",
    "\n",
    "Lots of fantastic tutorials exists on the Nilearn website. Learning to use Nilearn almost certainly starts here!\n",
    "https://nilearn.github.io/index.html\n",
    "\n",
    "If things go poorly on your computer, join us online using Google Colab:\n",
    "*insert link here*\n",
    "\n",
    "Don't be afraid to ask questions! We have TAs to help out. And stop me if I'm going to fast!\n",
    "\n",
    "Don't forget, nobody ever writes error-free code!\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Section 1: Nilearn 101\n",
    "============\n",
    "\n",
    "Here, we will learn how to run Python code in Jupyter notebooks, and learn a bit about how to use Nilearn"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Let's use this space to play a bit with Jupyter"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Basic nilearn example: manipulating and looking at data\n",
    "A simple example showing how to load an existing Nifti file and use\n",
    "basic nilearn functionalities."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Let's use a Nifti file that is shipped with nilearn\n",
    "from nilearn.datasets import MNI152_FILE_PATH\n",
    "\n",
    "# Note that the variable MNI152_FILE_PATH is just a path to a Nifti file\n",
    "print('Path to MNI152 template: %r' % MNI152_FILE_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### A first step: looking at our data\n",
    "Let's quickly plot this file:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nilearn import plotting\n",
    "plotting.plot_img(MNI152_FILE_PATH)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Simple image manipulation: smoothing\n",
    "\n",
    "Let's use an image-smoothing function from nilearn:\n",
    ":func:`nilearn.image.smooth_img`\n",
    "\n",
    "Functions containing 'img' can take either a filename or an image as input.\n",
    "\n",
    "Here we give as inputs the image filename and the smoothing value in mm"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from nilearn import image\n",
    "smooth_anat_img = image.smooth_img(MNI152_FILE_PATH, fwhm=3)\n",
    "\n",
    "# While we are giving a file name as input, the function returns\n",
    "# an in-memory object:\n",
    "print(smooth_anat_img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "This is an in-memory object. We can pass it to nilearn function, for instance to look at it"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plotting.plot_img(smooth_anat_img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We could also pass it to the smoothing function"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "more_smooth_anat_img = image.smooth_img(smooth_anat_img, fwhm=3)\n",
    "plotting.plot_img(more_smooth_anat_img)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a moment to think about the relative merits of in-memory vs. on disk"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(smooth_anat_img.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x,y,z = smooth_anat_img.shape\n",
    "print(x*y*z)\n",
    "# frames = \n",
    "# subjects = "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now imagine the size of a 4D image!"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Saving results to a file\n",
    "\n",
    "We can save any in-memory object as follows:\n",
    "\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "more_smooth_anat_img.to_filename('more_smooth_anat_img.nii.gz')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "**Exercise**: Try plotting one of your own files. In the above,\n",
    "MNI152_FILE_PATH is nothing more than a string with a path pointing to\n",
    "a nifti image. You can replace it with a string pointing to a file on\n",
    "your disk. Note that it should be a 3D volume, and not a 4D volume."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Try to plot your own file here:"
   ]
  }
 ],
 "metadata": {
  "anaconda-cloud": {},
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.6.2"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 1
}