MNT update notebooks

TomDLT · TomDLT · commit a9ceac6e07d2 · 2021-09-10T11:16:39.000-07:00
diff --git a/tutorials/notebooks/movies_3T/00_load_colab.ipynb b/tutorials/notebooks/movies_3T/00_load_colab.ipynb
@@ -33,14 +33,14 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Change runtime to use a GPU\n\nThis tutorial is much faster when a GPU is available to run the computations.\nIn Google Colab you can request access to a GPU by changing the runtime type. \nTo do so, click the following menu options in Google Colab: \n\n(Menu) \"Runtime\" -> \"Change runtime type\" -> \"Hardware accelerator\" -> \"GPU\".\n\n"
+        "## Change runtime to use a GPU\n\nThis tutorial is much faster when a GPU is available to run the computations.\nIn Google Colab you can request access to a GPU by changing the runtime type.\nTo do so, click the following menu options in Google Colab:\n\n(Menu) \"Runtime\" -> \"Change runtime type\" -> \"Hardware accelerator\" -> \"GPU\".\n\n"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Download the data and install all required dependencies\n\nUncomment and run the following cell to download the tutorial data and\ninstall the required dependencies\n\n"
+        "## Download the data and install all required dependencies\n\nUncomment and run the following cell to download the tutorial data and\ninstall the required dependencies.\n\n"
       ]
     },
     {
@@ -51,14 +51,14 @@
       },
       "outputs": [],
       "source": [
-        "# !gdown --id 1b0I0Ytj06m6GCmfxfNrZuyF97fDo3NZb && \\\n# tar xzf vim-5-for-ccn.tar.gz && \\\n# pip install -q voxelwise_tutorials && \\\n# git clone https://github.com/gallantlab/pycortex"
+        "# ![ -f \"vim-5-for-ccn.tar.gz\" ] || gdown --id 1b0I0Ytj06m6GCmfxfNrZuyF97fDo3NZb\n# ![ -d \"vim-5\" ] || tar xzf vim-5-for-ccn.tar.gz\n# ![ -d \"pycortex\" ] || git clone https://github.com/gallantlab/pycortex\n# !pip install -q voxelwise_tutorials"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Now run the following cell to set up the environment variables for the tutorials\nand pycortex.\n\n"
+        "Now run the following cell to set up the environment variables for the\ntutorials and pycortex.\n\n"
       ]
     },
     {
diff --git a/tutorials/notebooks/movies_3T/05_plot_banded_ridge_model.ipynb b/tutorials/notebooks/movies_3T/05_plot_banded_ridge_model.ipynb
@@ -76,6 +76,24 @@
         "import numpy as np\n\nfrom voxelwise_tutorials.io import load_hdf5_array\n\nfile_name = os.path.join(directory, \"responses\", f\"{subject}_responses.hdf\")\nY_train = load_hdf5_array(file_name, key=\"Y_train\")\nY_test = load_hdf5_array(file_name, key=\"Y_test\")\n\nprint(\"(n_samples_train, n_voxels) =\", Y_train.shape)\nprint(\"(n_repeats, n_samples_test, n_voxels) =\", Y_test.shape)"
       ]
     },
+    {
+      "cell_type": "markdown",
+      "metadata": {},
+      "source": [
+        "We also compute the explainable variance, to exclude voxels with low\nexplainable variance from the fit, and speed up the model fitting.\n\n"
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "collapsed": false
+      },
+      "outputs": [],
+      "source": [
+        "from voxelwise_tutorials.utils import explainable_variance\nev = explainable_variance(Y_test)\nprint(\"(n_voxels,) =\", ev.shape)\n\nmask = ev > 0.1\nprint(\"(n_voxels_mask,) =\", ev[mask].shape)"
+      ]
+    },
     {
       "cell_type": "markdown",
       "metadata": {},
@@ -357,7 +375,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "## Fit the model\n\nWe fit on the train set, and score on the test set.\n\nWith a GPU backend, the fitting of this model takes around 6 minutes. With a\nCPU backend, it can last 10 times more.\n\n"
+        "## Fit the model\n\nWe fit on the train set, and score on the test set.\n\nTo speed up the fit and to limit the memory peak in Colab, we only fit on\nvoxels with explainable variance above 0.1.\n\nWith a GPU backend, the fitting of this model takes around 6 minutes. With a\nCPU backend, it can last 10 times more.\n\n"
       ]
     },
     {
@@ -368,7 +386,7 @@
       },
       "outputs": [],
       "source": [
-        "pipeline.fit(X_train, Y_train)\n\nscores = pipeline.score(X_test, Y_test)\nscores = backend.to_numpy(scores)\n\nprint(\"(n_voxels,) =\", scores.shape)"
+        "pipeline.fit(X_train, Y_train[:, mask])\n\nscores_mask = pipeline.score(X_test, Y_test[:, mask])\nscores_mask = backend.to_numpy(scores_mask)\nprint(\"(n_voxels_mask,) =\", scores_mask.shape)\n\n# Then we extend the scores to all voxels, giving a score of zero to unfitted\n# voxels.\nn_voxels = Y_train.shape[1]\nscores = np.zeros(n_voxels)\nscores[mask] = scores_mask"
       ]
     },
     {
@@ -397,14 +415,14 @@
       },
       "outputs": [],
       "source": [
-        "pipeline_baseline.fit(X_train, Y_train)\nscores_baseline = pipeline_baseline.score(X_test, Y_test)\nscores_baseline = backend.to_numpy(scores_baseline)"
+        "pipeline_baseline.fit(X_train, Y_train[:, mask])\nscores_baseline_mask = pipeline_baseline.score(X_test, Y_test[:, mask])\nscores_baseline_mask = backend.to_numpy(scores_baseline_mask)\n\n# extend to unfitted voxels\nn_voxels = Y_train.shape[1]\nscores_baseline = np.zeros(n_voxels)\nscores_baseline[mask] = scores_baseline_mask"
       ]
     },
     {
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "Here we plot the comparison of model prediction accuracies with a 2D histogram.\nAll 70k voxels are represented in this histogram, where the diagonal\ncorresponds to identical model prediction accuracy for both models. A distibution deviating\nfrom the diagonal means that one model has better predictive performance\nthan the other.\n\n"
+        "Here we plot the comparison of model prediction accuracies with a 2D\nhistogram. All 70k voxels are represented in this histogram, where the\ndiagonal corresponds to identical model prediction accuracy for both models.\nA distibution deviating from the diagonal means that one model has better\npredictive performance than the other.\n\n"
       ]
     },
     {
@@ -440,7 +458,7 @@
       },
       "outputs": [],
       "source": [
-        "from himalaya.scoring import r2_score_split\n\nY_test_pred_split = pipeline.predict(X_test, split=True)\nsplit_scores = r2_score_split(Y_test, Y_test_pred_split)\nsplit_scores.shape\n\nprint(\"(n_kernels, n_samples_test, n_voxels) =\", Y_test_pred_split.shape)\nprint(\"(n_kernels, n_voxels) =\", split_scores.shape)"
+        "from himalaya.scoring import r2_score_split\n\nY_test_pred_split = pipeline.predict(X_test, split=True)\nsplit_scores_mask = r2_score_split(Y_test[:, mask], Y_test_pred_split)\n\nprint(\"(n_kernels, n_samples_test, n_voxels_mask) =\", Y_test_pred_split.shape)\nprint(\"(n_kernels, n_voxels_mask) =\", split_scores_mask.shape)\n\n# extend to unfitted voxels\nn_kernels = split_scores_mask.shape[0]\nn_voxels = Y_train.shape[1]\nsplit_scores = np.zeros((n_kernels, n_voxels))\nsplit_scores[:, mask] = split_scores_mask\nprint(\"(n_kernels, n_voxels) =\", split_scores.shape)"
       ]
     },
     {
@@ -465,7 +483,7 @@
       "cell_type": "markdown",
       "metadata": {},
       "source": [
-        "The blue regions are better predicted by the motion-energy features, the orange\nregions are better predicted by the wordnet features, and the white regions are\nwell predicted by both feature spaces.\n\nCompared to the last figure of the previous example, we see that most white\nregions have been replaced by either blue or orange regions. The\nbanded ridge regression disentangled the two feature spaces in voxels where\nboth feature spaces had good prediction accuracy (see previous example). For\nexample, motion-energy features predict brain activity in early visual\ncortex, while wordnet features predict in semantic visual areas. For more\ndiscussions about these results, we refer the reader to the original\npublication [1]_.\n\n"
+        "The blue regions are better predicted by the motion-energy features, the\norange regions are better predicted by the wordnet features, and the white\nregions are well predicted by both feature spaces.\n\nCompared to the last figure of the previous example, we see that most white\nregions have been replaced by either blue or orange regions. The banded ridge\nregression disentangled the two feature spaces in voxels where both feature\nspaces had good prediction accuracy (see previous example). For example,\nmotion-energy features predict brain activity in early visual cortex, while\nwordnet features predict in semantic visual areas. For more discussions about\nthese results, we refer the reader to the original publication [1]_.\n\n"
       ]
     },
     {
diff --git a/tutorials/notebooks/movies_3T/merged_for_colab.ipynb b/tutorials/notebooks/movies_3T/merged_for_colab.ipynb
@@ -49,8 +49,8 @@
     "## Change runtime to use a GPU\n",
     "\n",
     "This tutorial is much faster when a GPU is available to run the computations.\n",
-    "In Google Colab you can request access to a GPU by changing the runtime type. \n",
-    "To do so, click the following menu options in Google Colab: \n",
+    "In Google Colab you can request access to a GPU by changing the runtime type.\n",
+    "To do so, click the following menu options in Google Colab:\n",
     "\n",
     "(Menu) \"Runtime\" -> \"Change runtime type\" -> \"Hardware accelerator\" -> \"GPU\".\n",
     "\n"
@@ -63,7 +63,7 @@
     "## Download the data and install all required dependencies\n",
     "\n",
     "Uncomment and run the following cell to download the tutorial data and\n",
-    "install the required dependencies\n",
+    "install the required dependencies.\n",
     "\n"
    ]
   },
@@ -75,18 +75,18 @@
    },
    "outputs": [],
    "source": [
-    "# !gdown --id 1b0I0Ytj06m6GCmfxfNrZuyF97fDo3NZb && \\\n",
-    "# tar xzf vim-5-for-ccn.tar.gz && \\\n",
-    "# pip install -q voxelwise_tutorials && \\\n",
-    "# git clone https://github.com/gallantlab/pycortex"
+    "# ![ -f \"vim-5-for-ccn.tar.gz\" ] || gdown --id 1b0I0Ytj06m6GCmfxfNrZuyF97fDo3NZb\n",
+    "# ![ -d \"vim-5\" ] || tar xzf vim-5-for-ccn.tar.gz\n",
+    "# ![ -d \"pycortex\" ] || git clone https://github.com/gallantlab/pycortex\n",
+    "# !pip install -q voxelwise_tutorials"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Now run the following cell to set up the environment variables for the tutorials\n",
-    "and pycortex.\n",
+    "Now run the following cell to set up the environment variables for the\n",
+    "tutorials and pycortex.\n",
     "\n"
    ]
   },
@@ -2781,6 +2781,31 @@
     "print(\"(n_repeats, n_samples_test, n_voxels) =\", Y_test.shape)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We also compute the explainable variance, to exclude voxels with low\n",
+    "explainable variance from the fit, and speed up the model fitting.\n",
+    "\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {
+    "collapsed": false
+   },
+   "outputs": [],
+   "source": [
+    "from voxelwise_tutorials.utils import explainable_variance\n",
+    "ev = explainable_variance(Y_test)\n",
+    "print(\"(n_voxels,) =\", ev.shape)\n",
+    "\n",
+    "mask = ev > 0.1\n",
+    "print(\"(n_voxels_mask,) =\", ev[mask].shape)"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -3203,6 +3228,9 @@
     "\n",
     "We fit on the train set, and score on the test set.\n",
     "\n",
+    "To speed up the fit and to limit the memory peak in Colab, we only fit on\n",
+    "voxels with explainable variance above 0.1.\n",
+    "\n",
     "With a GPU backend, the fitting of this model takes around 6 minutes. With a\n",
     "CPU backend, it can last 10 times more.\n",
     "\n"
@@ -3216,12 +3244,17 @@
    },
    "outputs": [],
    "source": [
-    "pipeline.fit(X_train, Y_train)\n",
+    "pipeline.fit(X_train, Y_train[:, mask])\n",
     "\n",
-    "scores = pipeline.score(X_test, Y_test)\n",
-    "scores = backend.to_numpy(scores)\n",
+    "scores_mask = pipeline.score(X_test, Y_test[:, mask])\n",
+    "scores_mask = backend.to_numpy(scores_mask)\n",
+    "print(\"(n_voxels_mask,) =\", scores_mask.shape)\n",
     "\n",
-    "print(\"(n_voxels,) =\", scores.shape)"
+    "# Then we extend the scores to all voxels, giving a score of zero to unfitted\n",
+    "# voxels.\n",
+    "n_voxels = Y_train.shape[1]\n",
+    "scores = np.zeros(n_voxels)\n",
+    "scores[mask] = scores_mask"
    ]
   },
   {
@@ -3266,20 +3299,25 @@
    },
    "outputs": [],
    "source": [
-    "pipeline_baseline.fit(X_train, Y_train)\n",
-    "scores_baseline = pipeline_baseline.score(X_test, Y_test)\n",
-    "scores_baseline = backend.to_numpy(scores_baseline)"
+    "pipeline_baseline.fit(X_train, Y_train[:, mask])\n",
+    "scores_baseline_mask = pipeline_baseline.score(X_test, Y_test[:, mask])\n",
+    "scores_baseline_mask = backend.to_numpy(scores_baseline_mask)\n",
+    "\n",
+    "# extend to unfitted voxels\n",
+    "n_voxels = Y_train.shape[1]\n",
+    "scores_baseline = np.zeros(n_voxels)\n",
+    "scores_baseline[mask] = scores_baseline_mask"
    ]
   },
   {
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "Here we plot the comparison of model prediction accuracies with a 2D histogram.\n",
-    "All 70k voxels are represented in this histogram, where the diagonal\n",
-    "corresponds to identical model prediction accuracy for both models. A distibution deviating\n",
-    "from the diagonal means that one model has better predictive performance\n",
-    "than the other.\n",
+    "Here we plot the comparison of model prediction accuracies with a 2D\n",
+    "histogram. All 70k voxels are represented in this histogram, where the\n",
+    "diagonal corresponds to identical model prediction accuracy for both models.\n",
+    "A distibution deviating from the diagonal means that one model has better\n",
+    "predictive performance than the other.\n",
     "\n"
    ]
   },
@@ -3344,10 +3382,16 @@
     "from himalaya.scoring import r2_score_split\n",
     "\n",
     "Y_test_pred_split = pipeline.predict(X_test, split=True)\n",
-    "split_scores = r2_score_split(Y_test, Y_test_pred_split)\n",
-    "split_scores.shape\n",
+    "split_scores_mask = r2_score_split(Y_test[:, mask], Y_test_pred_split)\n",
+    "\n",
+    "print(\"(n_kernels, n_samples_test, n_voxels_mask) =\", Y_test_pred_split.shape)\n",
+    "print(\"(n_kernels, n_voxels_mask) =\", split_scores_mask.shape)\n",
     "\n",
-    "print(\"(n_kernels, n_samples_test, n_voxels) =\", Y_test_pred_split.shape)\n",
+    "# extend to unfitted voxels\n",
+    "n_kernels = split_scores_mask.shape[0]\n",
+    "n_voxels = Y_train.shape[1]\n",
+    "split_scores = np.zeros((n_kernels, n_voxels))\n",
+    "split_scores[:, mask] = split_scores_mask\n",
     "print(\"(n_kernels, n_voxels) =\", split_scores.shape)"
    ]
   },
@@ -3381,18 +3425,17 @@
    "cell_type": "markdown",
    "metadata": {},
    "source": [
-    "The blue regions are better predicted by the motion-energy features, the orange\n",
-    "regions are better predicted by the wordnet features, and the white regions are\n",
-    "well predicted by both feature spaces.\n",
+    "The blue regions are better predicted by the motion-energy features, the\n",
+    "orange regions are better predicted by the wordnet features, and the white\n",
+    "regions are well predicted by both feature spaces.\n",
     "\n",
     "Compared to the last figure of the previous example, we see that most white\n",
-    "regions have been replaced by either blue or orange regions. The\n",
-    "banded ridge regression disentangled the two feature spaces in voxels where\n",
-    "both feature spaces had good prediction accuracy (see previous example). For\n",
-    "example, motion-energy features predict brain activity in early visual\n",
-    "cortex, while wordnet features predict in semantic visual areas. For more\n",
-    "discussions about these results, we refer the reader to the original\n",
-    "publication [1]_.\n",
+    "regions have been replaced by either blue or orange regions. The banded ridge\n",
+    "regression disentangled the two feature spaces in voxels where both feature\n",
+    "spaces had good prediction accuracy (see previous example). For example,\n",
+    "motion-energy features predict brain activity in early visual cortex, while\n",
+    "wordnet features predict in semantic visual areas. For more discussions about\n",
+    "these results, we refer the reader to the original publication [1]_.\n",
     "\n"
    ]
   },

Original file line number	Diff line number	Diff line change
`@@ -33,14 +33,14 @@`
`33`	`33`	`"cell_type": "markdown",`
`34`	`34`	`"metadata": {},`
`35`	`35`	`"source": [`
`36`		`- "## Change runtime to use a GPU\n\nThis tutorial is much faster when a GPU is available to run the computations.\nIn Google Colab you can request access to a GPU by changing the runtime type. \nTo do so, click the following menu options in Google Colab: \n\n(Menu) \"Runtime\" -> \"Change runtime type\" -> \"Hardware accelerator\" -> \"GPU\".\n\n"`
	`36`	`+ "## Change runtime to use a GPU\n\nThis tutorial is much faster when a GPU is available to run the computations.\nIn Google Colab you can request access to a GPU by changing the runtime type.\nTo do so, click the following menu options in Google Colab:\n\n(Menu) \"Runtime\" -> \"Change runtime type\" -> \"Hardware accelerator\" -> \"GPU\".\n\n"`
`37`	`37`	`]`
`38`	`38`	`},`
`39`	`39`	`{`
`40`	`40`	`"cell_type": "markdown",`
`41`	`41`	`"metadata": {},`
`42`	`42`	`"source": [`
`43`		`- "## Download the data and install all required dependencies\n\nUncomment and run the following cell to download the tutorial data and\ninstall the required dependencies\n\n"`
	`43`	`+ "## Download the data and install all required dependencies\n\nUncomment and run the following cell to download the tutorial data and\ninstall the required dependencies.\n\n"`
`44`	`44`	`]`
`45`	`45`	`},`
`46`	`46`	`{`
`@@ -51,14 +51,14 @@`
`51`	`51`	`},`
`52`	`52`	`"outputs": [],`
`53`	`53`	`"source": [`
`54`		`- "# !gdown --id 1b0I0Ytj06m6GCmfxfNrZuyF97fDo3NZb && \\\n# tar xzf vim-5-for-ccn.tar.gz && \\\n# pip install -q voxelwise_tutorials && \\\n# git clone https://github.com/gallantlab/pycortex"`
	`54`	`+ "# ![ -f \"vim-5-for-ccn.tar.gz\" ] \|\| gdown --id 1b0I0Ytj06m6GCmfxfNrZuyF97fDo3NZb\n# ![ -d \"vim-5\" ] \|\| tar xzf vim-5-for-ccn.tar.gz\n# ![ -d \"pycortex\" ] \|\| git clone https://github.com/gallantlab/pycortex\n# !pip install -q voxelwise_tutorials"`
`55`	`55`	`]`
`56`	`56`	`},`
`57`	`57`	`{`
`58`	`58`	`"cell_type": "markdown",`
`59`	`59`	`"metadata": {},`
`60`	`60`	`"source": [`
`61`		`- "Now run the following cell to set up the environment variables for the tutorials\nand pycortex.\n\n"`
	`61`	`+ "Now run the following cell to set up the environment variables for the\ntutorials and pycortex.\n\n"`
`62`	`62`	`]`
`63`	`63`	`},`
`64`	`64`	`{`
Original file line number	Diff line number	Diff line change
`@@ -76,6 +76,24 @@`
`76`	`76`	`"import numpy as np\n\nfrom voxelwise_tutorials.io import load_hdf5_array\n\nfile_name = os.path.join(directory, \"responses\", f\"{subject}_responses.hdf\")\nY_train = load_hdf5_array(file_name, key=\"Y_train\")\nY_test = load_hdf5_array(file_name, key=\"Y_test\")\n\nprint(\"(n_samples_train, n_voxels) =\", Y_train.shape)\nprint(\"(n_repeats, n_samples_test, n_voxels) =\", Y_test.shape)"`
`77`	`77`	`]`
`78`	`78`	`},`
	`79`	`+ {`
	`80`	`+ "cell_type": "markdown",`
	`81`	`+ "metadata": {},`
	`82`	`+ "source": [`
	`83`	`+ "We also compute the explainable variance, to exclude voxels with low\nexplainable variance from the fit, and speed up the model fitting.\n\n"`
	`84`	`+ ]`
	`85`	`+ },`
	`86`	`+ {`
	`87`	`+ "cell_type": "code",`
	`88`	`+ "execution_count": null,`
	`89`	`+ "metadata": {`
	`90`	`+ "collapsed": false`
	`91`	`+ },`
	`92`	`+ "outputs": [],`
	`93`	`+ "source": [`
	`94`	`+ "from voxelwise_tutorials.utils import explainable_variance\nev = explainable_variance(Y_test)\nprint(\"(n_voxels,) =\", ev.shape)\n\nmask = ev > 0.1\nprint(\"(n_voxels_mask,) =\", ev[mask].shape)"`
	`95`	`+ ]`
	`96`	`+ },`
`79`	`97`	`{`
`80`	`98`	`"cell_type": "markdown",`
`81`	`99`	`"metadata": {},`
`@@ -357,7 +375,7 @@`
`357`	`375`	`"cell_type": "markdown",`
`358`	`376`	`"metadata": {},`
`359`	`377`	`"source": [`
`360`		`- "## Fit the model\n\nWe fit on the train set, and score on the test set.\n\nWith a GPU backend, the fitting of this model takes around 6 minutes. With a\nCPU backend, it can last 10 times more.\n\n"`
	`378`	`+ "## Fit the model\n\nWe fit on the train set, and score on the test set.\n\nTo speed up the fit and to limit the memory peak in Colab, we only fit on\nvoxels with explainable variance above 0.1.\n\nWith a GPU backend, the fitting of this model takes around 6 minutes. With a\nCPU backend, it can last 10 times more.\n\n"`
`361`	`379`	`]`
`362`	`380`	`},`
`363`	`381`	`{`
`@@ -368,7 +386,7 @@`
`368`	`386`	`},`
`369`	`387`	`"outputs": [],`
`370`	`388`	`"source": [`
`371`		`- "pipeline.fit(X_train, Y_train)\n\nscores = pipeline.score(X_test, Y_test)\nscores = backend.to_numpy(scores)\n\nprint(\"(n_voxels,) =\", scores.shape)"`
	`389`	`+ "pipeline.fit(X_train, Y_train[:, mask])\n\nscores_mask = pipeline.score(X_test, Y_test[:, mask])\nscores_mask = backend.to_numpy(scores_mask)\nprint(\"(n_voxels_mask,) =\", scores_mask.shape)\n\n# Then we extend the scores to all voxels, giving a score of zero to unfitted\n# voxels.\nn_voxels = Y_train.shape[1]\nscores = np.zeros(n_voxels)\nscores[mask] = scores_mask"`
`372`	`390`	`]`
`373`	`391`	`},`
`374`	`392`	`{`
`@@ -397,14 +415,14 @@`
`397`	`415`	`},`
`398`	`416`	`"outputs": [],`
`399`	`417`	`"source": [`
`400`		`- "pipeline_baseline.fit(X_train, Y_train)\nscores_baseline = pipeline_baseline.score(X_test, Y_test)\nscores_baseline = backend.to_numpy(scores_baseline)"`
	`418`	`+ "pipeline_baseline.fit(X_train, Y_train[:, mask])\nscores_baseline_mask = pipeline_baseline.score(X_test, Y_test[:, mask])\nscores_baseline_mask = backend.to_numpy(scores_baseline_mask)\n\n# extend to unfitted voxels\nn_voxels = Y_train.shape[1]\nscores_baseline = np.zeros(n_voxels)\nscores_baseline[mask] = scores_baseline_mask"`
`401`	`419`	`]`
`402`	`420`	`},`
`403`	`421`	`{`
`404`	`422`	`"cell_type": "markdown",`
`405`	`423`	`"metadata": {},`
`406`	`424`	`"source": [`
`407`		`- "Here we plot the comparison of model prediction accuracies with a 2D histogram.\nAll 70k voxels are represented in this histogram, where the diagonal\ncorresponds to identical model prediction accuracy for both models. A distibution deviating\nfrom the diagonal means that one model has better predictive performance\nthan the other.\n\n"`
	`425`	`+ "Here we plot the comparison of model prediction accuracies with a 2D\nhistogram. All 70k voxels are represented in this histogram, where the\ndiagonal corresponds to identical model prediction accuracy for both models.\nA distibution deviating from the diagonal means that one model has better\npredictive performance than the other.\n\n"`
`408`	`426`	`]`
`409`	`427`	`},`
`410`	`428`	`{`
`@@ -440,7 +458,7 @@`
`440`	`458`	`},`
`441`	`459`	`"outputs": [],`
`442`	`460`	`"source": [`
`443`		`- "from himalaya.scoring import r2_score_split\n\nY_test_pred_split = pipeline.predict(X_test, split=True)\nsplit_scores = r2_score_split(Y_test, Y_test_pred_split)\nsplit_scores.shape\n\nprint(\"(n_kernels, n_samples_test, n_voxels) =\", Y_test_pred_split.shape)\nprint(\"(n_kernels, n_voxels) =\", split_scores.shape)"`
	`461`	+ "from himalaya.scoring import r2_score_split\n\nY_test_pred_split = pipeline.predict(X_test, split=True)\nsplit_scores_mask = r2_score_split(Y_test[:, mask], Y_test_pred_split)\n\nprint(\"(n_kernels, n_samples_test, n_voxels_mask) =\", Y_test_pred_split.shape)\nprint(\"(n_kernels, n_voxels_mask) =\", split_scores_mask.shape)\n\n# extend to unfitted voxels\nn_kernels = split_scores_mask.shape[0]\nn_voxels = Y_train.shape[1]\nsplit_scores = np.zeros((n_kernels, n_voxels))\nsplit_scores[:, mask] = split_scores_mask\nprint(\"(n_kernels, n_voxels) =\", split_scores.shape)"
`444`	`462`	`]`
`445`	`463`	`},`
`446`	`464`	`{`
`@@ -465,7 +483,7 @@`
`465`	`483`	`"cell_type": "markdown",`
`466`	`484`	`"metadata": {},`
`467`	`485`	`"source": [`
`468`		- "The blue regions are better predicted by the motion-energy features, the orange\nregions are better predicted by the wordnet features, and the white regions are\nwell predicted by both feature spaces.\n\nCompared to the last figure of the previous example, we see that most white\nregions have been replaced by either blue or orange regions. The\nbanded ridge regression disentangled the two feature spaces in voxels where\nboth feature spaces had good prediction accuracy (see previous example). For\nexample, motion-energy features predict brain activity in early visual\ncortex, while wordnet features predict in semantic visual areas. For more\ndiscussions about these results, we refer the reader to the original\npublication [1]_.\n\n"
	`486`	+ "The blue regions are better predicted by the motion-energy features, the\norange regions are better predicted by the wordnet features, and the white\nregions are well predicted by both feature spaces.\n\nCompared to the last figure of the previous example, we see that most white\nregions have been replaced by either blue or orange regions. The banded ridge\nregression disentangled the two feature spaces in voxels where both feature\nspaces had good prediction accuracy (see previous example). For example,\nmotion-energy features predict brain activity in early visual cortex, while\nwordnet features predict in semantic visual areas. For more discussions about\nthese results, we refer the reader to the original publication [1]_.\n\n"
`469`	`487`	`]`
`470`	`488`	`},`
`471`	`489`	`{`