def __init__(self, identifier):
regression = linear_regression(xarray_kwargs=dict(stimulus_coord='stimulus_id')) # word
correlation = pearsonr_correlation(xarray_kwargs=dict(correlation_coord='stimulus_id'))
metric = CrossRegressedCorrelation(regression=regression, correlation=correlation,
crossvalidation_kwargs=dict(splits=5, kfold=True, split_coord='stimulus_id',
stratification_coord='sentence_id'))
super(Fedorenko2016Encoding, self).__init__(identifier=identifier, metric=metric)
def ToliasCadena2017PLS():
loader = AssemblyLoader()
assembly_repetition = loader(average_repetition=False)
assembly = loader(average_repetition=True)
assembly.stimulus_set.name = assembly.stimulus_set_name
similarity_metric = CrossRegressedCorrelation(
regression=pls_regression(),
correlation=pearsonr_correlation(),
crossvalidation_kwargs={'stratification_coord': None})
identifier = f'tolias.Cadena2017-pls'
ceiler = InternalConsistency(split_coord='repetition_id')
def ceiling():
# This assembly has many stimuli that are only shown to a subset of the neurons.
# When the loader runs with `average_repetition=True`, it automatically drops nan cells,
# but for the `assembly_repetition`, it keeps all the rows.
# If we now use the usual ceiling approach, the two halves will end up with NaN values
# due to stimuli not being shown to neurons, which doesn't let us correlate.
# Instead, we here drop all NaN cells and their corresponding stimuli,
# which keeps only 43% of the original presentation rows, but lets us correlate again.
assembly_nonan, stimuli = loader.dropna(assembly_repetition, assembly_repetition.attrs['stimulus_set'])
return ceiler(assembly_nonan)
return NeuralBenchmark(identifier=identifier, version=1,
assembly=assembly, similarity_metric=similarity_metric, visual_degrees=VISUAL_DEGREES,
ceiling_func=ceiling)
def __init__(self):
ceiling = Score([1, np.nan],
coords={'aggregation': ['center', 'error']},
dims=['aggregation'])
assembly_repetition = get_assembly()
assert len(np.unique(assembly_repetition['region'])) == 1
assert hasattr(assembly_repetition, 'repetition')
self.region = 'IT'
self.assembly = average_repetition(assembly_repetition)
self._assembly = self.assembly
self.timebins = timebins_from_assembly(self.assembly)
self._similarity_metric = CrossRegressedCorrelation(
regression=pls_regression(),
correlation=pearsonr_correlation(),
crossvalidation_kwargs=dict(
stratification_coord=Split.Defaults.stratification_coord
if hasattr(self.assembly, Split.Defaults.stratification_coord
) else None))
identifier = f'{assembly_repetition.name}-layer_selection'
ceiler = InternalConsistency()
super(_MockBenchmark,
self).__init__(identifier=identifier,
ceiling_func=lambda: ceiler(assembly_repetition),
version='1.0')
def __init__(self,
identifier,
split_coord='word',
unique_split_values=False):
self._logger = logging.getLogger(fullname(self))
self._identifier = identifier
assembly = LazyLoad(self._load_assembly)
self._target_assembly = assembly
regression = linear_regression(xarray_kwargs=dict(
stimulus_coord='word_id',
neuroid_coord='subject_id')) # used for sorting -- keep at word_id
correlation = pearsonr_correlation(xarray_kwargs=dict(
correlation_coord='word_id',
neuroid_coord='subject_id')) # used for sorting -- keep at word_id
self._metric = CrossRegressedCorrelation(
regression=regression,
correlation=correlation,
crossvalidation_kwargs=dict(
splits=5,
kfold=True,
split_coord=split_coord,
stratification_coord='sentence_id',
unique_split_values=unique_split_values))
self._cross_subject = CartesianProduct(dividers=['subject_id'])
self._ceiler = self.ManySubjectExtrapolationCeiling(
subject_column='subject_id')
def __init__(self, **kwargs):
metric = CrossRegressedCorrelation(
regression=linear_regression(xarray_kwargs=dict(stimulus_coord='stimulus_id')),
correlation=pearsonr_correlation(xarray_kwargs=dict(correlation_coord='stimulus_id')),
crossvalidation_kwargs=dict(split_coord='stimulus_id', stratification_coord=None))
metric = Invert(metric)
super(PereiraDecoding, self).__init__(metric=metric, **kwargs)
def DicarloSanghavi2020ITPLS():
return _DicarloSanghavi2020Region(
'IT',
identifier_metric_suffix='pls',
similarity_metric=CrossRegressedCorrelation(
regression=pls_regression(),
correlation=pearsonr_correlation(),
crossvalidation_kwargs=dict(stratification_coord='object_name')),
ceiler=InternalConsistency())
def MovshonFreemanZiemba2013V2PLS():
return _MovshonFreemanZiemba2013Region(
'V2',
identifier_metric_suffix='pls',
similarity_metric=CrossRegressedCorrelation(
regression=pls_regression(),
correlation=pearsonr_correlation(),
crossvalidation_kwargs=dict(stratification_coord='texture_type')),
ceiler=InternalConsistency())
def __init__(self, bold_shift=None):
assembly = load_Fedorenko2016()
self._target_assembly = assembly
self._regression = pls_regression(xarray_kwargs=dict(stimulus_coord='stimulus_id')) # word
self._correlation = pearsonr_correlation(xarray_kwargs=dict(correlation_coord='stimulus_id'))
self._metric = CrossRegressedCorrelation(
regression=self._regression, correlation=self._correlation,
# crossvalidation_kwargs=dict(split_coord='sentence_id', stratification_coord=None))
crossvalidation_kwargs=dict(split_coord='stimulus_id', stratification_coord='sentence_id', train_size=.8))
def __init__(self, *args, **kwargs):
super(Blank2014fROIEncoding, self).__init__(*args, **kwargs)
regression = linear_regression(xarray_kwargs=dict(
stimulus_coord='stimulus_id', neuroid_coord='fROI_area'))
correlation = pearsonr_correlation(xarray_kwargs=dict(
correlation_coord='stimulus_id', neuroid_coord='fROI_area'))
self._metric = CrossRegressedCorrelation(
regression=regression, correlation=correlation,
crossvalidation_kwargs=dict(splits=5, kfold=True, split_coord='stimulus_id', stratification_coord='story'))
def test_small(self):
assembly = NeuroidAssembly((np.arange(30 * 25) + np.random.standard_normal(30 * 25)).reshape((30, 25)),
coords={'image_id': ('presentation', np.arange(30)),
'object_name': ('presentation', ['a', 'b', 'c'] * 10),
'neuroid_id': ('neuroid', np.arange(25)),
'region': ('neuroid', ['some_region'] * 25)},
dims=['presentation', 'neuroid'])
metric = CrossRegressedCorrelation(regression=pls_regression(), correlation=pearsonr_correlation())
score = metric(source=assembly, target=assembly)
assert score.sel(aggregation='center') == approx(1, abs=.00001)
def __init__(self, bold_shift=None):
assembly = load_Fedorenko2016()
self._target_assembly = assembly
# avg code
# packaging file, change the benchmark to include averaging.
self._regression = pls_regression(xarray_kwargs=dict(stimulus_coord='stimulus_id')) # word
self._correlation = pearsonr_correlation(xarray_kwargs=dict(correlation_coord='stimulus_id'))
self._metric = CrossRegressedCorrelation(
regression=self._regression, correlation=self._correlation,
crossvalidation_kwargs=dict(split_coord='stimulus_id', stratification_coord='stimulus_id'))
def _standard_benchmark(identifier, load_assembly, visual_degrees, number_of_trials, stratification_coord, bibtex):
assembly_repetition = LazyLoad(lambda: load_assembly(average_repetitions=False))
assembly = LazyLoad(lambda: load_assembly(average_repetitions=True))
similarity_metric = CrossRegressedCorrelation(
regression=pls_regression(), correlation=pearsonr_correlation(),
crossvalidation_kwargs=dict(stratification_coord=stratification_coord))
ceiler = InternalConsistency()
return NeuralBenchmark(identifier=f"{identifier}-pls", version=1,
assembly=assembly, similarity_metric=similarity_metric,
visual_degrees=visual_degrees, number_of_trials=number_of_trials,
ceiling_func=lambda: ceiler(assembly_repetition),
parent=None,
bibtex=bibtex)
def __init__(self, identifier, bold_shift=4):
self._identifier = identifier
assembly = LazyLoad(lambda: self._load_assembly(bold_shift))
self._target_assembly = assembly
regression = linear_regression(xarray_kwargs=dict(
stimulus_coord='stimulus_id', neuroid_coord='neuroid_id'))
correlation = pearsonr_correlation(xarray_kwargs=dict(
correlation_coord='stimulus_id', neuroid_coord='neuroid_id'))
self._metric = CrossRegressedCorrelation(
regression=regression, correlation=correlation,
crossvalidation_kwargs=dict(splits=5, kfold=True, split_coord='stimulus_id', stratification_coord='story'))
self._ceiler = ExtrapolationCeiling(subject_column='subject_UID', post_process=self.post_process_ceilings)
def __init__(self, *args, **kwargs):
super(Futrell2018SentencesEncoding, self).__init__(*args, **kwargs)
regression = linear_regression(xarray_kwargs=dict(
stimulus_coord='word_id', neuroid_coord='subject_id'))
correlation = pearsonr_correlation(xarray_kwargs=dict(
correlation_coord='word_id', neuroid_coord='subject_id'))
self._metric = CrossRegressedCorrelation(
regression=regression,
correlation=correlation,
crossvalidation_kwargs=dict(splits=5,
kfold=True,
unique_split_values=True,
split_coord='sentence_id',
stratification_coord=None))
def ToliasCadena2017Mask():
loader = AssemblyLoader()
assembly_repetition = loader(average_repetition=False)
assembly = loader(average_repetition=True)
assembly.stimulus_set.name = assembly.stimulus_set_name
similarity_metric = CrossRegressedCorrelation(
regression=mask_regression(),
correlation=pearsonr_correlation(),
crossvalidation_kwargs={'splits': 4, 'stratification_coord': None})
identifier = f'tolias.Cadena2017-mask'
ceiler = InternalConsistency(split_coord='repetition_id')
return NeuralBenchmark(identifier=identifier, version=1,
assembly=assembly, similarity_metric=similarity_metric, visual_degrees=VISUAL_DEGREES,
ceiling_func=lambda: ceiler(assembly_repetition))
def DicarloMajaj2015CateHighVar(*regression_args, **regression_kwargs):
assembly = load_assembly(average_repetitions=True, region='V4')
assembly = build_cate_assembly(assembly)
return RegressionBenchmark(
identifier='dicarlo.Majaj2015.highvar.cate',
assembly=assembly,
similarity_metric=CrossRegressedCorrelation(
regression=XarrayRegression(
MultiOutputClassifier(LinearSVC(
*regression_args, **regression_kwargs))),
correlation=tricky_accuracy(),
crossvalidation_kwargs=dict(
splits=4, stratification_coord='object_name')),
version=3, ceiling_func=None,
paper_link='http://www.jneurosci.org/content/35/39/13402.short',
)
def __init__(self, identifier):
self._logger = logging.getLogger(fullname(self))
self._identifier = identifier
assembly = LazyLoad(self._load_assembly)
self._target_assembly = assembly
regression = linear_regression(xarray_kwargs=dict(
stimulus_coord='word_id', neuroid_coord='subject_id'))
correlation = pearsonr_correlation(xarray_kwargs=dict(
correlation_coord='word_id', neuroid_coord='subject_id'))
self._metric = CrossRegressedCorrelation(
regression=regression,
correlation=correlation,
crossvalidation_kwargs=dict(splits=5,
kfold=True,
split_coord='word_id',
stratification_coord='sentence_id'))
def _standard_benchmark(identifier, load_assembly, stratification_coord):
assembly_repetition = LazyLoad(
lambda: load_assembly(average_repetitions=False))
assembly = LazyLoad(lambda: load_assembly(average_repetitions=True))
similarity_metric = CrossRegressedCorrelation(
regression=pls_regression(),
correlation=pearsonr_correlation(),
crossvalidation_kwargs=dict(stratification_coord=stratification_coord))
ceiler = InternalConsistency()
return NeuralBenchmark(
identifier=f"{identifier}-pls",
version=1,
assembly=assembly,
similarity_metric=similarity_metric,
ceiling_func=lambda: ceiler(assembly_repetition),
parent=None,
paper_link='http://www.jneurosci.org/content/35/39/13402.short')
def ToliasCadena2017CadenaFitCadenaScores(*regression_args, **regression_kwargs):
loader = AssemblyLoaderWithNaN()
assembly = loader(average_repetition=True)
assembly.stimulus_set.name = assembly.stimulus_set_name
similarity_metric = CrossRegressedCorrelation(
regression=cadena_regression(
*regression_args, **regression_kwargs),
correlation=cadena_rep_score(),
crossvalidation_kwargs={
'train_size': .8, 'splits': 2, 'stratification_coord': None})
identifier = f'tolias.Cadena2017-cadena-fit-cadena-scores'
ceiling_func = lambda: Score(
[1, np.nan],
coords={'aggregation': ['center', 'error']},
dims=['aggregation'])
return NeuralBenchmark(identifier=identifier, version=1,
assembly=assembly,
similarity_metric=similarity_metric,
ceiling_func=ceiling_func)
def ToliasCadena2017MaskParams(*regression_args, **regression_kwargs):
loader = AssemblyLoader()
assembly_repetition = loader(average_repetition=False)
assembly = loader(average_repetition=True)
assembly.stimulus_set.name = assembly.stimulus_set_name
similarity_metric = CrossRegressedCorrelation(
regression=mask_regression_with_params(
*regression_args, **regression_kwargs),
correlation=pearsonr_correlation(),
crossvalidation_kwargs={'splits': 4, 'stratification_coord': None})
identifier = f'tolias.Cadena2017-param-mask'
ceiler = InternalConsistency(split_coord='repetition_id')
def ceiling():
assembly_nonan, stimuli = loader.dropna(
assembly_repetition,
assembly_repetition.attrs['stimulus_set'])
return ceiler(assembly_nonan)
return NeuralBenchmark(identifier=identifier, version=1,
assembly=assembly, similarity_metric=similarity_metric,
ceiling_func=ceiling)
def load_Pereira2018_Blank_languageresiduals():
# hijack the corresponding encoding benchmark to regress, but then store residuals instead of correlate
from neural_nlp.benchmarks.neural import PereiraEncoding
benchmark = PereiraEncoding()
assembly, cross = benchmark._target_assembly, benchmark._cross
residuals = []
def store_residuals(nonlanguage_prediction, language_target):
residual = language_target - nonlanguage_prediction
residuals.append(residual)
return Score([0],
coords={'neuroid_id': ('neuroid', [0])},
dims=['neuroid']) # dummy score
pseudo_metric = CrossRegressedCorrelation(regression=linear_regression(
xarray_kwargs=dict(stimulus_coord='stimulus_id')),
correlation=store_residuals,
crossvalidation_kwargs=dict(
splits=5,
kfold=True,
split_coord='stimulus_id',
stratification_coord=None))
# separate language from non-language networks
language_assembly = assembly[{
'neuroid': [
atlas in ['DMN', 'MD', 'language']
for atlas in assembly['atlas'].values
]
}]
nonlanguage_assembly = assembly[{
'neuroid': [
atlas in ['visual', 'auditory']
for atlas in assembly['atlas'].values
]
}]
# run
def apply_cross(source_assembly, target_assembly):
# filter experiment
source_assembly = source_assembly[{
'presentation': [
stimulus_id in target_assembly['stimulus_id'].values
for stimulus_id in source_assembly['stimulus_id'].values
]
}]
assert all(source_assembly['stimulus_id'].values ==
target_assembly['stimulus_id'].values)
# filter subjects that have not done this experiment
source_assembly = source_assembly.dropna('neuroid')
# for the target assembly, it's going to become awkward if we just drop those neuroids.
# instead, we set them to zero which makes for simple zero regression weights.
target_assembly = target_assembly.fillna(0)
# this will regress from joint visual+auditory neural space to one of the language networks
return pseudo_metric(source_assembly, target_assembly)
cross(language_assembly,
apply=lambda cross_assembly: apply_cross(nonlanguage_assembly,
cross_assembly))
# combine residuals
assert len(
residuals
) == 5 * 2 * 3 # 5-fold CV, 2 experiments, 3 language brain networks
# ensure uniqueness
neuroid_ids, stimulus_ids = [], []
for residual in residuals:
neuroid_ids += residual['neuroid_id'].values.tolist()
stimulus_ids += residual['stimulus_id'].values.tolist()
assert len(neuroid_ids) == len(language_assembly['neuroid']) * 5 * 2
assert len(set(neuroid_ids)) == len(
set(language_assembly['neuroid_id'].values))
assert len(stimulus_ids) == len(language_assembly['presentation']) * 3
assert len(set(stimulus_ids)) == len(
set(language_assembly['stimulus_id'].values))
residuals = merge_data_arrays(residuals)
residuals = type(language_assembly)(residuals)
residuals.attrs['stimulus_set'] = assembly.stimulus_set
return residuals
