diff --git a/docs/source/evaluation.rst b/docs/source/evaluation.rst
index 9288910..06e3066 100644
--- a/docs/source/evaluation.rst
+++ b/docs/source/evaluation.rst
@@ -166,7 +166,7 @@ Prerequisites for the linear encoding function include:
Variance Partitioning Analysis (VPA)
-----------------
+------------------------------------
.. note::
@@ -174,18 +174,20 @@ Variance Partitioning Analysis (VPA)
-**Net2Brain** enhances model and cerebral data assessment through Variance Partitioning Analysis.
-This technique supports the evaluation of **up to four independent variables** in relation to a
-**singular dependent variable**, typically the neural data.
+**Net2Brain** enhances model and cerebral data assessment through Variance Partitioning Analysis.
+This technique supports the evaluation of **up to four independent variables** in relation to a
+**singular dependent variable**, typically the neural data. It works both for time-resolved data
+(e.g. EEG/MEG) and for data without a time axis (e.g. fMRI).
The requirements for VPA are:
-- **dependent_variable**: The RDM-formatted path to the brain data.
-- **independent_variable**: An array of arrays, each containing RDM paths belonging to a specific group.
+- **dependent_variable**: The brain data. For time-resolved data (e.g. EEG) this is a single path to a pre-stacked array shaped *[subjects, time, pairs]*. For data without a time axis (e.g. fMRI) it can be either a single *[subjects, pairs]* array or a list of per-subject RDM paths; in that case the results are returned per subject, with no time dimension.
+- **independent_variable**: A list with one entry per independent variable. Each entry is itself a list of RDM paths belonging to that group, which are averaged together when ``average_models=True``. A bare path string is also accepted for a single-model group.
- **variable_names**: The labels for the independent variables, integral for visualization.
Returns:
-- **dataframe**: Contains all unique and shared variances. Dataframe can be filtered to only contain relevant information
+
+- **dataframe**: Contains all unique and shared variances, plus the upper and lower noise ceiling as ``UNC`` and ``LNC`` rows. The dataframe can be filtered to only contain relevant information.
@@ -207,22 +209,33 @@ Returns:
Plotting VPA
^^^^^^^^^^^^^^
-The plotting utilities of **Net2Brain** offer the capability to visualize time-course data.
-The `plotting_over_time` function includes an optional standard deviation overlay to enrich the
-graphical representation.
+The plotting utilities of **Net2Brain** cover both kinds of VPA results, and both overlay the
+upper and lower noise ceiling.
-- **add_std**: Enable to display the standard deviation on the graph. Defaults to False.
+For time-resolved data, ``plotting_over_time`` draws each component as a line over time and
+supports an optional standard-deviation band.
+- **add_std**: Enable to display the standard deviation on the graph. Defaults to False.
.. code-block:: python
from net2brain.evaluations.plotting import Plotting
- # Plotting with significance
+ # Time-resolved results (e.g. EEG)
plotter = Plotting(dataframe)
-
plotter.plotting_over_time(add_std=True)
+For data without a time axis, ``plotting_components`` draws each component as a bar (mean across
+subjects with SEM error bars) and marks significance.
+
+- **threshold**: Significance level for the markers. Defaults to 0.05.
+
+.. code-block:: python
+
+ # Non-time-resolved results (e.g. fMRI)
+ plotter = Plotting(dataframe)
+ plotter.plotting_components()
+
Centered Kernel Alignment (CKA)
diff --git a/net2brain/evaluations/plotting.py b/net2brain/evaluations/plotting.py
index 3d9f49c..a5817f9 100644
--- a/net2brain/evaluations/plotting.py
+++ b/net2brain/evaluations/plotting.py
@@ -322,9 +322,97 @@ def add_std_deviation(self, dataframe):
return dataframe
+ def plotting_components(self, threshold=0.05, title="Variance Partitioning"):
+ """Bar plot of VPA components for results without a time axis (e.g. fMRI).
+
+ Each component is shown as its mean across subjects with SEM error bars
+ and a significance marker where the corrected p-value is below
+ ``threshold``. Bars are coloured by component type (unique, shared, or
+ combined/influence) so the partitioning is easy to read at a glance.
+
+ Args:
+ threshold (float): Significance level for the star markers.
+ title (str): Figure title.
+ """
+ category_colors = {
+ 'Unique': '#4C72B0',
+ 'Shared': '#DD8452',
+ 'Combined / influence': '#8C8C8C',
+ }
+
+ def component_category(variable):
+ variable = str(variable)
+ if variable.startswith('R'):
+ return 'Combined / influence'
+ return 'Unique' if len(variable) <= 2 else 'Shared'
+
+ for dataframe in self.dataframes:
+ names, means, sems, sigs, colors, categories = [], [], [], [], [], []
+ ceilings = {}
+ for _, row in dataframe.iterrows():
+ if row["Variable"] in ('UNC', 'LNC'):
+ ceilings[row["Variable"]] = float(np.mean(np.atleast_1d(np.asarray(row["Values"], dtype=float))))
+ continue
+ values = np.atleast_1d(np.asarray(row["Values"], dtype=float))
+ n_subjects = len(values)
+ category = component_category(row["Variable"])
+ names.append(row["Description"])
+ means.append(values.mean())
+ sems.append(values.std(ddof=1) / np.sqrt(n_subjects) if n_subjects > 1 else 0.0)
+ sigs.append(float(np.asarray(row["Significance"])))
+ colors.append(category_colors[category])
+ categories.append(category)
+
+ x = np.arange(len(names))
+ fig, ax = plt.subplots(figsize=(max(7, 1.4 * len(names)), 6))
+
+ ax.bar(x, means, yerr=sems, capsize=4, color=colors, edgecolor='white',
+ linewidth=0.8, alpha=0.9, error_kw=dict(ecolor='0.3', lw=1.2))
+
+ value_range = (max(means) - min(means)) or 1.0
+ for xi, mean, sem, p in zip(x, means, sems, sigs):
+ if p < threshold:
+ if mean >= 0:
+ ax.text(xi, mean + sem + 0.03 * value_range, '*', ha='center',
+ va='bottom', fontsize=16, color='black')
+ else:
+ ax.text(xi, mean - sem - 0.03 * value_range, '*', ha='center',
+ va='top', fontsize=16, color='black')
+
+ ax.axhline(0, color='0.2', linewidth=1)
+ ax.set_xticks(x)
+ ax.set_xticklabels([self.add_line_break(name) for name in names], rotation=30, ha='right')
+ ax.set_ylabel("Variance explained (R\u00b2)", fontsize=12)
+ ax.set_title(title, fontsize=15, pad=12)
+
+ ax.spines['top'].set_visible(False)
+ ax.spines['right'].set_visible(False)
+ ax.grid(axis='y', alpha=0.3)
+ ax.set_axisbelow(True)
+
+ # Legend: component categories plus noise-ceiling reference lines
+ handles = [plt.Rectangle((0, 0), 1, 1, color=category_colors[c]) for c in category_colors if c in categories]
+ labels = [c for c in category_colors if c in categories]
+ for key, label, ls in [('UNC', 'Upper noise ceiling', '--'), ('LNC', 'Lower noise ceiling', ':')]:
+ if key in ceilings and not np.isnan(ceilings[key]):
+ line = ax.axhline(ceilings[key], color='0.45', linestyle=ls, linewidth=1.2)
+ handles.append(line)
+ labels.append(label)
+ if len(labels) > 1:
+ ax.legend(handles, labels, frameon=False, loc='best')
+
+ plt.tight_layout()
+ plt.show()
+
+
def plotting_over_time(self, add_std=False):
"""Plotting line plots over time for each dataframe."""
for dataframe in self.dataframes:
+ if np.asarray(dataframe.iloc[0]["Values"]).ndim < 2:
+ raise ValueError(
+ "This dataframe has no time axis (its 'Values' are 1D), so it "
+ "cannot be plotted over time. Use 'plotting_components' instead."
+ )
self.add_std_deviation(dataframe)
# Average 2D arrays over the first axis
@@ -349,6 +437,12 @@ def plotting_over_time(self, add_std=False):
std = row["Std"]
color = palette[index]
+ # Draw the noise ceiling as grey reference lines, not coloured components
+ if row["Variable"] in ('UNC', 'LNC'):
+ ls = '--' if row["Variable"] == 'UNC' else ':'
+ plt.plot(time_points, values, label=name, color='0.45', linestyle=ls, linewidth=1.5)
+ continue
+
# Plot values with optional standard deviation shading
plt.plot(time_points, values, label=name, color=color, linewidth=2)
if add_std and std is not None:
@@ -370,5 +464,15 @@ def plotting_over_time(self, add_std=False):
plt.title("Time Series Analysis Results")
# Add legend and show plot
- plt.legend()
+ ax, fig = plt.gca(), plt.gcf()
+ handles, labels = ax.get_legend_handles_labels()
+ order = sorted(range(len(labels)), key=lambda k: labels[k])
+ handles, labels = [handles[k] for k in order], [labels[k] for k in order]
+ if len(labels) > 3:
+ # Long legends overrun the plot, so place them below in ordered columns
+ fig.legend(handles, labels, loc='upper center', ncol=min(3, len(labels)),
+ bbox_to_anchor=(0.5, 0), bbox_transform=fig.transFigure, fontsize=9)
+ plt.tight_layout(rect=[0, 0, 1, 1])
+ else:
+ ax.legend(handles, labels)
plt.show()
\ No newline at end of file
diff --git a/net2brain/evaluations/variance_partitioning_analysis.py b/net2brain/evaluations/variance_partitioning_analysis.py
index e978797..dbce163 100644
--- a/net2brain/evaluations/variance_partitioning_analysis.py
+++ b/net2brain/evaluations/variance_partitioning_analysis.py
@@ -86,8 +86,8 @@ def noise_ceiling_r2(self, rdm1, rdm2):
"""
lt_rdm1 = rdm1
lt_rdm2 = rdm2
- slope, intercept, r_value, p_value, std_err = scipy.stats.linregress(lt_rdm1, lt_rdm2)
- return r_value ** 2
+ rho, _ = scipy.stats.spearmanr(lt_rdm1, lt_rdm2)
+ return rho ** 2
def get_uppernoiseceiling(self, rdm):
"""Calculate upper noise ceiling
@@ -230,6 +230,91 @@ def load_rdms(self, rdm_paths):
+ def _as_array(self, loaded):
+ """Return a plain numpy array from whatever ``load`` produced.
+
+ Args:
+ loaded: Either a numpy array (e.g. from a .npy) or a dict-like
+ object (e.g. an .npz/.mat) holding the RDM under 'rdm'/'arr_0'.
+
+ Returns:
+ numpy array: The extracted RDM.
+ """
+ if isinstance(loaded, np.ndarray):
+ return loaded
+ if 'rdm' in loaded:
+ return np.asarray(loaded['rdm'])
+ if 'arr_0' in loaded:
+ return np.asarray(loaded['arr_0'])
+ raise ValueError("The RDM file does not contain 'rdm' or 'arr_0' keys.")
+
+ def _load_dependent(self, dependent_variable):
+ """Load the dependent variable into shape (subjects, time, pairs).
+
+ A single path is treated as one pre-stacked array. A list of paths is
+ treated as one RDM per subject and stacked. Square per-subject RDMs are
+ reduced to their upper triangle; condensed vectors and (time, pairs)
+ matrices are kept as-is. Data without a time axis is given a singleton
+ time axis so the time-resolved machinery can run on it unchanged.
+
+ Args:
+ dependent_variable (str or list): Path or list of paths to the RDMs.
+
+ Returns:
+ tuple: (dep_var, is_timeresolved), where dep_var has shape
+ (subjects, time, pairs) and is_timeresolved is False when a
+ singleton time axis had to be inserted.
+ """
+ if isinstance(dependent_variable, str):
+ dep_var = self._as_array(load(dependent_variable))
+ else:
+ subject_rdms = []
+ for path in dependent_variable:
+ rdm = self._as_array(load(path))
+ if rdm.ndim == 2 and rdm.shape[0] == rdm.shape[1]:
+ rdm = self.get_uppertriangular(rdm)
+ subject_rdms.append(rdm)
+ dep_var = np.array(subject_rdms)
+
+ if dep_var.ndim not in (2, 3):
+ raise ValueError(
+ f"Dependent variable resolved to shape {dep_var.shape}; expected "
+ "2D (subjects, pairs) or 3D (subjects, time, pairs)."
+ )
+
+ if dep_var.shape[-1] < 2:
+ raise ValueError(
+ f"Dependent variable has only {dep_var.shape[-1]} condition pair(s); "
+ "VPA needs at least 2 (i.e. 3 or more conditions)."
+ )
+
+ is_timeresolved = dep_var.ndim == 3
+ if not is_timeresolved:
+ dep_var = dep_var[:, np.newaxis, :]
+
+ return dep_var, is_timeresolved
+
+ def _load_independent(self, independent_variable):
+ """Load an independent variable into shape (n_models, pairs).
+
+ Accepts either a single path or a list of paths. Each RDM is reduced to
+ its upper-triangular vector, so a bare string is handled the same as a
+ one-element list instead of falling through to the EEG code path in
+ ``load_rdms``.
+
+ Args:
+ independent_variable (str or list): Path or list of paths to RDMs.
+
+ Returns:
+ numpy array: Stacked upper-triangular RDM vectors.
+ """
+ paths = [independent_variable] if isinstance(independent_variable, str) else list(independent_variable)
+ vectors = []
+ for path in paths:
+ rdm = self.check_squareform(self._as_array(load(path)))
+ vectors.append(self.get_uppertriangular(rdm))
+ return np.array(vectors)
+
def calculate_p_values(self, models_data):
"""
Calculate p-values for each time-step in models_data using one-sample t-test among participants.
@@ -268,8 +353,8 @@ def VPA_2(self, dep_var):
"""
# Open RDMs
- ind_var_1 = self.load_rdms(self.independent_1)
- ind_var_2 = self.load_rdms(self.independent_2)
+ ind_var_1 = self._load_independent(self.independent_1)
+ ind_var_2 = self._load_independent(self.independent_2)
# Average if wanted
if self.average_models:
@@ -310,9 +395,9 @@ def VPA_3(self, dep_var):
"""
# Open RDMs
- ind_var_1 = self.load_rdms(self.independent_1)
- ind_var_2 = self.load_rdms(self.independent_2)
- ind_var_3 = self.load_rdms(self.independent_3)
+ ind_var_1 = self._load_independent(self.independent_1)
+ ind_var_2 = self._load_independent(self.independent_2)
+ ind_var_3 = self._load_independent(self.independent_3)
# Average if wanted
if self.average_models:
@@ -364,10 +449,10 @@ def VPA_4(self, dep_var):
"""
# Open RDMs
- ind_var_1 = self.load_rdms(self.independent_1)
- ind_var_2 = self.load_rdms(self.independent_2)
- ind_var_3 = self.load_rdms(self.independent_3)
- ind_var_4 = self.load_rdms(self.independent_4)
+ ind_var_1 = self._load_independent(self.independent_1)
+ ind_var_2 = self._load_independent(self.independent_2)
+ ind_var_3 = self._load_independent(self.independent_3)
+ ind_var_4 = self._load_independent(self.independent_4)
# Average if wanted
if self.average_models:
@@ -483,6 +568,12 @@ def evaluate_2(self, dep_var, num_subjects, eeg_time):
values = [R1_values, R2_values, R12_values, y12_values, y1_values, y2_values]
significances = [sig_R1, sig_R2, sig_R12, sig_y12, sig_y1, sig_y2]
+ # Surface the noise ceiling as its own rows instead of discarding it
+ variables += ['UNC', 'LNC']
+ descriptions += ['Upper Noise Ceiling', 'Lower Noise Ceiling']
+ values += [R_un, R_ln]
+ significances += [np.full(eeg_time, np.nan), np.full(eeg_time, np.nan)]
+
data_to_append = []
for var, desc, val, sig in zip(variables, descriptions, values, significances):
@@ -541,7 +632,7 @@ def evaluate_3(self, dep_var, num_subjects, eeg_time):
for i in range(num_subjects):
this_dep_var = np.squeeze(dep_var[i,time,:])
results = self.VPA_3(this_dep_var)
- R1_values[i, time], R2_values[i, time], R3_values[i, time], R12_values[i, time], R13_values[i, time], R23_values[i, time], R123_values[i, time], y123_values[i, time], y12_values[i, time], y13_values[i, time], y23_values[i, time], y1_values[i, time], y2_values[i, time], y3_values[i, time] = results
+ R1_values[i, time], R2_values[i, time], R3_values[i, time], R12_values[i, time], R13_values[i, time], R23_values[i, time], R123_values[i, time], y123_values[i, time], y12_values[i, time], y13_values[i, time], y23_values[i, time], y1_values[i, time], y2_values[i, time], y3_values[i, time] = (results['R1'], results['R2'], results['R3'], results['R12'], results['R13'], results['R23'], results['R123'], results['y123'], results['y12'], results['y13'], results['y23'], results['y1'], results['y2'], results['y3'])
# Calculate significance for all values
sig_R1 = self.calculate_p_values(R1_values)
@@ -575,6 +666,12 @@ def evaluate_3(self, dep_var, num_subjects, eeg_time):
values = [R1_values, R2_values, R3_values, R12_values, R13_values, R23_values, R123_values, y123_values, y12_values, y13_values, y23_values, y1_values, y2_values, y3_values]
significances = [sig_R1, sig_R2, sig_R3, sig_R12, sig_R13, sig_R23, sig_R123, sig_y123, sig_y12, sig_y13, sig_y23, sig_y1, sig_y2, sig_y3]
+ # Surface the noise ceiling as its own rows instead of discarding it
+ variables += ['UNC', 'LNC']
+ descriptions += ['Upper Noise Ceiling', 'Lower Noise Ceiling']
+ values += [R_un, R_ln]
+ significances += [np.full(eeg_time, np.nan), np.full(eeg_time, np.nan)]
+
data_to_append = []
for var, desc, val, sig in zip(variables, descriptions, values, significances):
@@ -671,6 +768,10 @@ def evaluate_4(self, dep_var, num_subjects, eeg_time):
'Color': None
})
+ # Surface the noise ceiling as its own rows instead of discarding it
+ data_to_append.append({'Variable': 'UNC', 'Description': 'Upper Noise Ceiling', 'Values': R_un, 'Significance': np.full(eeg_time, np.nan), 'Color': None})
+ data_to_append.append({'Variable': 'LNC', 'Description': 'Lower Noise Ceiling', 'Values': R_ln, 'Significance': np.full(eeg_time, np.nan), 'Color': None})
+
all_variances_df = pd.concat([all_variances_df, pd.DataFrame(data_to_append)], ignore_index=True)
return all_variances_df
@@ -691,7 +792,7 @@ def evaluate(self, average_models=False):
self.average_models=average_models
# Load dependent variable
- dep_var = self.load_rdms(self.dependent_variable)[0]
+ dep_var, is_timeresolved = self._load_dependent(self.dependent_variable)
# Get Subjects and time from the dimensions (16, 100, 1225)
num_subjects = dep_var.shape[0]
@@ -700,4 +801,11 @@ def evaluate(self, average_models=False):
# Calculate VPA
all_variances_df = self.VPA_function(dep_var, num_subjects, eeg_time)
+ # Drop the singleton time axis from the results when the data has no time dimension
+ if not is_timeresolved:
+ for column in ('Values', 'Significance'):
+ all_variances_df[column] = [
+ np.squeeze(np.asarray(value), axis=-1) for value in all_variances_df[column]
+ ]
+
return all_variances_df
\ No newline at end of file
diff --git a/net2brain/preprocess/rdm.py b/net2brain/preprocess/rdm.py
index 7ad24ee..1aab684 100644
--- a/net2brain/preprocess/rdm.py
+++ b/net2brain/preprocess/rdm.py
@@ -4,19 +4,18 @@
from multiprocessing import Pool
from itertools import combinations
from sklearn.discriminant_analysis import LinearDiscriminantAnalysis as LDA
+from tqdm.auto import tqdm
class eeg_classfier:
def __init__(self,dataA,dataB):
self.dataA = dataA
self.dataB = dataB
- #print(dataA.shape,dataB.shape)
self.lenTrn = self.dataA.shape[0] - 1
-
+
def leaveOneOut(self,ii):
clf = LDA()
dat = np.concatenate([np.delete(self.dataA, ii, axis=0), np.delete(self.dataB, ii, axis=0)],axis=0)
lab = np.concatenate([np.ones(self.lenTrn),np.ones(self.lenTrn)*2])
- #print(dat.shape,lab.shape)
clf.fit(dat,lab)
return np.mean([1,2] == clf.predict([self.dataA[ii,:],self.dataB[ii,:]]))
@@ -26,15 +25,12 @@ def eeg_rdm(eeg,labels):
counts = collections.OrderedDict(sorted(counts.items()))
ordered_labels = list(counts.keys())
minCount = min(counts.values())
- ########
timepoints = eeg.shape[-1]
numLabels = len(counts)
index_dict = {l : np.where(labels==l)[0][:minCount] for l in counts.keys()}
- ########
rdms = np.zeros((numLabels,numLabels,timepoints))
- for tt in range(timepoints):
+ for tt in tqdm(range(timepoints), desc="Decoding RDM"):
for l1,l2 in combinations(range(numLabels),2):
- #print(ii,jj)
ii = ordered_labels[l1]
jj = ordered_labels[l2]
classify = eeg_classfier(np.squeeze(eeg[index_dict[ii],:,tt]),np.squeeze(eeg[index_dict[jj],:,tt]))
diff --git a/notebooks/Workshops/Net2Brain_EEG_Cutting_Edge_Workshop.ipynb b/notebooks/Workshops/Net2Brain_EEG_Cutting_Edge_Workshop.ipynb
index bf3ed0a..88cca23 100644
--- a/notebooks/Workshops/Net2Brain_EEG_Cutting_Edge_Workshop.ipynb
+++ b/notebooks/Workshops/Net2Brain_EEG_Cutting_Edge_Workshop.ipynb
@@ -1 +1,718 @@
-{"cells":[{"cell_type":"markdown","metadata":{"id":"5JZLodA2Ovlj"},"source":["# Installing Net2Brain and Relevant Dependencies"]},{"cell_type":"markdown","metadata":{},"source":["![](\"data/Net2Brain_Logo.png\")
"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":133382,"status":"ok","timestamp":1697637683762,"user":{"displayName":"Johannes Kasper","userId":"06891618930953657970"},"user_tz":-120},"id":"kYeIGnfkOvll","outputId":"46c690fc-7570-4148-9c8b-8b09205e8ef7"},"outputs":[],"source":["# !pip install -U git+https://github.com/cvai-roig-lab/Net2Brain"]},{"cell_type":"markdown","metadata":{"id":"Retsh7xoOvll"},"source":["\n","\n","---\n","\n","\n","\n","---\n","\n","\n","## Restart Runtime\n","\n","\n","\n","---\n","\n","\n","\n","---\n"]},{"cell_type":"markdown","metadata":{},"source":["# Load Dataset"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":341},"executionInfo":{"elapsed":128923,"status":"error","timestamp":1697638153392,"user":{"displayName":"Johannes Kasper","userId":"06891618930953657970"},"user_tz":-120},"id":"1rfLUaBWFob8","outputId":"32e40ea8-f120-452a-a6c9-095105a203ad"},"outputs":[],"source":["from net2brain.utils.download_datasets import WorkshopCuttingGardens\n","paths = WorkshopCuttingGardens.load_dataset()\n","data_dir = paths[\"data_dir\"]"]},{"cell_type":"markdown","metadata":{"id":"XWhWeYWGOvlm"},"source":["## Unraveling Temporal Processing Hierarchies With ANN\n","\n","Previous research demonstrated that 2D, 3D, and Semantic network can act as proxies for various cognitive processes [Dwivedi 2021].\n","\n","\n","\n","This same process can be used to unravel how cognitive representations unravel through time instead of space.\n","\n","\n","## Roadmap\n","\n","\n","1. **Create an RDM from the EEG**: Leave one out pairwise classification\n","2. **Loading Models**: Loading 2d, 3D, and Semantic models from `Net2Brain`\n","3. **Feature Generation**: Extracting model feautures using the `BonnerPnas2017`-Dataset\n","4. **RDM Creating**: Turning the features from both models into one RDM per network layer\n","5. **Evaluation through RSA**: Comparing model to PPA-representations using RSA\n","\n","\n","[Dwivedi 2021] Dwivedi K, Bonner MF, Cichy RM, Roig G. Unveiling functions of the visual cortex using task-specific deep neural networks. PLoS Comput Biol. 2021"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"yv-_4bDJOvlm"},"outputs":[],"source":["import numpy as np\n","import matplotlib.pyplot as plt"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"Sc-_5fXZOvlm"},"outputs":[],"source":["subj_data = np.load(data_dir+'/data_sml.npy', allow_pickle=True)[()]"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":224,"status":"ok","timestamp":1697624742677,"user":{"displayName":"Gemma Roig","userId":"15872947373680703208"},"user_tz":-120},"id":"pdYmJz4SOvlm","outputId":"e594fee8-45c8-488a-a489-a8bcee5b69ba"},"outputs":[],"source":["subj_data['dat'].shape"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/"},"executionInfo":{"elapsed":2,"status":"ok","timestamp":1697624743539,"user":{"displayName":"Gemma Roig","userId":"15872947373680703208"},"user_tz":-120},"id":"5UHsag-JOvlm","outputId":"e04722d3-47aa-485a-b6bf-ba92914a9901"},"outputs":[],"source":["subj_data['lbl'].shape"]},{"cell_type":"markdown","metadata":{"id":"zeSBZMiLOvlm"},"source":["### 1. Claculating EEG RDMs\n","For each pair of images i,j find associated eeg trials Xi and Xj and using leave one out cross validation train a classifier, average accuracy is used for a distance measure. This is done at every timepoint. Pseudo code:\n","\n","```\n","for t in timepoints\n"," for i,j in image pairs\n"," accuracy_ij = 0\n"," for k in number of instances\n"," trn_I = all EEG instances for image i except k\n"," trn_J = all EEG instances for image j except k\n"," tst_I = EEG instance k for image i\n"," tst_J = EEG instance k for image j\n"," LDA.fit([trn_I,trn_J])\n"," accuracy_ij += LDA.predict([tst_I,tst_j])\n"," RDM[i,j,tt] = accuracy_ij\n","```"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"05DTWqHLOvlm"},"outputs":[],"source":["from net2brain.preprocess.rdm import eeg_rdm\n","rdm = eeg_rdm(subj_data['dat'],subj_data['lbl'])"]},{"cell_type":"code","execution_count":null,"metadata":{"colab":{"base_uri":"https://localhost:8080/","height":454},"executionInfo":{"elapsed":444,"status":"ok","timestamp":1697624867712,"user":{"displayName":"Gemma Roig","userId":"15872947373680703208"},"user_tz":-120},"id":"Ek9cRWKVOvlm","outputId":"1e2e5b80-d22e-4ab7-a504-bd55fbca59b5"},"outputs":[],"source":["plt.matshow(rdm[:,:,5])"]},{"cell_type":"markdown","metadata":{"id":"josleopNOvln"},"source":["### 2. Loading Models\n","To extract activations from a pretrained model of one of the netsets available with Net2Brain, you must first initialize the `FeatureExtractor` class and specify the name of the model as well as the netset it belongs to.\n","\n","__Note__: If you want to implement your _own_ pre-trained ANN, use the model as an argument of `Feature Extractor` like:\n","`FeatureExtractor(model=my_model, device='cuda')`"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"3xsPCcBAOvln","outputId":"6714a07b-36de-42a4-e3ff-739debafc5c8"},"outputs":[],"source":["from net2brain.feature_extraction import print_netset_models\n","print_netset_models('Taskonomy')"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"KnUj-B1vOvln"},"outputs":[],"source":["model_name = 'autoencoding'"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"N0epb6kGOvln"},"outputs":[],"source":["from net2brain.feature_extraction import FeatureExtractor\n","\n","fx_model = FeatureExtractor(model=model_name,\n"," netset='Taskonomy',\n"," device='cuda')"]},{"cell_type":"markdown","metadata":{"id":"cY08sLwKOvln"},"source":["### 3. Feature Generation"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"b2PT9dfVOvln","outputId":"e6075bde-a00b-4aa7-ae17-13da9e9bb6c1"},"outputs":[],"source":["# Create features for the chosen model\n","ft_path = f'feats_{model_name}'\n","fx_model.extract(data_path=data_dir+'./BonnerPnas2017',\n"," save_path=ft_path,\n"," layers_to_extract=['layer4'])"]},{"cell_type":"markdown","metadata":{"id":"eLSGYbtmOvln"},"source":["### RDM Creating:"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"jinK4zcTOvln","outputId":"2e2bd2e9-80d6-458c-e251-f53a7a77868f"},"outputs":[],"source":["from net2brain.rdm_creation import RDMCreator\n","\n","# Create RDMs for the model\n","creator_class = RDMCreator()\n","creator_class.create_rdms(feature_path=ft_path, save_path='model_rdm', save_format=\"npz\")"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"oKbhmlknOvlo","outputId":"5366e230-4847-4987-dc84-13a1bb7ee9e5"},"outputs":[],"source":["plt.matshow(np.load('./model_rdm/layer4.npz')['arr_0'])"]},{"cell_type":"markdown","metadata":{"id":"jbEAMBBOOvlo"},"source":["## Evaluation\n","Instead of RSA we will use unique variance partioning\n","\n",""]},{"cell_type":"markdown","metadata":{"id":"FlDygFjUOvlo"},"source":["# Loading all Data"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"oDTPQaGvOvlo"},"outputs":[],"source":["import os"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"s0LmwBpSOvlo"},"outputs":[],"source":["myPath = data_dir\n","myPath = os.path.abspath(myPath)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"__0iiaIdOvlo"},"outputs":[],"source":["paths_2D = ['RDM_taskonomy_nav/autoencoder_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/colorization_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/denoise_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/edge2d_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/inpainting_whole_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/keypoint2d_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/segment2d_encoder_block4.mat']\n","\n","paths_3D = ['RDM_taskonomy_nav/curvature_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/edge3d_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/keypoint3d_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/reshade_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/rgb2depth_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/rgb2mist_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/rgb2sfnorm_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/segment25d_encoder_block4.mat']\n","\n","paths_Sm = ['RDM_taskonomy_nav/class_1000_feedforward_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/class_places_feedforward_encoder_block4.mat',\n"," 'RDM_taskonomy_nav/segmentsemantic_encoder_block4.mat']\n","\n","paths_nv = ['./NAM_rdm.mat']\n","\n","\n","# Adding my own path\n","for i, path in enumerate(paths_2D):\n"," paths_2D[i] = myPath+'/'+path\n","for i, path in enumerate(paths_3D):\n"," paths_3D[i] = myPath+'/'+path\n","for i, path in enumerate(paths_Sm):\n"," paths_Sm[i] = myPath+'/'+path\n","for i, path in enumerate(paths_nv):\n"," paths_nv[i] = myPath+'/'+path"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"AiO58o49Ovlo"},"outputs":[],"source":["# Loading the dependent EEG data\n","eeg_path = data_dir+'/eeg_rdms_matlab_decoding_lt.npy'"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"vfxg6Z33Ovlo"},"outputs":[],"source":["from net2brain.evaluations.variance_partitioning_analysis import VPA\n","\n","independent_variables = [paths_2D, paths_3D, paths_Sm, paths_nv]\n","variable_names = [\"2D\", \"3D\", \"SM\", \"NV\"]\n","\n","VPA_eval = VPA(eeg_path, independent_variables, variable_names)\n","dataframe = VPA_eval.evaluate(average_models=True)\n","dataframe = dataframe.query(\"Variable in ['y1234', 'y1', 'y2', 'y3', 'y4']\").reset_index(drop=True)\n"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"5cmW3wBQOvlo"},"outputs":[],"source":["from net2brain.evaluations.plotting import Plotting\n","\n","# Plotting with significance\n","plotter = Plotting(dataframe)"]},{"cell_type":"code","execution_count":null,"metadata":{"id":"SYWLpY9XOvlo","outputId":"35756389-61f9-478b-ceb3-1870c1db81fb"},"outputs":[],"source":["plotter.plotting_over_time(add_std=True)"]}],"metadata":{"colab":{"provenance":[]},"kernelspec":{"display_name":"Python 3 (ipykernel)","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.10.13"}},"nbformat":4,"nbformat_minor":0}
+{
+ "cells": [
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "5JZLodA2Ovlj"
+ },
+ "source": [
+ "# Installing Net2Brain and Relevant Dependencies"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ ""
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "executionInfo": {
+ "elapsed": 133382,
+ "status": "ok",
+ "timestamp": 1697637683762,
+ "user": {
+ "displayName": "Johannes Kasper",
+ "userId": "06891618930953657970"
+ },
+ "user_tz": -120
+ },
+ "id": "kYeIGnfkOvll",
+ "outputId": "46c690fc-7570-4148-9c8b-8b09205e8ef7"
+ },
+ "outputs": [],
+ "source": [
+ "# !pip install -U git+https://github.com/cvai-roig-lab/Net2Brain"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "Retsh7xoOvll"
+ },
+ "source": [
+ "\n",
+ "\n",
+ "---\n",
+ "\n",
+ "\n",
+ "\n",
+ "---\n",
+ "\n",
+ "\n",
+ "## Restart Runtime\n",
+ "\n",
+ "\n",
+ "\n",
+ "---\n",
+ "\n",
+ "\n",
+ "\n",
+ "---\n"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {},
+ "source": [
+ "# Load Dataset"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 1,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/",
+ "height": 341
+ },
+ "executionInfo": {
+ "elapsed": 128923,
+ "status": "error",
+ "timestamp": 1697638153392,
+ "user": {
+ "displayName": "Johannes Kasper",
+ "userId": "06891618930953657970"
+ },
+ "user_tz": -120
+ },
+ "id": "1rfLUaBWFob8",
+ "outputId": "32e40ea8-f120-452a-a6c9-095105a203ad"
+ },
+ "outputs": [],
+ "source": [
+ "from net2brain.utils.download_datasets import WorkshopCuttingGardens\n",
+ "paths = WorkshopCuttingGardens.load_dataset()\n",
+ "data_dir = paths[\"data_dir\"]"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "XWhWeYWGOvlm"
+ },
+ "source": [
+ "## Unraveling Temporal Processing Hierarchies With ANN\n",
+ "\n",
+ "Previous research demonstrated that 2D, 3D, and Semantic network can act as proxies for various cognitive processes [Dwivedi 2021].\n",
+ "\n",
+ "\n",
+ "\n",
+ "This same process can be used to unravel how cognitive representations unravel through time instead of space.\n",
+ "\n",
+ "\n",
+ "## Roadmap\n",
+ "\n",
+ "\n",
+ "1. **Create an RDM from the EEG**: Leave one out pairwise classification\n",
+ "2. **Loading Models**: Loading 2d, 3D, and Semantic models from `Net2Brain`\n",
+ "3. **Feature Generation**: Extracting model feautures using the `BonnerPnas2017`-Dataset\n",
+ "4. **RDM Creating**: Turning the features from both models into one RDM per network layer\n",
+ "5. **Evaluation through RSA**: Comparing model to PPA-representations using RSA\n",
+ "\n",
+ "\n",
+ "[Dwivedi 2021] Dwivedi K, Bonner MF, Cichy RM, Roig G. Unveiling functions of the visual cortex using task-specific deep neural networks. PLoS Comput Biol. 2021"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 2,
+ "metadata": {
+ "id": "yv-_4bDJOvlm"
+ },
+ "outputs": [],
+ "source": [
+ "import numpy as np\n",
+ "import matplotlib.pyplot as plt"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 3,
+ "metadata": {
+ "id": "Sc-_5fXZOvlm"
+ },
+ "outputs": [],
+ "source": [
+ "subj_data = np.load(data_dir+'/data_sml.npy', allow_pickle=True)[()]"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 4,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "executionInfo": {
+ "elapsed": 224,
+ "status": "ok",
+ "timestamp": 1697624742677,
+ "user": {
+ "displayName": "Gemma Roig",
+ "userId": "15872947373680703208"
+ },
+ "user_tz": -120
+ },
+ "id": "pdYmJz4SOvlm",
+ "outputId": "e594fee8-45c8-488a-a489-a8bcee5b69ba"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(300, 17, 60)"
+ ]
+ },
+ "execution_count": 4,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "subj_data['dat'].shape"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 5,
+ "metadata": {
+ "colab": {
+ "base_uri": "https://localhost:8080/"
+ },
+ "executionInfo": {
+ "elapsed": 2,
+ "status": "ok",
+ "timestamp": 1697624743539,
+ "user": {
+ "displayName": "Gemma Roig",
+ "userId": "15872947373680703208"
+ },
+ "user_tz": -120
+ },
+ "id": "5UHsag-JOvlm",
+ "outputId": "e04722d3-47aa-485a-b6bf-ba92914a9901"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "(300,)"
+ ]
+ },
+ "execution_count": 5,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "subj_data['lbl'].shape"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "zeSBZMiLOvlm"
+ },
+ "source": [
+ "### 1. Claculating EEG RDMs\n",
+ "For each pair of images i,j find associated eeg trials Xi and Xj and using leave one out cross validation train a classifier, average accuracy is used for a distance measure. This is done at every timepoint. Pseudo code:\n",
+ "\n",
+ "```\n",
+ "for t in timepoints\n",
+ " for i,j in image pairs\n",
+ " accuracy_ij = 0\n",
+ " for k in number of instances\n",
+ " trn_I = all EEG instances for image i except k\n",
+ " trn_J = all EEG instances for image j except k\n",
+ " tst_I = EEG instance k for image i\n",
+ " tst_J = EEG instance k for image j\n",
+ " LDA.fit([trn_I,trn_J])\n",
+ " accuracy_ij += LDA.predict([tst_I,tst_j])\n",
+ " RDM[i,j,tt] = accuracy_ij\n",
+ "```"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 6,
+ "metadata": {
+ "id": "05DTWqHLOvlm"
+ },
+ "outputs": [
+ {
+ "data": {
+ "application/vnd.jupyter.widget-view+json": {
+ "model_id": "b31d907d7b854576a68f248199658320",
+ "version_major": 2,
+ "version_minor": 0
+ },
+ "text/plain": [
+ "Decoding RDM: 0%| | 0/60 [00:00"
+ ]
+ },
+ "execution_count": 7,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plt.matshow(rdm[:,:,5])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "josleopNOvln"
+ },
+ "source": [
+ "### 2. Loading Models\n",
+ "To extract activations from a pretrained model of one of the netsets available with Net2Brain, you must first initialize the `FeatureExtractor` class and specify the name of the model as well as the netset it belongs to.\n",
+ "\n",
+ "__Note__: If you want to implement your _own_ pre-trained ANN, use the model as an argument of `Feature Extractor` like:\n",
+ "`FeatureExtractor(model=my_model, device='cuda')`"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 9,
+ "metadata": {
+ "id": "3xsPCcBAOvln",
+ "outputId": "6714a07b-36de-42a4-e3ff-739debafc5c8"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ "['autoencoding',\n",
+ " 'curvature',\n",
+ " 'colorization',\n",
+ " 'class_object',\n",
+ " 'class_scene',\n",
+ " 'denoising',\n",
+ " 'euclidean',\n",
+ " 'depth',\n",
+ " 'edge_occlusion',\n",
+ " 'edge_texture',\n",
+ " 'egomotion',\n",
+ " 'fixated_pose',\n",
+ " 'inpainting',\n",
+ " 'jigsaw',\n",
+ " 'keypoints2d',\n",
+ " 'keypoints3d',\n",
+ " 'nonfixated_pose',\n",
+ " 'normal',\n",
+ " 'point_matching',\n",
+ " 'reshading',\n",
+ " 'room_layout',\n",
+ " 'segment_unsup2d',\n",
+ " 'segment_unsup25d',\n",
+ " 'segment_semantic',\n",
+ " 'vanishing_point']"
+ ]
+ },
+ "execution_count": 9,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from net2brain.taxonomy import print_netset_models\n",
+ "print_netset_models('Taskonomy')"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 10,
+ "metadata": {
+ "id": "KnUj-B1vOvln"
+ },
+ "outputs": [],
+ "source": [
+ "model_name = 'autoencoding'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": null,
+ "metadata": {
+ "id": "N0epb6kGOvln"
+ },
+ "outputs": [],
+ "source": [
+ "from net2brain.feature_extraction import FeatureExtractor\n",
+ "\n",
+ "fx_model = FeatureExtractor(model=model_name,\n",
+ " netset='Taskonomy',\n",
+ " device='cuda')"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "cY08sLwKOvln"
+ },
+ "source": [
+ "### 3. Feature Generation"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 14,
+ "metadata": {
+ "id": "b2PT9dfVOvln",
+ "outputId": "e6075bde-a00b-4aa7-ae17-13da9e9bb6c1"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "Processing files: 100%|██████████| 4/4 [00:00<00:00, 20.35it/s, subfiles=1/1]\n"
+ ]
+ },
+ {
+ "name": "stdout",
+ "output_type": "stream",
+ "text": [
+ "Consolidating data per layer...\n"
+ ]
+ },
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "100%|██████████| 4/4 [00:00<00:00, 1022.00it/s]\n"
+ ]
+ }
+ ],
+ "source": [
+ "# Create features for the chosen model\n",
+ "ft_path = f'feats_{model_name}'\n",
+ "fx_model.extract(data_path=data_dir+'/BonnerPnas2017',\n",
+ " save_path=ft_path,\n",
+ " layers_to_extract=['layer4'])"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "eLSGYbtmOvln"
+ },
+ "source": [
+ "### RDM Creating:"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 15,
+ "metadata": {
+ "id": "jinK4zcTOvln",
+ "outputId": "2e2bd2e9-80d6-458c-e251-f53a7a77868f"
+ },
+ "outputs": [
+ {
+ "name": "stderr",
+ "output_type": "stream",
+ "text": [
+ "/Users/domenicbersch/Documents/Repositories/Net2Brain/net2brain/rdm/feature_iterator.py:388: UserWarning: Keyword arguments provided for dimensionality reduction only supported for NPZ_SEPARATE, and will have no effect for the provided format FeatureFormat.NPZ_CONSOLIDATED.\n",
+ " warnings.warn(f\"Keyword arguments provided for dimensionality reduction only supported for NPZ_SEPARATE, \"\n"
+ ]
+ },
+ {
+ "data": {
+ "text/plain": [
+ "PosixPath('model_rdm')"
+ ]
+ },
+ "execution_count": 15,
+ "metadata": {},
+ "output_type": "execute_result"
+ }
+ ],
+ "source": [
+ "from net2brain.rdm_creation import RDMCreator\n",
+ "\n",
+ "# Create RDMs for the model\n",
+ "creator_class = RDMCreator()\n",
+ "creator_class.create_rdms(feature_path=ft_path, save_path='model_rdm', save_format=\"npz\")"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 29,
+ "metadata": {
+ "id": "oKbhmlknOvlo",
+ "outputId": "5366e230-4847-4987-dc84-13a1bb7ee9e5"
+ },
+ "outputs": [
+ {
+ "data": {
+ "text/plain": [
+ ""
+ ]
+ },
+ "execution_count": 29,
+ "metadata": {},
+ "output_type": "execute_result"
+ },
+ {
+ "data": {
+ "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZUAAAGQCAYAAABmlv2IAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMiwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8g+/7EAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAfvklEQVR4nO3df2yV5f3/8ddpoS2Mnirp2vLj8Knz5xBplyJdZTrcp9IPLp3kmyWNLrZrHEtcS9BmieCE+mNanJNgYgeKMvxjHY1k6KZYonWFr7EEKZKvGH+EiaNRT1tibOsx9MC57+8fyHH9ULDn3PfVc+7ez0dyxfTmvs717onhzft93T8Ctm3bAgDABRmpDgAAMHmQVAAAriGpAABcQ1IBALiGpAIAcA1JBQDgGpIKAMA1JBUAgGumpDoAAJjMTp48qWg06vhzsrKylJOT40JEZpFUAMCQkydP6pL/mqFwf8zxZxUVFenYsWNpn1hIKgBgSDQaVbg/pmM9/6VgbvK7DUPDli4p+7ei0ShJBQD87jszzoxkxTz0hEY26gEArqFSAQDDLNmylHy54WTuRCOpAIBhlixZDud7Be0vAIBrqFQAwLCYbSvm4H2ITuZONJIKABjmpz0V2l8AANdQqQCAYZZsxXxSqZBUAMAw2l8AACSBSgUADPPT1V++r1RaW1tVXFysnJwclZeX68CBA6kOKe3s27dP1dXVmj17tgKBgF544YVUh5SWWlpadO211yo3N1cFBQVasWKFPvjgg1SHlZY2b96shQsXKhgMKhgMqqKiQq+88kqqwzLGcmF4ha+TSnt7u5qamtTc3KxDhw6ppKREVVVV6u/vT3VoaSUSiaikpEStra2pDiWt7d27Vw0NDdq/f79effVVnTp1SsuWLVMkEkl1aGln7ty52rBhg3p6enTw4EH95Cc/0S233KJ333031aEZEft6o97J8IqAbXuornJZeXm5rr32Wj355JOSJMuyFAqFtGrVKq1ZsybF0aWnQCCgXbt2acWKFakOJe0NDAyooKBAe/fu1Q033JDqcNLezJkz9dhjj+mOO+5IdSiuGRoaUl5ent59r0C5Dh59Pzxs6erv92twcFDBYNDFCN3n20olGo2qp6dHlZWV8WMZGRmqrKxUd3d3CiPDZDE4OCjpzF+WOL9YLKYdO3YoEomooqIi1eEYEbOdD6/w7Ub9iRMnFIvFVFhYOOp4YWGh3n///RRFhcnCsizdddddWrJkiRYsWJDqcNLSO++8o4qKCp08eVIzZszQrl27NH/+/FSHZYTTfREv7an4NqkAJjU0NOjIkSN64403Uh1K2rryyit1+PBhDQ4OaufOnaqrq9PevXsnbWLxC98mlfz8fGVmZqqvr2/U8b6+PhUVFaUoKkwGjY2Neumll7Rv3z7NnTs31eGkraysLF122WWSpLKyMr311lt64okn9NRTT6U4MvdZCiimgKP5XuHbPZWsrCyVlZWps7MzfsyyLHV2dk7avi7Msm1bjY2N2rVrl15//XVdcsklqQ7JUyzL0sjISKrDMMKynQ+v8G2lIklNTU2qq6vTokWLtHjxYm3atEmRSET19fWpDi2tfPnllzp69Gj852PHjunw4cOaOXOm5s2bl8LI0ktDQ4Pa2tr04osvKjc3V+FwWJKUl5enadOmpTi69LJ27VotX75c8+bN0/DwsNra2tTV1aU9e/akOjQ45OukUlNTo4GBAa1fv17hcFilpaXq6Og4Z/Pe7w4ePKgbb7wx/nNTU5Mkqa6uTtu3b09RVOln8+bNkqSlS5eOOv7nP/9Zv/zlLyc+oDTW39+v2tpaffbZZ8rLy9PChQu1Z88e3XTTTakOzYiYw/aXk7kTzdf3qQCASWfvU3nz3Vma4eA+lS+HLV139WfcpwIA8Bdft78AYCJYdkCW7eDqLwdzJxpJBQAM89OeCu0vAIBrqFQAwLCYMhRz8G/4mIuxmEZSAQDDbId7KjZ7KgCAs9hT8ZmRkRHdf//9k/YREW7hexo/vqvx4XuafLj5Ud/coOSFG4tSie9p/Piuxmeyf09nf79X/t8l+o6Dmx8jw5aWLzzmie+J9hcAGGYpIMtBY8jy0OuEaX8BAFwz4ZWKZVn69NNPlZubq0AgPTafhoaGRv0XY+N7Gj++q/FJx+/Jtm0NDw9r9uzZyshw59/dftqon/Ck8umnnyoUCk30suOSrnGlG76n8eO7Gp90/J56e3tde8lazM5QzHZwn4qHtr4nPKnk5uZKkn6kmzVFUyd6eU+x/jEn1SF4xqrQ66kOwRP+OlCe6hDS3qlIVP9Y8df431VIzIQnlbMtrymaqikBksqFWN/JTnUInjE9NzPVIXjC1K+yUh2CZ7jZnj+zUe+P1wlz9RcAGGY5fEwLV38BAHyJSgUADGOjHgDgGksZ3PwIAECiqFQAwLCYHVDMwePrncydaCQVADDM+Uu6vNP+IqkAgGGWnSHLwUa95aGNevZUAACuoVIBAMP81P6iUgEAwyx9s1mfzLCSXLe1tVXFxcXKyclReXm5Dhw4cMHzN23apCuvvFLTpk1TKBTS3XffrZMnTya0JkkFACah9vZ2NTU1qbm5WYcOHVJJSYmqqqrU398/5vltbW1as2aNmpub9d577+nZZ59Ve3u77r333oTWJakAgGFnb350MhK1ceNGrVy5UvX19Zo/f762bNmi6dOna9u2bWOe/+abb2rJkiW67bbbVFxcrGXLlunWW2/91urmfyOpAIBhZx/T4mRIZ15m9p9jZGRkzPWi0ah6enpUWVkZP5aRkaHKykp1d3ePOee6665TT09PPIl89NFH2r17t26++eaEfleSCgB4RCgUUl5eXny0tLSMed6JEycUi8VUWFg46nhhYaHC4fCYc2677TY9+OCD+tGPfqSpU6fq0ksv1dKlSxNuf3H1FwAY5tb7VHp7exUMBuPHs7Pde+dSV1eXHnnkEf3pT39SeXm5jh49qtWrV+uhhx7SunXrxv05JBUAMMz5U4rPzA0Gg6OSyvnk5+crMzNTfX19o4739fWpqKhozDnr1q3T7bffrl/96leSpGuuuUaRSES//vWv9bvf/U4ZGeOLn/YXAEwyWVlZKisrU2dnZ/yYZVnq7OxURUXFmHO++uqrcxJHZuaZN6raCdzRT6UCAIY5v/kx8blNTU2qq6vTokWLtHjxYm3atEmRSET19fWSpNraWs2ZMye+L1NdXa2NGzfqBz/4Qbz9tW7dOlVXV8eTy3iQVADAMMsOyHLwpOFk5tbU1GhgYEDr169XOBxWaWmpOjo64pv3x48fH1WZ3HfffQoEArrvvvv0ySef6Lvf/a6qq6v18MMPJ7QuSQUAJqnGxkY1NjaO+WddXV2jfp4yZYqam5vV3NzsaE2SCgAYZjlsfzl5a+REI6kAgGHOH31PUgEAfC2mgGIO7lNxMneieSf9AQDSHpUKABhG+wsA4JqYnLWwYu6FYpx30h8AIO1RqQCAYbS/AACuceuBkl6QVKSJvvcYAOAPCSeVRN97DAB+Z3/9PpVkhz2Z71NJ9L3HAOB3br1O2AsSijSZ9x6PjIyc815lAMDklFBSSea9xy0tLaPeqRwKhZKPFgA86Oyj750MrzBeU61du1aDg4Px0dvba3pJAEgrZ1/S5WR4RUKXFCfz3uPs7GxlZ2cnHyEAwDMSSn/JvPcYAPzOT+2vhG9+/Lb3HgMARrOU4ehFW5P6JV3f9t5jAMBoMTugmINqw8nciZbUY1ou9N5jAIB/8ewvADDM6b7IpN5TAQAkxnb4lGJ7st5RDwDAhVCpAIBhMQUcvvmR9hcA4GuW7WxfxLJdDMYw2l8AANdQqQCAYbxOGADgmrMv23Iy3yu8k/4AAGmPSgUADOMxLQAA1/hpT8U7kQIA0h6VCgAYZsnhs788tFFPUgEAw2yHV3/ZJBUAwFl+ekoxeyoAANdQqQCAYX66+oukAgCG0f4CACAJVCoAYJifnv1FUgEAw2h/AQCQBCoVADDMT5UKSQUADPNTUqH9BQBwDZUKABjmp0qFpAIAhtlydlmw7V4oxpFUAMAwP1Uq7KkAAFyTskrF+sccWd/JTtXynpDx372pDsEz/ufTkVSH4Amd075IdQhpbyR2yvXP9FOlQvsLAAzzU1Kh/QUAcA2VCgAY5qdKhaQCAIbZdkC2g8TgZO5Eo/0FAHANlQoAGMb7VAAArvHTngrtLwCAa6hUAMAwP23Uk1QAwDDaXwAAJIFKBQAMo/0FAHCN7bD9RVIBAMTZkmwHb9ry0ku62FMBALiGSgUADLMUUIA76gEAbvDTRj3tLwCAa6hUAMAwyw4owM2PAAA32LbzkYzW1lYVFxcrJydH5eXlOnDgwAXP/+KLL9TQ0KBZs2YpOztbV1xxhXbv3p3QmlQqADAJtbe3q6mpSVu2bFF5ebk2bdqkqqoqffDBByooKDjn/Gg0qptuukkFBQXauXOn5syZo3//+9+66KKLElqXpAIAhqVio37jxo1auXKl6uvrJUlbtmzRyy+/rG3btmnNmjXnnL9t2zZ9/vnnevPNNzV16lRJUnFxccLr0v4CAMPOJhUnQ5KGhoZGjZGRkTHXi0aj6unpUWVlZfxYRkaGKisr1d3dPeacv//976qoqFBDQ4MKCwu1YMECPfLII4rFYgn9riQVAPCIUCikvLy8+GhpaRnzvBMnTigWi6mwsHDU8cLCQoXD4THnfPTRR9q5c6disZh2796tdevW6fHHH9fvf//7hGKk/QUAhrl19Vdvb6+CwWD8eHZ2tuPY4mtYlgoKCvT0008rMzNTZWVl+uSTT/TYY4+publ53J9DUgEAw5xcwXV2viQFg8FRSeV88vPzlZmZqb6+vlHH+/r6VFRUNOacWbNmaerUqcrMzIwf+/73v69wOKxoNKqsrKxxxUr7CwAmmaysLJWVlamzszN+zLIsdXZ2qqKiYsw5S5Ys0dGjR2VZVvzYhx9+qFmzZo07oUgkFQAw7kyl4mSjPvE1m5qatHXrVj333HN67733dOeddyoSicSvBqutrdXatWvj59955536/PPPtXr1an344Yd6+eWX9cgjj6ihoSGhdWl/AYBhqbikuKamRgMDA1q/fr3C4bBKS0vV0dER37w/fvy4MjK+qStCoZD27Nmju+++WwsXLtScOXO0evVq3XPPPQmtS1IBAMNsOXsnSrJzGxsb1djYOOafdXV1nXOsoqJC+/fvT3K1M2h/AQBcQ6UCAIb56dH3JBUAMC1V/a8USLj9tW/fPlVXV2v27NkKBAJ64YUXDIQFAPCihJNKJBJRSUmJWltbTcQDAJOP0+d+Teb21/Lly7V8+XITsQDApOTWHfVeYHxPZWRkZNSTNIeGhkwvCQBIEeOXFLe0tIx6qmYoFDK9JACkFbcefe8FxpPK2rVrNTg4GB+9vb2mlwSA9HJ2X8TJ8Ajj7a/s7GxXH88MAEhf3KcCAIaxUX8BX375pY4ePRr/+dixYzp8+LBmzpypefPmuRocAEwKPrr5MeGkcvDgQd14443xn5uamiRJdXV12r59u2uBAQC8J+GksnTpUtleqsUAIMV49hcAwF0++bc4SQUADPNTpcL7VAAArqFSAQDTuPoLAOCewNfDyXxvoP0FAHANlQoAmEb7CwDgGh8lFdpfAADXUKkAgGlOH1/voftUSCoAYJifnlJM+wsA4BoqFQAwzUcb9SQVADDNR3sqtL8AAK6hUgEAwwL2meFkvleQVADANPZUAACuYU8FAIDEUakAgGm0vwAArvFRUqH9BQBwDZUKAJjmo0qFpAIApnH1FwAAiaNSAQDDuKMeAOAeH+2p0P4CALiGpAIAcA3tLwAwLCCHeyquRWJeypLKqtDrmp6bmarlPeF/Ph1JdQieUTW7NNUheELlkaFUh5D2TmadTnUInkalAgCm+eg+FZIKAJjmo6u/SCoAYJqPkgpXfwEAXEOlAgCGcUc9AMA9tL8AAEgclQoAmOajSoWkAgCG+WlPhfYXAMA1VCoAYBp31AMAXOOjPRXaXwAA11CpAIBhftqoJ6kAgGk+an+RVADANIeVipeSCnsqAADXUKkAgGm0vwAArvFRUqH9BQBwDZUKABjmp0uKqVQAAK4hqQAAXENSAQDTbBdGElpbW1VcXKycnByVl5frwIED45q3Y8cOBQIBrVixIuE1SSoAYNjZPRUnI1Ht7e1qampSc3OzDh06pJKSElVVVam/v/+C8z7++GP99re/1fXXX5/U70pSAYBJaOPGjVq5cqXq6+s1f/58bdmyRdOnT9e2bdvOOycWi+kXv/iFHnjgAX3ve99Lal2SCgBMBBdaX0NDQ6PGyMjImEtFo1H19PSosrIyfiwjI0OVlZXq7u4+b4gPPvigCgoKdMcddyT9a5JUAMA0l/ZUQqGQ8vLy4qOlpWXM5U6cOKFYLKbCwsJRxwsLCxUOh8ec88Ybb+jZZ5/V1q1bHf2q3KcCAB7R29urYDAY/zk7O9uVzx0eHtbtt9+urVu3Kj8/39FnkVQAwDC3bn4MBoOjksr55OfnKzMzU319faOO9/X1qaio6Jzz//Wvf+njjz9WdXV1/JhlWZKkKVOm6IMPPtCll146rlhpfwGAaRN8SXFWVpbKysrU2dkZP2ZZljo7O1VRUXHO+VdddZXeeecdHT58OD5+9rOf6cYbb9Thw4cVCoXGvTaVCgAYlorHtDQ1Namurk6LFi3S4sWLtWnTJkUiEdXX10uSamtrNWfOHLW0tCgnJ0cLFiwYNf+iiy6SpHOOfxuSCgBMQjU1NRoYGND69esVDodVWlqqjo6O+Ob98ePHlZHhfrMqoaTS0tKiv/3tb3r//fc1bdo0XXfddXr00Ud15ZVXuh4YAEwaKXr0fWNjoxobG8f8s66urgvO3b59e1JrJpSm9u7dq4aGBu3fv1+vvvqqTp06pWXLlikSiSS1OAD4Qooe05IKCVUqHR0do37evn27CgoK1NPToxtuuMHVwAAA3uNoT2VwcFCSNHPmzPOeMzIyMuquz6GhISdLAoDn8D6VcbAsS3fddZeWLFlywasDWlpaRt0BmsilaQAwKfio/ZV0UmloaNCRI0e0Y8eOC563du1aDQ4Oxkdvb2+ySwIA0lxS7a/Gxka99NJL2rdvn+bOnXvBc7Ozs117lAAAeFKKrv5KhYSSim3bWrVqlXbt2qWuri5dcsklpuICgEnDT3sqCSWVhoYGtbW16cUXX1Rubm78aZd5eXmaNm2akQABAN6R0J7K5s2bNTg4qKVLl2rWrFnx0d7ebio+APA+H23UJ9z+AgAkxk/tL55SDABwDQ+UBADTuPoLAOAakgoAwC2Br4eT+V7BngoAwDVUKgBgGu0vAIBbuKQYAIAkUKkAgGm0vwAArvJQYnCC9hcAwDVUKgBgmJ826kkqAGCaj/ZUaH8BAFxDpQIAhtH+AgC4h/YXAACJo1IBAMNofwEA3OOj9hdJBQBM81FSYU8FAOAaKhUAMIw9FQCAe2h/AQCQOCoVADAsYNsK2MmXG07mTjSSCgCYRvsLAIDEUakAgGFc/QUAcI+P2l8pSyp/HSjX1K+yUrW8J3RO+yLVIXhG5ZGhVIfgCa8tyE11CGnvtH0q1SF4GpUKABhG+wsA4B4ftb+4+gsA4BoqFQAwjPYXAMA9Pmp/kVQAYAJ4qdpwgj0VAIBrqFQAwDTbPjOczPcIkgoAGOanjXraXwAA11CpAIBpXP0FAHBLwDoznMz3CtpfAADXUKkAgGm0vwAAbuHqLwAAkkClAgCmcfMjAMAttL8AAEgClQoAmMbVXwAAt/ip/UVSAQDTfLRRz54KAMA1VCoAYBjtLwCAe3y0UU/7CwDgGioVADCM9hcAwD2WfWY4me8RtL8AYJJqbW1VcXGxcnJyVF5ergMHDpz33K1bt+r666/XxRdfrIsvvliVlZUXPP98SCoAYJrtwkhQe3u7mpqa1NzcrEOHDqmkpERVVVXq7+8f8/yuri7deuut+uc//6nu7m6FQiEtW7ZMn3zySULrklQAwLCAvtlXSWoksebGjRu1cuVK1dfXa/78+dqyZYumT5+ubdu2jXn+X/7yF/3mN79RaWmprrrqKj3zzDOyLEudnZ0JrUtSAQCPGBoaGjVGRkbGPC8ajaqnp0eVlZXxYxkZGaqsrFR3d/e41vrqq6906tQpzZw5M6EYSSoAYNrZx7Q4GZJCoZDy8vLio6WlZczlTpw4oVgspsLCwlHHCwsLFQ6HxxXyPffco9mzZ49KTOORUFLZvHmzFi5cqGAwqGAwqIqKCr3yyisJLQgAfuOo9fUflyP39vZqcHAwPtauXWsk3g0bNmjHjh3atWuXcnJyEpqb0CXFc+fO1YYNG3T55ZfLtm0999xzuuWWW/T222/r6quvTmhhAPANl+6oP/sP+m+Tn5+vzMxM9fX1jTre19enoqKiC8794x//qA0bNui1117TwoULEw41oUqlurpaN998sy6//HJdccUVevjhhzVjxgzt378/4YUBAGZkZWWprKxs1Cb72U33ioqK8877wx/+oIceekgdHR1atGhRUmsnffNjLBbT888/r0gkcsEgR0ZGRm0mDQ0NJbskAHhSwLYVcPD4+mTmNjU1qa6uTosWLdLixYu1adMmRSIR1dfXS5Jqa2s1Z86c+L7Mo48+qvXr16utrU3FxcXxvZcZM2ZoxowZ41434aTyzjvvqKKiQidPntSMGTO0a9cuzZ8//7znt7S06IEHHkh0GQCYPKyvh5P5CaqpqdHAwIDWr1+vcDis0tJSdXR0xDfvjx8/royMb5pVmzdvVjQa1c9//vNRn9Pc3Kz7779/3OsGbDuxFBiNRnX8+HENDg5q586deuaZZ7R3797zJpaxKpVQKKT/82qdpn4nK5GlfWfOtC9SHYJnFGRRAY/HawtyUx1C2jttn1KXXtTg4OC49i8uZGhoSHl5ebr+hmZNmZLYhveomE6f1P/d94ArMZmWcKWSlZWlyy67TJJUVlamt956S0888YSeeuqpMc/Pzs5Wdna2sygBwMNS0f5KFccPlLQs67w34AAA5Kv3qSSUVNauXavly5dr3rx5Gh4eVltbm7q6urRnzx5T8QEAPCShpNLf36/a2lp99tlnysvL08KFC7Vnzx7ddNNNpuIDAO/7j7vik57vEQkllWeffdZUHAAwafnpJV08+wsA4Bre/AgAptH+AgC4JWCdGU7mewXtLwCAa6hUAMA02l8AANdw8yMAwC1+ekwLeyoAANdQqQCAaeypAABcY8vZ+1S8k1NofwEA3EOlAgCG+WmjnqQCAKbZcrin4lokxtH+AgC4hkoFAEzj6i8AgGssSQGH8z2C9hcAwDVUKgBgGFd/AQDc46M9FdpfAADXUKkAgGk+qlRIKgBgGkkFAOAaLikGACBxVCoAYBiXFAMA3OOjPRXaXwAA11CpAIBpli0FHFQblncqFZIKAJjmo/bXhCcV++sv51QkOtFLe85I7FSqQ/CMk1mnUx2CJ5y2+X/q25zWme/I9tBf5OlkwpPK8PCwJOkfK/460UsDwLgNDw8rLy/PpU9zWKl46NWPE55UZs+erd7eXuXm5ioQcHI3kHuGhoYUCoXU29urYDCY6nDSFt/T+PFdjU86fk+2bWt4eFizZ89280Npf5mSkZGhuXPnTvSy4xIMBtPmf+x0xvc0fnxX45Nu35N7FYr/sFEPAKZZthy1sLj6CwAQZ1tnhpP5HsHNj5Kys7PV3Nys7OzsVIeS1viexo/vanz4niafgM11cwBgxNDQkPLy8lQZulNTMpJPnKetEb3Wu1mDg4Nptfc0FtpfAGAaeyoAANf46JJi9lQAAK6hUgEA02w5rFRci8Q4kgoAmEb7CwCAxFGpAIBpliXJwQ2MlndufiSpAIBptL8AAEgclQoAmOajSoWkAgCm+eiOetpfAADXUKkAgGG2bcl28Ph6J3MnGkkFAEyzbWctLA/tqdD+AgC4hkoFAEyzHW7Ue6hSIakAgGmWJQX88TphkgoAmOajSoU9FQCAa6hUAMAw27JkO2h/cUkxAOAbtL8AAEgclQoAmGbZUsAflQpJBQBMs205ekmXh5IK7S8AgGuoVADAMNuyZTtof9keqlRIKgBgmu3wHfUeuqSY9hcATFKtra0qLi5WTk6OysvLdeDAgQue//zzz+uqq65STk6OrrnmGu3evTvhNUkqAGCYbdmOR6La29vV1NSk5uZmHTp0SCUlJaqqqlJ/f/+Y57/55pu69dZbdccdd+jtt9/WihUrtGLFCh05ciShdQO2l5p1AOAhQ0NDysvL01LdoimBqUl/zmn7lLr0ogYHBxUMBsc1p7y8XNdee62efPJJSZJlWQqFQlq1apXWrFlzzvk1NTWKRCJ66aWX4sd++MMfqrS0VFu2bBl3rFQqAGDYaZ3SadvB0ClJZ5LUf46RkZEx14tGo+rp6VFlZWX8WEZGhiorK9Xd3T3mnO7u7lHnS1JVVdV5zz8fNuoBwJCsrCwVFRXpjXDiexP/24wZMxQKhUYda25u1v3333/OuSdOnFAsFlNhYeGo44WFhXr//ffH/PxwODzm+eFwOKE4SSoAYEhOTo6OHTumaDTq+LNs21YgEBh1LDs72/Hnuo2kAgAG5eTkKCcnZ0LXzM/PV2Zmpvr6+kYd7+vrU1FR0ZhzioqKEjr/fNhTAYBJJisrS2VlZers7IwfsyxLnZ2dqqioGHNORUXFqPMl6dVXXz3v+edDpQIAk1BTU5Pq6uq0aNEiLV68WJs2bVIkElF9fb0kqba2VnPmzFFLS4skafXq1frxj3+sxx9/XD/96U+1Y8cOHTx4UE8//XRC65JUAGASqqmp0cDAgNavX69wOKzS0lJ1dHTEN+OPHz+ujIxvmlXXXXed2tradN999+nee+/V5ZdfrhdeeEELFixIaF3uUwEAuIY9FQCAa0gqAADXkFQAAK4hqQAAXENSAQC4hqQCAHANSQUA4BqSCgDANSQVAIBrSCoAANeQVAAArvn/GvuOddqp4GgAAAAASUVORK5CYII=",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "from scipy.spatial.distance import squareform\n",
+ "plt.matshow(squareform(np.load('model_rdm/RDM_layer4.npz')['rdm']))\n",
+ "plt.colorbar()"
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "jbEAMBBOOvlo"
+ },
+ "source": [
+ "## Evaluation\n",
+ "Instead of RSA we will use unique variance partioning\n",
+ "\n",
+ ""
+ ]
+ },
+ {
+ "cell_type": "markdown",
+ "metadata": {
+ "id": "FlDygFjUOvlo"
+ },
+ "source": [
+ "# Loading all Data"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 31,
+ "metadata": {
+ "id": "oDTPQaGvOvlo"
+ },
+ "outputs": [],
+ "source": [
+ "import os"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 32,
+ "metadata": {
+ "id": "s0LmwBpSOvlo"
+ },
+ "outputs": [],
+ "source": [
+ "myPath = data_dir\n",
+ "myPath = os.path.abspath(myPath)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 33,
+ "metadata": {
+ "id": "__0iiaIdOvlo"
+ },
+ "outputs": [],
+ "source": [
+ "paths_2D = ['RDM_taskonomy_nav/autoencoder_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/colorization_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/denoise_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/edge2d_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/inpainting_whole_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/keypoint2d_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/segment2d_encoder_block4.mat']\n",
+ "\n",
+ "paths_3D = ['RDM_taskonomy_nav/curvature_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/edge3d_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/keypoint3d_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/reshade_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/rgb2depth_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/rgb2mist_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/rgb2sfnorm_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/segment25d_encoder_block4.mat']\n",
+ "\n",
+ "paths_Sm = ['RDM_taskonomy_nav/class_1000_feedforward_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/class_places_feedforward_encoder_block4.mat',\n",
+ " 'RDM_taskonomy_nav/segmentsemantic_encoder_block4.mat']\n",
+ "\n",
+ "paths_nv = ['./NAM_rdm.mat']\n",
+ "\n",
+ "\n",
+ "# Adding my own path\n",
+ "for i, path in enumerate(paths_2D):\n",
+ " paths_2D[i] = myPath+'/'+path\n",
+ "for i, path in enumerate(paths_3D):\n",
+ " paths_3D[i] = myPath+'/'+path\n",
+ "for i, path in enumerate(paths_Sm):\n",
+ " paths_Sm[i] = myPath+'/'+path\n",
+ "for i, path in enumerate(paths_nv):\n",
+ " paths_nv[i] = myPath+'/'+path"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 34,
+ "metadata": {
+ "id": "AiO58o49Ovlo"
+ },
+ "outputs": [],
+ "source": [
+ "# Loading the dependent EEG data\n",
+ "eeg_path = data_dir+'/eeg_rdms_matlab_decoding_lt.npy'"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 35,
+ "metadata": {
+ "id": "vfxg6Z33Ovlo"
+ },
+ "outputs": [],
+ "source": [
+ "from net2brain.evaluations.variance_partitioning_analysis import VPA\n",
+ "\n",
+ "independent_variables = [paths_2D, paths_3D, paths_Sm, paths_nv]\n",
+ "variable_names = [\"2D\", \"3D\", \"SM\", \"NV\"]\n",
+ "\n",
+ "VPA_eval = VPA(eeg_path, independent_variables, variable_names)\n",
+ "dataframe = VPA_eval.evaluate(average_models=True)\n",
+ "dataframe = dataframe.query(\"Variable in ['y1234', 'y1', 'y2', 'y3', 'y4']\").reset_index(drop=True)\n"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 37,
+ "metadata": {
+ "id": "5cmW3wBQOvlo"
+ },
+ "outputs": [],
+ "source": [
+ "from net2brain.evaluations.plotting import Plotting\n",
+ "\n",
+ "# Plotting with significance\n",
+ "plotter = Plotting(dataframe)"
+ ]
+ },
+ {
+ "cell_type": "code",
+ "execution_count": 38,
+ "metadata": {
+ "id": "SYWLpY9XOvlo",
+ "outputId": "35756389-61f9-478b-ceb3-1870c1db81fb"
+ },
+ "outputs": [
+ {
+ "data": {
+ "image/png": "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",
+ "text/plain": [
+ ""
+ ]
+ },
+ "metadata": {},
+ "output_type": "display_data"
+ }
+ ],
+ "source": [
+ "plotter.plotting_over_time(add_std=True)"
+ ]
+ }
+ ],
+ "metadata": {
+ "colab": {
+ "provenance": []
+ },
+ "kernelspec": {
+ "display_name": "N2B",
+ "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.10.13"
+ }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 0
+}