diff --git a/dypac/__init__.py b/dypac/__init__.py index ae914bd..70b4d76 100644 --- a/dypac/__init__.py +++ b/dypac/__init__.py @@ -3,4 +3,16 @@ from dypac.embeddings import Embedding from dypac.bascpp import replicate_clusters, find_states, stab_maps from dypac.tests import test_bascpp, test_dypac -__all__ = ['Dypac', 'test_bascpp', 'test_dypac', 'replicate_clusters', 'find_states', 'stab_maps', 'Embedding'] +from dypac.masker import LabelsMasker, MapsMasker + +__all__ = [ + "Dypac", + "test_bascpp", + "test_dypac", + "replicate_clusters", + "find_states", + "stab_maps", + "Embedding", + "LabelsMasker", + "MapsMasker", +] diff --git a/dypac/dypac.py b/dypac/dypac.py index 024fe51..bf80980 100644 --- a/dypac/dypac.py +++ b/dypac/dypac.py @@ -301,7 +301,7 @@ def fit(self, imgs, confounds=None): if self.n_batch > len(imgs): warnings.warn( "{0} batches were requested, but only {1} datasets available. Using {2} batches instead.".format( - self.n_batch, len(imgs), self.n_batch + self.n_batch, len(imgs), len(imgs) ) ) self.n_batch = len(imgs) diff --git a/dypac/embeddings.py b/dypac/embeddings.py index 4887932..5bdf716 100644 --- a/dypac/embeddings.py +++ b/dypac/embeddings.py @@ -1,6 +1,6 @@ import numpy as np from sklearn.preprocessing import StandardScaler - +from sklearn.linear_model import Lasso, Ridge def miss_constant(X, precision=1e-10): """Check if a constant vector is missing in a vector basis.""" @@ -8,7 +8,7 @@ def miss_constant(X, precision=1e-10): class Embedding: - def __init__(self, X, add_constant=True): + def __init__(self, X, add_constant=True, method='ols', **kwargs): """ Transformation to and from an embedding. @@ -18,7 +18,21 @@ def __init__(self, X, add_constant=True): The vector basis defining the embedding (each row is a vector). add_constant: boolean - Add a constant vector to the vector basis, if none is present. + Add a constant vector (intercept) to the vector basis, if none is + present. + + method: string, default 'ols' + The type of embedding. + 'ols' ordinary least-squares - based on numpy pinv + 'lasso' lasso regression (l1 regularization) + based on sklearn.linear_model.Lasso + 'ridge' Ridge regression (l2 regularization) + based on sklearn.linear_model.Ridge + + kwargs: dict, optional + keyword arguments passed to the embedding method, e.g. Lasso. + Note: 'fit_intercept' is forced to False in Lasso and cannot be + changed. Use `add_constant` instead. Attributes ---------- @@ -34,6 +48,8 @@ def __init__(self, X, add_constant=True): """ self.size = X.shape[0] + self.method = method + self.kwargs = kwargs # Once we have the embedded representation beta, the inverse transform # is a simple linear mixture: # Y_hat = beta * X @@ -42,22 +58,47 @@ def __init__(self, X, add_constant=True): self.inverse_transform_mat = np.concatenate([np.ones([1, X.shape[1]]), X]) else: self.inverse_transform_mat = X - # The embedded representation beta is also derived by a simple linear - # mixture Y * P, where P is the pseudo-inverse of X - # We store P as our transform matrix - self.transform_mat = np.linalg.pinv(self.inverse_transform_mat) + + if self.method == 'ols': + # The embedded representation beta is derived by a simple linear + # mixture Y * P, where P is the pseudo-inverse of X + # We store P as our transform matrix + self.transform_mat = np.linalg.pinv(self.inverse_transform_mat) + + elif self.method == 'lasso': + self.transform_mat = Lasso(**self.kwargs) + elif self.method == 'ridge': + self.transform_mat = Ridge(**self.kwargs) + else: + raise ValueError( + f"{self.method} is an unknown embedding method" + ) def transform(self, data): """Project data in embedding space.""" - # Given Y, we get - # beta = Y * P - return np.matmul(data, self.transform_mat) + if self.method == 'ols': + # Given Y, we get + # beta = Y * P + emb = np.asarray(np.matmul(data, self.transform_mat)) + elif self.method == 'lasso': + self.transform_mat.fit( + self.inverse_transform_mat.transpose(), data.transpose(), + check_input=False + ) + emb = self.transform_mat.coef_.copy(order='C') + elif self.method == 'ridge': + self.transform_mat.fit( + self.inverse_transform_mat.transpose(), data.transpose() + ) + emb = self.transform_mat.coef_.copy(order='C') + + return emb def inverse_transform(self, embedded_data): """Project embedded data back to original space.""" # Given beta, we get: # Y_hat = beta * X - return np.matmul(embedded_data, self.inverse_transform_mat) + return np.asarray(np.matmul(embedded_data, self.inverse_transform_mat)) def compress(self, data): """Embedding compression of data in original space.""" diff --git a/dypac/masker.py b/dypac/masker.py new file mode 100644 index 0000000..6891ffe --- /dev/null +++ b/dypac/masker.py @@ -0,0 +1,257 @@ +from dypac.embeddings import Embedding +from sklearn.preprocessing import OneHotEncoder +from nilearn.image import resample_to_img +from nilearn.maskers import NiftiMasker +from nilearn.maskers._masker_validation import _check_embedded_nifti_masker + +class BaseMasker: + + def __init__(self, masker): + """ + Build a Dypac-like masker from labels. + + Parameters + ---------- + masker: + a nilearn NiftiMasker. + + Attributes + ---------- + masker_: + The nilearn masker + """ + self.masker_ = masker + + def _check_components_(self): + """Check for presence of estimated components.""" + if not hasattr(self, "components_"): + raise ValueError( + "Object has no components_ attribute. " + "This is probably because fit has not " + "been called." + ) + + + def load_img(self, img, confound=None): + """ + Load a 4D image using the same preprocessing as model fitting. + + Parameters + ---------- + img : Niimg-like object. + See http://nilearn.github.io/manipulating_images/input_output.html + An fMRI dataset + + Returns + ------- + img_p : Niimg-like object. + Same as input, after the preprocessing step used in the model have + been applied. + """ + self._check_components_() + tseries = self.masker_.transform([img], [confound]) + return self.masker_.inverse_transform(tseries[0]) + + def transform(self, img, confound=None): + """ + Transform a 4D dataset in a component space. + + Parameters + ---------- + img : Niimg-like object. + See http://nilearn.github.io/manipulating_images/input_output.html + An fMRI dataset + confound : CSV file or 2D matrix, optional. + Confound parameters, to be passed to nilearn.signal.clean. + + Returns + ------- + weights : numpy array of shape [n_samples, n_states + 1] + The fMRI tseries after projection in the parcellation + space. Note that the first coefficient corresponds to the intercept, + and not one of the parcels. + """ + self._check_components_() + tseries = self.masker_.transform([img], [confound]) + del img + return self.embedding_.transform(tseries[0]) + + def inverse_transform(self, weights): + """ + Transform component weights as a 4D dataset. + + Parameters + ---------- + weights : numpy array of shape [n_samples, n_states + 1] + The fMRI tseries after projection in the parcellation + space. Note that the first coefficient corresponds to the intercept, + and not one of the parcels. + + Returns + ------- + img : Niimg-like object. + The 4D fMRI dataset corresponding to the weights. + """ + self._check_components_() + return self.masker_.inverse_transform(self.embedding_.inverse_transform(weights)) + + def compress(self, img, confound=None): + """ + Provide the approximation of a 4D dataset after projection in parcellation space. + + Parameters + ---------- + img : Niimg-like object. + See http://nilearn.github.io/manipulating_images/input_output.html + An fMRI dataset + confound : CSV file or 2D matrix, optional. + Confound parameters, to be passed to nilearn.signal.clean. + + Returns + ------- + img_c : Niimg-like object. + The 4D fMRI dataset corresponding to the input, compressed in the parcel space. + """ + self._check_components_() + tseries = self.masker_.transform([img], [confound]) + del img + return self.masker_.inverse_transform(self.embedding_.compress(tseries[0])) + + def score(self, img, confound=None): + """ + R2 map of the quality of the compression. + + Parameters + ---------- + img : Niimg-like object. + See http://nilearn.github.io/manipulating_images/input_output.html + An fMRI dataset + confound : CSV file or 2D matrix, optional. + Confound parameters, to be passed to nilearn.signal.clean. + + Returns + ------- + score : Niimg-like object. + A 3D map of R2 score of the quality of the compression. + + Note + ---- + The R2 score map is the fraction of the variance of fMRI time series captured + by the parcels at each voxel. A score of 1 means perfect approximation. + The score can be negative, in which case the parcellation approximation + performs worst than the average of the signal. + """ + self._check_components_() + tseries = self.masker_.transform([img], [confound]) + del img + return self.masker_.inverse_transform(self.embedding_.score(tseries[0])) + + +class LabelsMasker(BaseMasker): + + def __init__(self, masker, labels_img, method='ols'): + """ + Build a Dypac-like masker from labels. + + Parameters + ---------- + + masker nilearn NiftiMasker object + See https://nilearn.github.io/modules/generated/nilearn.input_data.NiftiMasker.html + This masker is used to extract the time series prior to dimension + reduction. The brain mask from the masker is re-used as well. + + labels_img: + a brain volumes with parcels (labels). + + method: string, default 'ols' + The type of embedding. + 'ols' ordinary least-squares - based on numpy pinv + 'lasso' lasso regression (l1 regularization) + based on sklearn.linear_model.Lasso + 'ridge' Ridge regression (l2 regularization) + based on sklearn.linear_model.Ridge + + Attributes + ---------- + components_: + each column is a onehot encoder for one of the parcels. + + embedding_: + see the class Embedding from Dypac. + """ + + self.masker_ = _check_embedded_nifti_masker(masker) + # Forwarding potential attribute of provided masker + if hasattr(masker, 'mask_img_'): + # Allow free fit of returned mask + self.masker_.mask_img_ = masker.mask_img_ + + labels_r = resample_to_img(source_img=labels_img, + target_img=masker.mask_img_, interpolation="nearest") + nifti_masker = NiftiMasker( + mask_img=masker.mask_img_, + standardize=False, + smoothing_fwhm=None, + detrend=False, + memory="nilearn_cache", + memory_level=1, + ) + labels_mask = nifti_masker.fit_transform(labels_r) + self.components_ = OneHotEncoder().fit_transform(labels_mask.transpose()) + self.embedding_ = Embedding(self.components_.todense().transpose(), method=method) + + +class MapsMasker(BaseMasker): + + def __init__(self, masker, maps_img, method='ols'): + """ + Build a Dypac-like masker from a collection of brain maps. + + Parameters + ---------- + masker nilearn NiftiMasker object + See https://nilearn.github.io/modules/generated/nilearn.input_data.NiftiMasker.html + This masker is used to extract the time series prior to dimension + reduction. The brain mask from the masker is re-used as well. + + maps_img: 4D niimg-like object + See http://nilearn.github.io/manipulating_images/input_output.html + Set of continuous maps. One representative time course per map is + extracted using least square regression. + + method: string, default 'ols' + The type of embedding. + 'ols' ordinary least-squares - based on numpy pinv + 'lasso' lasso regression (l1 regularization) + based on sklearn.linear_model.Lasso + 'ridge' Ridge regression (l2 regularization) + based on sklearn.linear_model.Ridge + + Attributes + ---------- + components_: + each column is brain map, after masking + + embedding_: + see the class Embedding from Dypac. + """ + self.masker_ = _check_embedded_nifti_masker(masker) + # Forwarding potential attribute of provided masker + if hasattr(masker, 'mask_img_'): + # Allow free fit of returned mask + self.masker_.mask_img_ = masker.mask_img_ + + maps_r = resample_to_img(source_img=maps_img, + target_img=self.masker_.mask_img_, interpolation="continuous") + nifti_masker = NiftiMasker( + mask_img=self.masker_.mask_img_, + standardize=False, + smoothing_fwhm=None, + detrend=False, + memory="nilearn_cache", + memory_level=1, + ) + maps_mask = nifti_masker.fit_transform(maps_r) + self.components_ = maps_mask.transpose() + self.embedding_ = Embedding(self.components_.transpose(), method=method) diff --git a/examples/demo_cneuromod_masker.ipynb b/examples/demo_cneuromod_masker.ipynb new file mode 100644 index 0000000..29d3650 --- /dev/null +++ b/examples/demo_cneuromod_masker.ipynb @@ -0,0 +1,464 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/pbellec/.virtualenvs/dypac/local/lib/python3.6/site-packages/nilearn/__init__.py:69: FutureWarning: Python 3.6 support is deprecated and will be removed in release 0.10 of Nilearn. Consider switching to Python 3.8 or 3.9.\n", + " _python_deprecation_warnings()\n" + ] + } + ], + "source": [ + "import os\n", + "from dypac.masker import LabelsMasker, MapsMasker\n", + "from nilearn.plotting import plot_roi, plot_stat_map\n", + "from nilearn import datasets" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fetch a cneuromod preprocessed dataset. Here we use a motor run (because it's short). " + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "# This is on elm\n", + "path_cneuromod = '/data/neuromod/DATA/cneuromod/hcptrt/derivatives/fmriprep-20.2lts/fmriprep/sub-01/ses-001/func/'\n", + "file_epi = os.path.join(path_cneuromod, 'sub-01_ses-001_task-motor_run-1_space-MNI152NLin2009cAsym_desc-preproc_bold.nii.gz')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The cneuromod data has low level of motion, so we use a simple denoising strategy, adding a basic global signal regression. This strategy takes up few degrees of freedom, and is quite efficient at reducing motion artifacts. We use the new `load_confounds_strategy` module in nilearn:" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "from nilearn.interfaces.fmriprep import load_confounds_strategy\n", + "conf = load_confounds_strategy(file_epi, denoise_strategy='simple', global_signal='basic')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dypac 256 atlas - projection of 4D data" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We start by pointing to the dypac models which have been precomputed on the friends-s01 dataset. For each subject, there are parcellations at different resolutions (256, 512, 1024), as well as a mask of the grey matter and a copy of the corresponding T1w individual image for visualization (after non-linear registration in the MNI ICBM asym template)." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "path_dypac = '/data/cisl/pbellec/models'\n", + "file_mask = os.path.join(path_dypac, 'sub-01_space-MNI152NLin2009cAsym_label-GM_mask.nii.gz')\n", + "file_dypac = os.path.join(path_dypac, 'sub-01_space-MNI152NLin2009cAsym_desc-dypac256_components.nii.gz')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We first need to build a nilearn `NiftiMasker`. This masker is going to specify how to preprocess the data. Here we just use a simple smoothing, because the rest of the denoising will be taken care of by confound regression." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NiftiMasker(mask_img='/data/cisl/pbellec/models/sub-01_space-MNI152NLin2009cAsym_label-GM_mask.nii.gz',\n", + " smoothing_fwhm=5, standardize=True)" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nilearn.maskers import NiftiMasker\n", + "masker = NiftiMasker(standardize=True, detrend=False, smoothing_fwhm=5, mask_img=file_mask)\n", + "masker.fit(file_epi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we create a dypac masker. It uses the `NiftiMasker` we just created, as well as the nifti image of the dypac parcels, in order to create a new object. This object has the `transform` and `inverse_transform` methods which are common in nilearn maskers, as well as a few extra helper methods, see below." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "maps_masker = MapsMasker(masker=masker, maps_img=file_dypac)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's visualize one parcel. They are stored using the `NiftiMasker` defined above, which is available in the attribute `masker_`." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/pbellec/.virtualenvs/dypac/local/lib/python3.6/site-packages/nilearn/plotting/img_plotting.py:348: FutureWarning: Default resolution of the MNI template will change from 2mm to 1mm in version 0.10.0\n", + " anat_img = load_mni152_template()\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_stat_map(maps_masker.masker_.inverse_transform(maps_masker.components_[:, 5].transpose()))" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To load the data in parcellation space, we only need to use the `transform` method of the dypac masker. We have 144 time points x 256 parcels, so in parcellation space this dataset is very small. " + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(144, 256)" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tseries = maps_masker.transform(img=file_epi, confound=conf[0])\n", + "tseries.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "we can also map a vector of values back to voxel space using `inverse_transform`:" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "data_vec = tseries[0, :]\n", + "img_avg = maps_masker.inverse_transform(data_vec)\n", + "plot_stat_map(img_avg)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "One of the helper method can compute a R2 map of quality of time series compression. This means that we compare the original voxel `tseries` to the result of `inverse_transform(transform(img))` using the parcel projection." + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "r2_map = maps_masker.score(img=file_epi, confound=conf[0])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "When visualization this map, we see that there are partial volume effect and a lot of heterogeneity spatially in the quality of compression, but some part of the brain are compressed with very high R2. " + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "90th percentile R2: 0.5892444546410469\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "plot_stat_map(r2_map, vmax=1)\n", + "r2_val = NiftiMasker(standardize=False, mask_img=masker.mask_img).fit_transform(r2_map)\n", + "print(f'90th percentile R2: {np.percentile(r2_val, 90)}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Dypac projection of a single map " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We can use the dypac masker to project single brain maps, for example activation maps. But we need to turn off the temporal standardization for that: " + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NiftiMasker(mask_img='/data/cisl/pbellec/models/sub-01_space-MNI152NLin2009cAsym_label-GM_mask.nii.gz',\n", + " smoothing_fwhm=5)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nilearn.maskers import NiftiMasker\n", + "masker = NiftiMasker(standardize=False, smoothing_fwhm=5, mask_img=file_mask)\n", + "masker.fit(file_epi)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's illustrate how this compression works using a mean EPI image: " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "from nilearn.image import mean_img \n", + "epi_mean = mean_img(file_epi)\n", + "data_mean = masker.transform(epi_mean)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here we've simply read the values with our `NiftiMasker`, and we use the `inverse_transform` method to visualize the masked value back on a brain." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_stat_map(masker.inverse_transform(data_mean), vmax=20000, cut_coords=[1, -17, 26])" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now we create a dypac masker, and we use the `compress` method. What this does is project the brain map into the space of the parcels, and then use `inverse_transform` (but this time for parcels), to get back a voxel representation." + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "maps_masker = MapsMasker(masker=masker, maps_img=file_dypac)\n", + "epi_projected = maps_masker.compress(epi_mean)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "we visualize the compressed brain map. We can see that the compressed map does capture the main feature of the original, voxel level map. In terms of dimensionality, we went from about 100k voxel values in the grey matter mask to 256 values in parcellation space." + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_stat_map(epi_projected, vmax=20000, cut_coords=[1, -17, 26])" + ] + } + ], + "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.6.9" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/examples/demo_dypac_masker.ipynb b/examples/demo_dypac_masker.ipynb new file mode 100644 index 0000000..53186fd --- /dev/null +++ b/examples/demo_dypac_masker.ipynb @@ -0,0 +1,651 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "from dypac.masker import LabelsMasker, MapsMasker\n", + "from nilearn.plotting import plot_roi, plot_stat_map\n", + "from nilearn import datasets" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Fetch a preprocessed dataset from the ADHD sample to show how to use the DYPAC masker." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/pbellec/env/dypac/lib/python3.8/site-packages/nilearn/datasets/func.py:250: VisibleDeprecationWarning: Reading unicode strings without specifying the encoding argument is deprecated. Set the encoding, use None for the system default.\n", + " phenotypic = np.genfromtxt(phenotypic, names=True, delimiter=',',\n" + ] + } + ], + "source": [ + "from nilearn import datasets\n", + "n_subjects = 1\n", + "dev_dataset = datasets.fetch_adhd(n_subjects=n_subjects)\n", + "epi_filename = dev_dataset.func[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# \"hard parcels\": the Schaefer atlas" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We fetch the Schaefer atlas using nilearn." + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "atlas = datasets.fetch_atlas_schaefer_2018()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The first thing we need to do is create a nilearn `NiftiMasker`. This masker is used to load voxel-level data, and all preprocessing is based on that step. If the fMRI data was preprocessed with fMRIprep, make sure to load confounds using one of the [nilearn strategies](https://nilearn.github.io/stable/modules/generated/nilearn.interfaces.fmriprep.load_confounds_strategy.html#nilearn.interfaces.fmriprep.load_confounds_strategy). " + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NiftiMasker(detrend=True, standardize=True)" + ] + }, + "execution_count": 4, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nilearn.maskers import NiftiMasker\n", + "masker = NiftiMasker(standardize=True, detrend=True)\n", + "masker.fit(epi_filename)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "to create the dypac masker, we simply combine the `NiftiMasker` with the Schaeffer parcels. Because these are hard (binary, non-overlapping) parcels, we use `LabelsMasker` from dypac." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "labels_masker = LabelsMasker(masker=masker, labels_img=atlas.maps)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Now let's apply the masker to turn the fMRI dataset in a time series array, with 176 time steps x 402 regions:" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(176, 402)" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tseries = labels_masker.transform(epi_filename)\n", + "tseries.shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "it's also possible to map a vector of parcel values back into a voxel brain map:" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/pbellec/env/dypac/lib/python3.8/site-packages/nilearn/plotting/img_plotting.py:348: FutureWarning: Default resolution of the MNI template will change from 2mm to 1mm in version 0.10.0\n", + " anat_img = load_mni152_template()\n" + ] + }, + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data_vec = tseries[0, :] # pick the first volume\n", + "data_img = labels_masker.inverse_transform(data_vec)\n", + "plot_stat_map(data_img)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "The `LabelsMasker` embeds internally a vectorized representation of the Schaeffer atlas. It's possible to reconstruct these maps using the embedded `NiftiMasker`, as follows:" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_roi(labels_masker.masker_.inverse_transform(labels_masker.components_[:,2].todense().transpose()), resampling_interpolation='nearest')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another helper function is going to compare the preprocessed voxel based time series `tseries` with the result of a compression using parcel level data, i.e. `inverse_transform(transform(img))`. " + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [], + "source": [ + "r2_map = labels_masker.score(img=[epi_filename])" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average R2: 0.08262607125083415\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "plot_stat_map(r2_map, vmax=1)\n", + "r2_val = NiftiMasker(standardize=False, mask_img=masker.mask_img).fit_transform(r2_map)\n", + "print(f'Average R2: {np.mean(r2_val)}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# \"soft\" parcels: the ICA atlas from Smith et al. (2009)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This section of the tutorial simply repeats the steps from the Schaeffer atlas, but using `MapsMasker` for weigthed parcels, rather than `LabelsMasker` which is used for hard parcels. We illustrate the behavior of that procedure with ICA maps from the Smith et al. (2009) paper. Because the steps are identical, there are no comments and just the code." + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "ica_maps = datasets.fetch_atlas_smith_2009()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NiftiMasker(detrend=True, standardize=True)" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nilearn.maskers import NiftiMasker\n", + "masker = NiftiMasker(standardize=True, detrend=True)\n", + "masker.fit(epi_filename)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [], + "source": [ + "maps_masker = MapsMasker(masker=masker, maps_img=ica_maps.rsn70)" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(176, 71)" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tseries = maps_masker.transform(epi_filename)\n", + "tseries.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data_vec = tseries[0, :] # pick the first volume\n", + "data_img = maps_masker.inverse_transform(data_vec)\n", + "plot_stat_map(data_img)" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_stat_map(maps_masker.masker_.inverse_transform(maps_masker.components_[:, 5].transpose()))" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [], + "source": [ + "r2_map = maps_masker.score(img=epi_filename)" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average R2: 0.06549398006910229\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "plot_stat_map(r2_map, vmax=1)\n", + "r2_val = NiftiMasker(standardize=False, mask_img=masker.mask_img).fit_transform(r2_map)\n", + "print(f'Average R2: {np.mean(r2_val)}')" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "# Difumo" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "That section of the tutorial is identical to the one on ICA embeddings, but this time with the probabilistic parcels of difumo." + ] + }, + { + "cell_type": "code", + "execution_count": 19, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/home/pbellec/env/dypac/lib/python3.8/site-packages/nilearn/datasets/atlas.py:129: UserWarning: `legacy_format` will default to `False` in release 0.11. Dataset fetchers will then return pandas dataframes by default instead of recarrays.\n", + " warnings.warn(_LEGACY_FORMAT_MSG)\n" + ] + } + ], + "source": [ + "difumo_maps = datasets.fetch_atlas_difumo(dimension=1024)" + ] + }, + { + "cell_type": "code", + "execution_count": 20, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "NiftiMasker(detrend=True, standardize=True)" + ] + }, + "execution_count": 20, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "from nilearn.maskers import NiftiMasker\n", + "masker = NiftiMasker(standardize=True, detrend=True)\n", + "masker.fit(epi_filename)" + ] + }, + { + "cell_type": "code", + "execution_count": 21, + "metadata": {}, + "outputs": [], + "source": [ + "maps_masker = MapsMasker(masker=masker, maps_img=difumo_maps.maps)" + ] + }, + { + "cell_type": "code", + "execution_count": 22, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(176, 1025)" + ] + }, + "execution_count": 22, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "tseries = maps_masker.transform(epi_filename)\n", + "tseries.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 23, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 23, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "data_vec = tseries[0, :] # pick the first volume\n", + "data_img = maps_masker.inverse_transform(data_vec)\n", + "plot_stat_map(data_img)" + ] + }, + { + "cell_type": "code", + "execution_count": 24, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 24, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "plot_stat_map(maps_masker.masker_.inverse_transform(maps_masker.components_[:, 5].transpose()))" + ] + }, + { + "cell_type": "code", + "execution_count": 25, + "metadata": {}, + "outputs": [], + "source": [ + "r2_map = maps_masker.score(img=epi_filename)" + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Average R2: 0.16092547722834316\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "import numpy as np\n", + "plot_stat_map(r2_map, vmax=1)\n", + "r2_val = NiftiMasker(standardize=False, mask_img=masker.mask_img).fit_transform(r2_map)\n", + "print(f'Average R2: {np.mean(r2_val)}')" + ] + } + ], + "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.8.10" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}