<SYSTEM_TASK:>
Given the following text description, write Python code to implement the functionality described below step by step
<END_TASK>
<USER_TASK:>
Description:
 Simple example of decoding
Step1:  Prepare the data
Step2:  The decoding
Step3:  Compute prediction scores using cross-validation
Step4:  Retrieve the discriminating weights and save them
Step5:  Visualize the discriminating weights over the mean EPI
Step6:  Plot also the mask that was computed by the NiftiMasker
<ASSISTANT_TASK:>
Python Code:
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]
Explanation: Simple example of decoding: the Haxby data
Here is a simple example of decoding, reproducing the Haxby 2001
study on a face vs cat discrimination task in a mask of the ventral
stream.
Retrieve and load the Haxby dataset
End of explanation
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]
print(fmri_masked.shape)
# it is a substantially reduced dataset.
print(fmri_masked)
print(target)
Explanation: Prepare the data: apply the mask
End of explanation
# 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)
Explanation: The decoding
End of explanation
print(prediction);
print(target - prediction)
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)
Explanation: Compute prediction scores using cross-validation
End of explanation
# 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')
Explanation: Retrieve the discriminating weights and save them
End of explanation
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")
Explanation: Visualize the discriminating weights over the mean EPI
End of explanation
plot_roi(nifti_masker.mask_img_, mean_epi, title="Mask", display_mode="yx")
show()
Explanation: Plot also the mask that was computed by the NiftiMasker
End of explanation
<END_TASK>