In [1]:
%matplotlib inline
Retrieve and load the Haxby dataset
In [2]:
from nilearn import datasets
# if you download these from python.
haxby_dataset = datasets.fetch_haxby()
# print basic information on the dataset
print('First subject anatomical nifti image (3D) is at: %s' %
haxby_dataset.anat[0])
print('First subject functional nifti images (4D) are at: %s' %
haxby_dataset.func[0]) # 4D data
# Load the behavioral labels
import numpy as np
# Load target information as string and give a numerical identifier to each
labels = np.recfromcsv(haxby_dataset.session_target[0], delimiter=" ")
# scikit-learn >= 0.14 supports text labels. You can replace this line by:
# target = labels['labels']
_, target = np.unique(labels['labels'], return_inverse=True)
# Keep only data corresponding to faces or cats
condition_mask = np.logical_or(labels['labels'] == b'face',
labels['labels'] == b'cat')
target = target[condition_mask]
Prepare the data: apply the mask
In [3]:
from nilearn.input_data import NiftiMasker
# ventro-temporal mask -> it is a transformer -> 3D images => 2D feature spaces
mask_filename = haxby_dataset.mask_vt[0]
# For decoding, standardizing is often very important
nifti_masker = NiftiMasker(mask_img=mask_filename, standardize=True)
func_filename = haxby_dataset.func[0]
# We give the nifti_masker a filename and retrieve a 2D array ready
# for machine learning with scikit-learn
fmri_masked = nifti_masker.fit_transform(func_filename)
# Restrict the classification to the face vs cat discrimination
fmri_masked = fmri_masked[condition_mask]
In [11]:
print(fmri_masked.shape)
# it is a substantially reduced dataset.
print(fmri_masked)
print(target)
The decoding
In [15]:
# Here we use a Support Vector Classification, with a linear kernel
from sklearn.svm import SVC
# set the kernel type
svc = SVC(kernel='linear')
# And we run it
print(target.shape)
print(fmri_masked.shape)
svc.fit(fmri_masked, target)
prediction = svc.predict(fmri_masked)
len(target)
Out[15]:
Compute prediction scores using cross-validation
In [17]:
print(prediction);
print(target - prediction)
In [20]:
from sklearn.cross_validation import KFold
cv = KFold(n=len(fmri_masked), n_folds=5)
cv_scores = []
for train, test in cv:
svc.fit(fmri_masked[train], target[train])
prediction = svc.predict(fmri_masked[test])
cv_scores.append(np.sum(prediction == target[test])
/ float(np.size(target[test])))
print(cv_scores)
Retrieve the discriminating weights and save them
In [21]:
# Retrieve the SVC discriminating weights
coef_ = svc.coef_
# Reverse masking thanks to the Nifti Masker
coef_img = nifti_masker.inverse_transform(coef_)
# Save the coefficients as a Nifti image
coef_img.to_filename('haxby_svc_weights.nii')
Visualize the discriminating weights over the mean EPI
In [22]:
from nilearn.image import mean_img
from nilearn.plotting import plot_roi, plot_stat_map, show
mean_epi = mean_img(func_filename)
plot_stat_map(coef_img, mean_epi, title="SVM weights", display_mode="yx")
Out[22]:
Plot also the mask that was computed by the NiftiMasker
In [23]:
plot_roi(nifti_masker.mask_img_, mean_epi, title="Mask", display_mode="yx")
show()
In [ ]: