diff --git a/brainscore_language/models/oasm/__init__.py b/brainscore_language/models/oasm/__init__.py new file mode 100644 index 00000000..9cf4d443 --- /dev/null +++ b/brainscore_language/models/oasm/__init__.py @@ -0,0 +1,53 @@ +from brainscore_language import model_registry +from .model import OASMSubject + +# 49 OASM variants: sigma=0 (pure identity) + sigma=0.1..4.8 (paper's search grid). +model_registry['oasm-sigma0'] = lambda: OASMSubject(identifier='oasm-sigma0', sigma=0.0) +model_registry['oasm-sigma0.1'] = lambda: OASMSubject(identifier='oasm-sigma0.1', sigma=0.1) +model_registry['oasm-sigma0.2'] = lambda: OASMSubject(identifier='oasm-sigma0.2', sigma=0.2) +model_registry['oasm-sigma0.3'] = lambda: OASMSubject(identifier='oasm-sigma0.3', sigma=0.3) +model_registry['oasm-sigma0.4'] = lambda: OASMSubject(identifier='oasm-sigma0.4', sigma=0.4) +model_registry['oasm-sigma0.5'] = lambda: OASMSubject(identifier='oasm-sigma0.5', sigma=0.5) +model_registry['oasm-sigma0.6'] = lambda: OASMSubject(identifier='oasm-sigma0.6', sigma=0.6) +model_registry['oasm-sigma0.7'] = lambda: OASMSubject(identifier='oasm-sigma0.7', sigma=0.7) +model_registry['oasm-sigma0.8'] = lambda: OASMSubject(identifier='oasm-sigma0.8', sigma=0.8) +model_registry['oasm-sigma0.9'] = lambda: OASMSubject(identifier='oasm-sigma0.9', sigma=0.9) +model_registry['oasm-sigma1.0'] = lambda: OASMSubject(identifier='oasm-sigma1.0', sigma=1.0) +model_registry['oasm-sigma1.1'] = lambda: OASMSubject(identifier='oasm-sigma1.1', sigma=1.1) +model_registry['oasm-sigma1.2'] = lambda: OASMSubject(identifier='oasm-sigma1.2', sigma=1.2) +model_registry['oasm-sigma1.3'] = lambda: OASMSubject(identifier='oasm-sigma1.3', sigma=1.3) +model_registry['oasm-sigma1.4'] = lambda: OASMSubject(identifier='oasm-sigma1.4', sigma=1.4) +model_registry['oasm-sigma1.5'] = lambda: OASMSubject(identifier='oasm-sigma1.5', sigma=1.5) +model_registry['oasm-sigma1.6'] = lambda: OASMSubject(identifier='oasm-sigma1.6', sigma=1.6) +model_registry['oasm-sigma1.7'] = lambda: OASMSubject(identifier='oasm-sigma1.7', sigma=1.7) +model_registry['oasm-sigma1.8'] = lambda: OASMSubject(identifier='oasm-sigma1.8', sigma=1.8) +model_registry['oasm-sigma1.9'] = lambda: OASMSubject(identifier='oasm-sigma1.9', sigma=1.9) +model_registry['oasm-sigma2.0'] = lambda: OASMSubject(identifier='oasm-sigma2.0', sigma=2.0) +model_registry['oasm-sigma2.1'] = lambda: OASMSubject(identifier='oasm-sigma2.1', sigma=2.1) +model_registry['oasm-sigma2.2'] = lambda: OASMSubject(identifier='oasm-sigma2.2', sigma=2.2) +model_registry['oasm-sigma2.3'] = lambda: OASMSubject(identifier='oasm-sigma2.3', sigma=2.3) +model_registry['oasm-sigma2.4'] = lambda: OASMSubject(identifier='oasm-sigma2.4', sigma=2.4) +model_registry['oasm-sigma2.5'] = lambda: OASMSubject(identifier='oasm-sigma2.5', sigma=2.5) +model_registry['oasm-sigma2.6'] = lambda: OASMSubject(identifier='oasm-sigma2.6', sigma=2.6) +model_registry['oasm-sigma2.7'] = lambda: OASMSubject(identifier='oasm-sigma2.7', sigma=2.7) +model_registry['oasm-sigma2.8'] = lambda: OASMSubject(identifier='oasm-sigma2.8', sigma=2.8) +model_registry['oasm-sigma2.9'] = lambda: OASMSubject(identifier='oasm-sigma2.9', sigma=2.9) +model_registry['oasm-sigma3.0'] = lambda: OASMSubject(identifier='oasm-sigma3.0', sigma=3.0) +model_registry['oasm-sigma3.1'] = lambda: OASMSubject(identifier='oasm-sigma3.1', sigma=3.1) +model_registry['oasm-sigma3.2'] = lambda: OASMSubject(identifier='oasm-sigma3.2', sigma=3.2) +model_registry['oasm-sigma3.3'] = lambda: OASMSubject(identifier='oasm-sigma3.3', sigma=3.3) +model_registry['oasm-sigma3.4'] = lambda: OASMSubject(identifier='oasm-sigma3.4', sigma=3.4) +model_registry['oasm-sigma3.5'] = lambda: OASMSubject(identifier='oasm-sigma3.5', sigma=3.5) +model_registry['oasm-sigma3.6'] = lambda: OASMSubject(identifier='oasm-sigma3.6', sigma=3.6) +model_registry['oasm-sigma3.7'] = lambda: OASMSubject(identifier='oasm-sigma3.7', sigma=3.7) +model_registry['oasm-sigma3.8'] = lambda: OASMSubject(identifier='oasm-sigma3.8', sigma=3.8) +model_registry['oasm-sigma3.9'] = lambda: OASMSubject(identifier='oasm-sigma3.9', sigma=3.9) +model_registry['oasm-sigma4.0'] = lambda: OASMSubject(identifier='oasm-sigma4.0', sigma=4.0) +model_registry['oasm-sigma4.1'] = lambda: OASMSubject(identifier='oasm-sigma4.1', sigma=4.1) +model_registry['oasm-sigma4.2'] = lambda: OASMSubject(identifier='oasm-sigma4.2', sigma=4.2) +model_registry['oasm-sigma4.3'] = lambda: OASMSubject(identifier='oasm-sigma4.3', sigma=4.3) +model_registry['oasm-sigma4.4'] = lambda: OASMSubject(identifier='oasm-sigma4.4', sigma=4.4) +model_registry['oasm-sigma4.5'] = lambda: OASMSubject(identifier='oasm-sigma4.5', sigma=4.5) +model_registry['oasm-sigma4.6'] = lambda: OASMSubject(identifier='oasm-sigma4.6', sigma=4.6) +model_registry['oasm-sigma4.7'] = lambda: OASMSubject(identifier='oasm-sigma4.7', sigma=4.7) +model_registry['oasm-sigma4.8'] = lambda: OASMSubject(identifier='oasm-sigma4.8', sigma=4.8) diff --git a/brainscore_language/models/oasm/metadata.yml b/brainscore_language/models/oasm/metadata.yml new file mode 100644 index 00000000..68208885 --- /dev/null +++ b/brainscore_language/models/oasm/metadata.yml @@ -0,0 +1,15 @@ +models: + oasm: + architecture: DCNN + model_family: oasm + total_parameter_count: 1234567 + trainable_parameter_count: 1234567 + total_layers: 55 + trainable_layers: 40 + model_size_mb: 1202 + training_dataset: null + task_specialization: null + brainscore_link: https://github.com/brain-score/language/tree/master/brainscore_language/models/oasm + huggingface_link: null + extra_notes: Temporary hardcoded metadata - will be replaced with actual generation + runnable: true diff --git a/brainscore_language/models/oasm/model.py b/brainscore_language/models/oasm/model.py new file mode 100644 index 00000000..470a4024 --- /dev/null +++ b/brainscore_language/models/oasm/model.py @@ -0,0 +1,126 @@ +""" +OASM: Orthogonal Autocorrelated Sequences Model. + +A confound baseline model following Hadidi et al. (2025) "Illusions of Alignment Between +Large Language Models and Brains Emerge From Fragile Methods and Overlooked Confounds". + +The model constructs an N x N identity matrix (N = total stimuli) and applies Gaussian +smoothing within each block (passage/sentence/story) along axis=1. This captures temporal +autocorrelation -- the fact that brain responses to nearby stimuli are more similar -- +without encoding any linguistic content whatsoever. + +Reference: + Hadidi et al. (2025). bioRxiv. https://doi.org/10.1101/2025.03.09.642245 + Code: https://github.com/ebrahimfeghhi/beyond-brainscore +""" + +import copy +import numpy as np +from scipy.ndimage import gaussian_filter1d +from typing import Union, List, Dict + +from brainscore_core.supported_data_standards.brainio.assemblies import NeuroidAssembly, merge_data_arrays +from brainscore_language.artificial_subject import ArtificialSubject + + +class OASMSubject(ArtificialSubject): + """ + Orthogonal Autocorrelated Sequences Model (OASM) for brain-score evaluation. + + For each block of K stimuli (passage, sentence, or story), constructs a K x K identity + matrix and applies ``scipy.ndimage.gaussian_filter1d`` along axis=1 with the given sigma. + Each block is placed at a unique offset in a fixed-size feature space, maintaining + between-block orthogonality while introducing within-block temporal autocorrelation. + + This is mathematically equivalent to the paper's full N x N construction, adapted for + brain-score's per-block ``digest_text`` calling convention. + + :param identifier: Unique model identifier (e.g., 'oasm-sigma1.0'). + :param sigma: Gaussian smoothing width. Must be >= 0. sigma=0 gives pure identity. + :param max_features: Fixed dimensionality of the feature space. Must be >= total + number of stimuli across all blocks in a benchmark run. Default 2000. + """ + + def __init__(self, identifier: str, sigma: float, max_features: int = 2000): + self._identifier = identifier + self._sigma = sigma + self._max_features = max_features + self._neural_recordings: list = [] + self._offset: int = 0 + + def identifier(self) -> str: + return self._identifier + + def start_behavioral_task(self, task: ArtificialSubject.Task): + raise NotImplementedError("OASM encodes no linguistic content and cannot perform behavioral tasks") + + def start_neural_recording(self, recording_target: ArtificialSubject.RecordingTarget, + recording_type: ArtificialSubject.RecordingType): + self._neural_recordings.append((recording_target, recording_type)) + self._offset = 0 + + def digest_text(self, text: Union[str, List[str]]) -> Dict[str, NeuroidAssembly]: + assert len(self._neural_recordings) > 0, "Must call start_neural_recording before digest_text" + + if isinstance(text, str): + text = [text] + if isinstance(text, np.ndarray): + text = list(text) + + block_size = len(text) + + if self._offset + block_size > self._max_features: + raise ValueError( + f"Cumulative stimulus count ({self._offset + block_size}) exceeds " + f"max_features ({self._max_features}). Increase max_features." + ) + + # Build block: K x K identity, smoothed along axis=1 + block_features = np.eye(block_size, dtype=np.float64) + if self._sigma > 0 and block_size > 1: + block_features = gaussian_filter1d(block_features, sigma=self._sigma, axis=1) + + # Embed into D-dimensional space at the current offset + features = np.zeros((block_size, self._max_features), dtype=np.float64) + features[:, self._offset:self._offset + block_size] = block_features + self._offset += block_size + + # Package each stimulus as a NeuroidAssembly + output = {'behavior': [], 'neural': []} + for part_number, stimulus in enumerate(text): + stimuli_coords = { + 'stimulus': ('presentation', [stimulus]), + 'part_number': ('presentation', [part_number]), + } + neural_assembly = self._package_representations(features[part_number], stimuli_coords=stimuli_coords) + output['neural'].append(neural_assembly) + + output['neural'] = merge_data_arrays(output['neural']).sortby('part_number') + return output + + def _package_representations(self, representation_values: np.ndarray, + stimuli_coords: dict) -> NeuroidAssembly: + """Package a feature vector as a NeuroidAssembly matching the brain-score interface.""" + layer_name = f'oasm_sigma{self._sigma}' + num_units = len(representation_values) + + neuroid_coords = { + 'layer': ('neuroid', [layer_name] * num_units), + 'neuron_number_in_layer': ('neuroid', np.arange(num_units)), + 'neuroid_id': ('neuroid', [f'{layer_name}--{i}' for i in range(num_units)]), + } + + layer_representations = NeuroidAssembly( + [representation_values], + coords={**stimuli_coords, **neuroid_coords}, + dims=['presentation', 'neuroid']) + + representations = [] + for recording_target, recording_type in self._neural_recordings: + current_representations = copy.deepcopy(layer_representations) + current_representations['recording_target'] = 'neuroid', [recording_target] * num_units + current_representations['recording_type'] = 'neuroid', [recording_type] * num_units + current_representations = type(current_representations)(current_representations) + representations.append(current_representations) + representations = merge_data_arrays(representations) + return representations diff --git a/brainscore_language/models/oasm/test.py b/brainscore_language/models/oasm/test.py new file mode 100644 index 00000000..91a6fb82 --- /dev/null +++ b/brainscore_language/models/oasm/test.py @@ -0,0 +1,332 @@ +""" +Tests for the OASM (Orthogonal Autocorrelated Sequences Model) implementation. + +Tests cover: +- Feature construction correctness +- Between-block orthogonality +- Stateful offset mechanism +- NeuroidAssembly structure (brain-score interface compliance) +- Input handling edge cases +- Equivalence to the paper's full-matrix construction +- Model registration +- Paper's key finding: shuffled CV inflates scores, contiguous CV eliminates them +""" + +import numpy as np +import pytest +from scipy.ndimage import gaussian_filter1d +from scipy.stats import pearsonr +from sklearn.linear_model import RidgeCV +from sklearn.model_selection import ShuffleSplit + +from brainscore_language import load_model +from brainscore_language.artificial_subject import ArtificialSubject +from brainscore_language.models.oasm.model import OASMSubject + + +def _make_model(sigma: float = 1.0, max_features: int = 20) -> OASMSubject: + """Helper to create an OASMSubject with neural recording started.""" + model = OASMSubject(identifier='test', sigma=sigma, max_features=max_features) + model.start_neural_recording( + recording_target=ArtificialSubject.RecordingTarget.language_system, + recording_type=ArtificialSubject.RecordingType.fMRI, + ) + return model + + +class TestFeatureConstruction: + """Test the core identity + Gaussian smoothing feature construction.""" + + def test_sigma_zero_gives_identity(self): + """With sigma=0, each stimulus should get a one-hot vector at its offset position.""" + model = _make_model(sigma=0.0, max_features=10) + result = model.digest_text(['a', 'b', 'c'])['neural'] + + for i in range(3): + assert result.values[i, i] == 1.0 + non_peak = np.delete(result.values[i], i) + np.testing.assert_array_equal(non_peak, 0.0) + + def test_smoothing_matches_scipy_exactly(self): + """Feature values must exactly match scipy.ndimage.gaussian_filter1d on identity.""" + sigma = 2.0 + block_size = 5 + model = _make_model(sigma=sigma, max_features=10) + result = model.digest_text([f'w{i}' for i in range(block_size)])['neural'] + + expected = gaussian_filter1d(np.eye(block_size), sigma=sigma, axis=1) + np.testing.assert_allclose(result.values[:, :block_size], expected, atol=1e-10) + + +class TestBetweenBlockOrthogonality: + """Test that features from different digest_text calls occupy non-overlapping dimensions.""" + + def test_two_blocks_orthogonal(self): + """Dot product between any stimulus from block 1 and any from block 2 should be 0.""" + model = _make_model(sigma=1.0, max_features=20) + r1 = model.digest_text(['a', 'b', 'c'])['neural'] + r2 = model.digest_text(['d', 'e'])['neural'] + + for i in range(3): + for j in range(2): + dot = np.dot(r1.values[i], r2.values[j]) + assert dot == pytest.approx(0.0, abs=1e-10), ( + f"Block1[{i}] . Block2[{j}] = {dot}, expected 0" + ) + + +class TestStatefulOffset: + """Test the cumulative offset mechanism that places blocks in unique dimensions.""" + + def test_offset_advances_by_block_size(self): + """With sigma=0, the one-hot peak position reveals the offset.""" + model = _make_model(sigma=0.0, max_features=20) + + r1 = model.digest_text(['a', 'b', 'c'])['neural'] + assert r1.values[0, 0] == 1.0 + assert r1.values[1, 1] == 1.0 + assert r1.values[2, 2] == 1.0 + + r2 = model.digest_text(['d', 'e'])['neural'] + assert r2.values[0, 3] == 1.0 + assert r2.values[1, 4] == 1.0 + + def test_start_neural_recording_resets_offset(self): + """A new recording session should reset the offset to 0.""" + model = OASMSubject(identifier='test', sigma=0.0, max_features=20) + model.start_neural_recording( + recording_target=ArtificialSubject.RecordingTarget.language_system, + recording_type=ArtificialSubject.RecordingType.fMRI, + ) + + model.digest_text(['a', 'b', 'c']) + assert model._offset == 3 + + model.start_neural_recording( + recording_target=ArtificialSubject.RecordingTarget.language_system, + recording_type=ArtificialSubject.RecordingType.fMRI, + ) + assert model._offset == 0 + + result = model.digest_text(['x', 'y'])['neural'] + assert result.values[0, 0] == 1.0 + + def test_exceeds_max_features_raises(self): + """Should raise ValueError when cumulative stimuli exceed max_features.""" + model = _make_model(sigma=0.0, max_features=5) + model.digest_text(['a', 'b', 'c']) + + with pytest.raises(ValueError, match="max_features"): + model.digest_text(['d', 'e', 'f']) + + +class TestNeuroidAssemblyStructure: + """Test brain-score interface compliance: coordinates, dimensions, types.""" + + def test_required_neuroid_coordinates(self): + model = _make_model(sigma=1.0, max_features=10) + result = model.digest_text(['hello', 'world'])['neural'] + + for coord in ['layer', 'neuron_number_in_layer', 'neuroid_id', + 'recording_target', 'recording_type']: + result[coord] # should not raise + + def test_required_presentation_coordinates(self): + model = _make_model(sigma=1.0, max_features=10) + result = model.digest_text(['hello', 'world'])['neural'] + + np.testing.assert_array_equal(result['stimulus'].values, ['hello', 'world']) + np.testing.assert_array_equal(result['part_number'].values, [0, 1]) + + def test_output_shape(self): + max_features = 15 + model = _make_model(sigma=0.5, max_features=max_features) + result = model.digest_text(['a', 'b', 'c'])['neural'] + + assert result.dims == ('presentation', 'neuroid') + assert result.shape == (3, max_features) + + def test_consistent_neuroid_dims_across_blocks(self): + """All blocks must have the same neuroid dimension for concatenation (as benchmarks do).""" + model = _make_model(sigma=1.0, max_features=20) + + r1 = model.digest_text(['a', 'b', 'c'])['neural'] + r2 = model.digest_text(['d', 'e'])['neural'] + r3 = model.digest_text(['f'])['neural'] + + assert r1.sizes['neuroid'] == r2.sizes['neuroid'] == r3.sizes['neuroid'] == 20 + assert r1.sizes['presentation'] + r2.sizes['presentation'] + r3.sizes['presentation'] == 6 + + +class TestInputHandling: + """Test edge cases in input normalization.""" + + def test_numpy_array_input(self): + """Benchmarks pass numpy arrays, not Python lists.""" + model = _make_model(sigma=0.5, max_features=10) + text = np.array(['hello world', 'foo bar']) + result = model.digest_text(text)['neural'] + assert result.shape == (2, 10) + + def test_single_string_input(self): + model = _make_model(sigma=0.5, max_features=10) + result = model.digest_text('hello world')['neural'] + assert result.shape == (1, 10) + + def test_no_neural_recording_raises(self): + model = OASMSubject(identifier='test', sigma=0.5, max_features=10) + with pytest.raises(AssertionError, match="start_neural_recording"): + model.digest_text(['hello']) + + def test_behavioral_task_raises(self): + model = OASMSubject(identifier='test', sigma=0.5, max_features=10) + with pytest.raises(NotImplementedError): + model.start_behavioral_task(ArtificialSubject.Task.next_word) + + +class TestEquivalenceToPaper: + """Verify mathematical equivalence to the paper's full-matrix OASM construction.""" + + def test_incremental_matches_full_matrix(self): + """ + The stateful per-block approach must produce the same result as building + the full N x N matrix and smoothing within blocks. + + Validates equivalence to the paper's construction: + OASM_acts = np.eye(N) + for block in blocks: + OASM_acts[block, block] = gaussian_filter1d(submatrix, sigma, axis=1) + """ + sigma = 1.5 + blocks = [['a', 'b', 'c'], ['d', 'e'], ['f', 'g', 'h', 'i']] + total_n = sum(len(b) for b in blocks) + + full_matrix = np.eye(total_n) + offset = 0 + for block in blocks: + k = len(block) + if k > 1: + submatrix = full_matrix[offset:offset + k, offset:offset + k] + full_matrix[offset:offset + k, offset:offset + k] = gaussian_filter1d( + submatrix, sigma=sigma, axis=1 + ) + offset += k + + model = _make_model(sigma=sigma, max_features=total_n) + incremental_rows = [] + for block in blocks: + result = model.digest_text(block)['neural'] + incremental_rows.append(result.values) + + incremental_matrix = np.vstack(incremental_rows) + + np.testing.assert_allclose( + incremental_matrix, full_matrix, atol=1e-10, + err_msg="Incremental OASM must match paper's full-matrix construction" + ) + + def test_no_linguistic_content(self): + """ + OASM features should be identical regardless of actual text content, + given the same block structure. + """ + sigma = 1.0 + max_features = 10 + + model1 = _make_model(sigma=sigma, max_features=max_features) + r1 = model1.digest_text(['The cat sat on the mat', 'Dogs are great', 'Hello world'])['neural'] + + model2 = _make_model(sigma=sigma, max_features=max_features) + r2 = model2.digest_text(['xyz abc 123', 'qqq', 'asdfghjkl'])['neural'] + + np.testing.assert_array_equal( + r1.values, r2.values, + err_msg="OASM encodes zero linguistic content: features must depend only on block structure" + ) + + +class TestRegistration: + """Test model registry integration.""" + + def test_boundary_sigmas_load(self): + """All registrations are explicit literals, so load_model's static scan finds them.""" + for key in ['oasm-sigma0', 'oasm-sigma0.1', 'oasm-sigma4.8']: + model = load_model(key) + ident = model.identifier if isinstance(model.identifier, str) else model.identifier() + assert ident == key + + def test_49_variants_registered(self): + """48 sigma values (0.1-4.8) + sigma=0 = 49 total.""" + from brainscore_language import model_registry + oasm_keys = [k for k in model_registry if k.startswith('oasm-sigma')] + assert len(oasm_keys) == 49 + + +class TestPaperReproduction: + """ + Reproduce the paper's key finding on synthetic data: OASM scores high under + shuffled CV (temporal autocorrelation leakage) but drops to ~zero under + contiguous CV (entire blocks held out). + + Uses synthetic brain data with temporal autocorrelation -- no real data loading needed. + Reference: Hadidi et al. (2025), Figure 1. + """ + + def test_shuffled_high_contiguous_zero(self): + n_blocks = 6 + block_size = 4 + n_stimuli = n_blocks * block_size + n_voxels = 50 + sigma = 1.0 + + # Build OASM features: per-block identity + Gaussian smoothing + model = _make_model(sigma=sigma, max_features=n_stimuli) + all_features = [] + for b in range(n_blocks): + texts = [f'block{b}_stim{i}' for i in range(block_size)] + result = model.digest_text(texts)['neural'] + all_features.append(result.values) + X = np.vstack(all_features) + + # Synthetic brain data: random voxel responses with temporal autocorrelation + # (adjacent stimuli within a block have correlated responses) + rng = np.random.default_rng(42) + Y = np.zeros((n_stimuli, n_voxels)) + for b in range(n_blocks): + raw = rng.standard_normal((block_size, n_voxels)) + Y[b * block_size:(b + 1) * block_size] = gaussian_filter1d(raw, sigma=1.5, axis=0) + + # Shuffled CV: random train/test split (allows within-block leakage) + ss = ShuffleSplit(n_splits=10, train_size=0.9, random_state=1) + shuffled_rs = [] + for train_idx, test_idx in ss.split(X): + reg = RidgeCV(alphas=np.logspace(-3, 3, 7)) + reg.fit(X[train_idx], Y[train_idx]) + Y_pred = reg.predict(X[test_idx]) + rs = [pearsonr(Y[test_idx, j], Y_pred[:, j])[0] for j in range(n_voxels)] + shuffled_rs.append(np.nanmedian(rs)) + shuffled_score = np.mean(shuffled_rs) + + # Contiguous CV: hold out entire blocks (no within-block leakage) + contiguous_rs = [] + for held_out in range(n_blocks): + test_idx = list(range(held_out * block_size, (held_out + 1) * block_size)) + train_idx = [i for i in range(n_stimuli) if i not in test_idx] + reg = RidgeCV(alphas=np.logspace(-3, 3, 7)) + reg.fit(X[train_idx], Y[train_idx]) + Y_pred = reg.predict(X[test_idx]) + rs = [] + for j in range(n_voxels): + if np.std(Y[test_idx, j]) < 1e-10 or np.std(Y_pred[:, j]) < 1e-10: + rs.append(0.0) + else: + rs.append(pearsonr(Y[test_idx, j], Y_pred[:, j])[0]) + contiguous_rs.append(np.nanmedian(rs)) + contiguous_score = np.mean(contiguous_rs) + + assert shuffled_score > 0.1, ( + f"Shuffled CV should exploit temporal autocorrelation leakage: got r={shuffled_score:.4f}" + ) + assert abs(contiguous_score) < 0.02, ( + f"Contiguous CV should eliminate leakage: got r={contiguous_score:.4f}" + ) diff --git a/brainscore_language/models/oasm/validation/figure1_reproduction.png b/brainscore_language/models/oasm/validation/figure1_reproduction.png new file mode 100644 index 00000000..be6a823c Binary files /dev/null and b/brainscore_language/models/oasm/validation/figure1_reproduction.png differ diff --git a/brainscore_language/models/oasm/validation/oasm_reproduction.ipynb b/brainscore_language/models/oasm/validation/oasm_reproduction.ipynb new file mode 100644 index 00000000..5dbcbd26 --- /dev/null +++ b/brainscore_language/models/oasm/validation/oasm_reproduction.ipynb @@ -0,0 +1,2013 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "cell-0", + "metadata": {}, + "source": [ + "# Reproducing OASM Results: Hadidi et al. (2025)\n", + "\n", + "**Paper:** \"Illusions of Alignment Between Large Language Models and Brains Emerge From Fragile Methods and Overlooked Confounds\" \n", + "**Reference:** [bioRxiv 2025.03.09.642245v1](https://www.biorxiv.org/content/10.1101/2025.03.09.642245v1) \n", + "**Code:** [github.com/ebrahimfeghhi/beyond-brainscore](https://github.com/ebrahimfeghhi/beyond-brainscore)\n", + "\n", + "---\n", + "\n", + "OASM (Orthogonal Autocorrelated Sequences Model) encodes **zero linguistic content** -- each stimulus\n", + "gets its own orthogonal dimension, with only temporal smoothing (Gaussian filter) within passage blocks.\n", + "\n", + "The paper's key claim: under **shuffled** cross-validation splits (brain-score's default), OASM achieves\n", + "near-ceiling neural predictivity. Under **contiguous** (passage-level) splits, it drops to near zero.\n", + "This exposes temporal autocorrelation leakage in shuffled CV.\n", + "\n", + "We reproduce this by sweeping OASM sigma values on **Pereira2018.384sentences** under both split types." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "cell-1", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "brainscore_language loaded from: /Users/kartik/Brain-Score 2026/language\n" + ] + } + ], + "source": [ + "import sys\n", + "import os\n", + "import numpy as np\n", + "import xarray as xr\n", + "import matplotlib.pyplot as plt\n", + "from scipy.stats import pearsonr\n", + "from sklearn.linear_model import RidgeCV\n", + "from sklearn.model_selection import GroupKFold, ShuffleSplit\n", + "from tqdm.auto import tqdm\n", + "\n", + "# Ensure brainscore_language is importable from notebook directory\n", + "_notebook_dir = os.path.dirname(os.path.abspath(\"__file__\"))\n", + "_lang_root = os.path.abspath(os.path.join(_notebook_dir, '..', '..', '..', '..'))\n", + "if _lang_root not in sys.path:\n", + " sys.path.insert(0, _lang_root)\n", + "\n", + "from brainscore_language import load_dataset\n", + "from brainscore_language.artificial_subject import ArtificialSubject\n", + "from brainscore_language.models.oasm.model import OASMSubject\n", + "\n", + "print(f\"brainscore_language loaded from: {_lang_root}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-2", + "metadata": {}, + "source": [ + "## Configuration\n", + "\n", + "Set `QUICK_MODE = True` for a fast run (~15 min) with 10 sigma values. \n", + "Set `QUICK_MODE = False` for the full 48-value sweep (~1.5 hr) matching the paper." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "cell-3", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Mode: FULL\n", + "Sigma values (49): [0.0, 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1.0, 1.1, 1.2, 1.3, 1.4, 1.5, 1.6, 1.7, 1.8, 1.9, 2.0, 2.1, 2.2, 2.3, 2.4, 2.5, 2.6, 2.7, 2.8, 2.9, 3.0, 3.1, 3.2, 3.3, 3.4, 3.5, 3.6, 3.7, 3.8, 3.9, 4.0, 4.1, 4.2, 4.3, 4.4, 4.5, 4.6, 4.7, 4.8]\n" + ] + } + ], + "source": [ + "QUICK_MODE = False\n", + "EXPERIMENT = '384sentences'\n", + "MAX_FEATURES = 2000\n", + "\n", + "if QUICK_MODE:\n", + " SIGMA_VALUES = [0.0, 0.5, 1.0, 1.5, 2.0, 2.5, 3.0, 3.5, 4.0, 4.5]\n", + "else:\n", + " # Full sweep: 48 values from 0.1 to 4.8 (matching paper) + sigma=0 baseline\n", + " SIGMA_VALUES = [0.0] + [round(s * 0.1, 1) for s in range(1, 49)]\n", + "\n", + "# Pereira2018.384sentences ceiling (raw Pearson r, from brain-score)\n", + "CEILING_RAW = 0.36343748\n", + "\n", + "print(f\"Mode: {'QUICK' if QUICK_MODE else 'FULL'}\")\n", + "print(f\"Sigma values ({len(SIGMA_VALUES)}): {SIGMA_VALUES}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-4", + "metadata": {}, + "source": [ + "## Load Pereira2018 data" + ] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "cell-5", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Experiment: 384sentences\n", + "Stimuli: 384\n", + "Neuroids: 12155\n", + "Passages: 96\n", + "Stimuli per passage: 4.0\n" + ] + } + ], + "source": [ + "# Load Pireira2018 384 experiment and drop voxels with NaN values (not all subjects completed both experiments)\n", + "data = load_dataset('Pereira2018.language')\n", + "data = data.sel(experiment=EXPERIMENT)\n", + "data = data.dropna('neuroid')\n", + "\n", + "passages = sorted(set(data['passage_label'].values))\n", + "n_stimuli = len(data['stimulus_id'])\n", + "n_neuroids = len(data['neuroid'])\n", + "n_passages = len(passages)\n", + "\n", + "print(f\"Experiment: {EXPERIMENT}\")\n", + "print(f\"Stimuli: {n_stimuli}\")\n", + "print(f\"Neuroids: {n_neuroids}\")\n", + "print(f\"Passages: {n_passages}\")\n", + "print(f\"Stimuli per passage: {n_stimuli / n_passages:.1f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-6", + "metadata": {}, + "source": [ + "## Evaluation functions\n", + "\n", + "Both evaluation modes use **ridge regression** (`RidgeCV`, alphas 10^-3 to 10^3), matching the paper.\n", + "The only difference is the **split strategy**:\n", + "\n", + "1. **Shuffled** (brain-score default): `ShuffleSplit` on individual stimuli. Sentences from the same passage can end up in both train and test, allowing temporal autocorrelation leakage.\n", + "2. **Contiguous** (paper's recommendation): `GroupKFold` on `story` (24 stories). Entire stories are held out together, preventing temporal autocorrelation leakage.\n", + "\n", + "By keeping the regression method constant (ridge), we isolate the effect of the split strategy." + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "cell-7", + "metadata": {}, + "outputs": [], + "source": [ + "import warnings\n", + "\n", + "RIDGE_ALPHAS = np.logspace(-3, 3, 7)\n", + "\n", + "\n", + "def get_model_predictions(model, data: xr.DataArray) -> xr.DataArray:\n", + " \"\"\"Get model predictions for all passages, matching benchmark calling convention.\"\"\"\n", + " stimuli = data['stimulus']\n", + " passages = data['passage_label'].values\n", + " predictions = []\n", + " for passage in sorted(set(passages)):\n", + " passage_indexer = [stimulus_passage == passage for stimulus_passage in passages]\n", + " passage_stimuli = stimuli[passage_indexer]\n", + " passage_predictions = model.digest_text(passage_stimuli.values)['neural']\n", + " passage_predictions['stimulus_id'] = 'presentation', passage_stimuli['stimulus_id'].values\n", + " passage_predictions['passage_index'] = 'presentation', data['passage_index'].values[passage_indexer]\n", + " passage_predictions['story'] = 'presentation', data['story'].values[passage_indexer]\n", + " predictions.append(passage_predictions)\n", + " return xr.concat(predictions, dim='presentation')\n", + "\n", + "\n", + "def _ridge_cv_score(X, Y, split_iterator):\n", + " \"\"\"Shared ridge regression + Pearson r evaluation across CV splits.\"\"\"\n", + " split_medians = []\n", + " for train_idx, test_idx in split_iterator:\n", + " reg = RidgeCV(alphas=RIDGE_ALPHAS)\n", + " reg.fit(X[train_idx], Y[train_idx])\n", + " Y_pred = reg.predict(X[test_idx])\n", + "\n", + " rs = []\n", + " for j in range(Y.shape[1]):\n", + " y_true = Y[test_idx, j]\n", + " y_pred = Y_pred[:, j]\n", + " if np.std(y_true) < 1e-10 or np.std(y_pred) < 1e-10:\n", + " rs.append(0.0)\n", + " continue\n", + " r, _ = pearsonr(y_true, y_pred)\n", + " rs.append(r if not np.isnan(r) else 0.0)\n", + " split_medians.append(np.nanmedian(rs))\n", + " return float(np.mean(split_medians)) if split_medians else 0.0\n", + "\n", + "\n", + "def _align_by_stimulus_id(predictions, data):\n", + " \"\"\"Sort predictions and data by stimulus_id for alignment.\"\"\"\n", + " src_order = np.argsort(predictions['stimulus_id'].values)\n", + " tgt_order = np.argsort(data['stimulus_id'].values)\n", + " X = predictions.values[src_order]\n", + " Y = data.values[tgt_order]\n", + " return X, Y, tgt_order\n", + "\n", + "\n", + "def evaluate_shuffled(predictions: xr.DataArray, data: xr.DataArray,\n", + " n_splits: int = 10, train_size: float = 0.9) -> float:\n", + " \"\"\"Shuffled CV with ridge regression (matching the paper).\n", + "\n", + " Uses ShuffleSplit on individual stimuli (brain-score default split strategy)\n", + " with RidgeCV regression (matching the paper's methodology).\n", + " Returns median-over-neuroids, mean-over-splits Pearson r.\n", + " \"\"\"\n", + " X, Y, _ = _align_by_stimulus_id(predictions, data)\n", + " ss = ShuffleSplit(n_splits=n_splits, train_size=train_size, random_state=1)\n", + " return _ridge_cv_score(X, Y, ss.split(X))\n", + "\n", + "\n", + "def evaluate_contiguous(predictions: xr.DataArray, data: xr.DataArray,\n", + " n_splits: int = 10) -> float:\n", + " \"\"\"Story-level GroupKFold CV with ridge regression (matching the paper).\n", + "\n", + " Groups by `story` (24 unique stories in Pereira2018). Entire stories are\n", + " held out together, preventing temporal autocorrelation leakage.\n", + " Returns median-over-neuroids, mean-over-splits Pearson r.\n", + " \"\"\"\n", + " X, Y, tgt_order = _align_by_stimulus_id(predictions, data)\n", + "\n", + " story_labels = data['story'].values[tgt_order]\n", + " unique_stories = np.unique(story_labels)\n", + " story_to_int = {s: i for i, s in enumerate(unique_stories)}\n", + " groups = np.array([story_to_int[s] for s in story_labels])\n", + "\n", + " actual_splits = min(n_splits, len(unique_stories))\n", + " gkf = GroupKFold(n_splits=actual_splits)\n", + " return _ridge_cv_score(X, Y, gkf.split(X, groups=groups))\n", + "\n", + "\n", + "def evaluate_per_subject(predictions: xr.DataArray, data: xr.DataArray):\n", + " \"\"\"Evaluate under both split types for each fMRI subject independently.\n", + "\n", + " Returns dict with 'subjects', 'shuffled', 'contiguous' arrays.\n", + " \"\"\"\n", + " subjects = sorted(set(data['subject'].values))\n", + " shuffled_scores = []\n", + " contiguous_scores = []\n", + " for subj in tqdm(subjects, desc='per-subject evaluation'):\n", + " subj_mask = data['subject'].values == subj\n", + " subj_data = data.isel(neuroid=subj_mask)\n", + " shuffled_scores.append(evaluate_shuffled(predictions, subj_data))\n", + " contiguous_scores.append(evaluate_contiguous(predictions, subj_data))\n", + " return {\n", + " 'subjects': subjects,\n", + " 'shuffled': np.array(shuffled_scores),\n", + " 'contiguous': np.array(contiguous_scores),\n", + " }" + ] + }, + { + "cell_type": "markdown", + "id": "cell-8", + "metadata": {}, + "source": [ + "## Run sigma sweep\n", + "\n", + "For each sigma value, compute OASM features once, then evaluate under both split types." + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "cell-9", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "sigma sweep: 0%| | 0/49 [00:00" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Best shuffled: sigma=0.9, r=0.4922, normalized=1.354\n", + "Best contiguous: sigma=0.0, r=0.0000, normalized=0.000\n" + ] + } + ], + "source": [ + "sigmas = sorted(results_shuffled.keys())\n", + "shuffled_r = [results_shuffled[s] for s in sigmas]\n", + "contiguous_r = [results_contiguous[s] for s in sigmas]\n", + "\n", + "# Ceiling-normalized scores\n", + "shuffled_norm = [r / CEILING_RAW for r in shuffled_r]\n", + "contiguous_norm = [r / CEILING_RAW for r in contiguous_r]\n", + "\n", + "fig, axes = plt.subplots(1, 2, figsize=(14, 5), sharey=False)\n", + "\n", + "# --- Left panel: raw Pearson r ---\n", + "ax = axes[0]\n", + "ax.plot(sigmas, shuffled_r, 'o-', color='#E74C3C', linewidth=2,\n", + " markersize=5, label='Shuffled (standard brain-score)', zorder=3)\n", + "ax.plot(sigmas, contiguous_r, 's-', color='#3498DB', linewidth=2,\n", + " markersize=5, label='Contiguous (passage-level)', zorder=3)\n", + "ax.axhline(y=CEILING_RAW, color='gray', linestyle=':', alpha=0.7,\n", + " label=f'Ceiling (r={CEILING_RAW:.3f})')\n", + "ax.axhline(y=0, color='black', linestyle='-', alpha=0.2)\n", + "ax.set_xlabel('OASM sigma', fontsize=12)\n", + "ax.set_ylabel('Median Pearson r', fontsize=12)\n", + "ax.set_title(f'Raw neural predictivity', fontsize=13)\n", + "ax.legend(fontsize=9, loc='upper right')\n", + "ax.grid(True, alpha=0.2)\n", + "ax.set_xlim(-0.2, max(sigmas) + 0.2)\n", + "\n", + "# --- Right panel: ceiling-normalized ---\n", + "ax = axes[1]\n", + "ax.plot(sigmas, shuffled_norm, 'o-', color='#E74C3C', linewidth=2,\n", + " markersize=5, label='Shuffled', zorder=3)\n", + "ax.plot(sigmas, contiguous_norm, 's-', color='#3498DB', linewidth=2,\n", + " markersize=5, label='Contiguous', zorder=3)\n", + "ax.axhline(y=1.0, color='gray', linestyle=':', alpha=0.7, label='Ceiling')\n", + "ax.axhline(y=0, color='black', linestyle='-', alpha=0.2)\n", + "ax.set_xlabel('OASM sigma', fontsize=12)\n", + "ax.set_ylabel('Ceiling-normalized score', fontsize=12)\n", + "ax.set_title(f'Ceiling-normalized neural predictivity', fontsize=13)\n", + "ax.legend(fontsize=9, loc='upper right')\n", + "ax.grid(True, alpha=0.2)\n", + "ax.set_xlim(-0.2, max(sigmas) + 0.2)\n", + "\n", + "fig.suptitle(f'OASM on Pereira2018.{EXPERIMENT}: Zero linguistic content, high shuffled scores',\n", + " fontsize=14, fontweight='bold', y=1.02)\n", + "plt.tight_layout()\n", + "plt.savefig('oasm_shuffled_vs_contiguous.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "\n", + "# Summary\n", + "best_shuf_idx = np.argmax(shuffled_r)\n", + "best_cont_idx = np.argmax(contiguous_r)\n", + "print(f\"Best shuffled: sigma={sigmas[best_shuf_idx]:.1f}, \"\n", + " f\"r={shuffled_r[best_shuf_idx]:.4f}, \"\n", + " f\"normalized={shuffled_norm[best_shuf_idx]:.3f}\")\n", + "print(f\"Best contiguous: sigma={sigmas[best_cont_idx]:.1f}, \"\n", + " f\"r={contiguous_r[best_cont_idx]:.4f}, \"\n", + " f\"normalized={contiguous_norm[best_cont_idx]:.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-12", + "metadata": {}, + "source": [ + "## Results summary table" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "cell-13", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + " Sigma Shuffled r Contiguous r Shuf/Ceiling\n", + "----------------------------------------------------\n", + " 0.0 0.0000 0.0000 0.000\n", + " 0.1 0.0000 0.0000 0.000\n", + " 0.2 0.4805 0.0000 1.322\n", + " 0.3 0.4803 0.0000 1.322\n", + " 0.4 0.4786 0.0000 1.317\n", + " 0.5 0.4710 0.0000 1.296\n", + " 0.6 0.4654 0.0000 1.281\n", + " 0.7 0.4584 0.0000 1.261\n", + " 0.8 0.4837 0.0000 1.331\n", + " 0.9 0.4922 0.0000 1.354\n", + " 1.0 0.4919 0.0000 1.353\n", + " 1.1 0.4910 0.0000 1.351\n", + " 1.2 0.4894 0.0000 1.347\n", + " 1.3 0.4869 0.0000 1.340\n", + " 1.4 0.4841 0.0000 1.332\n", + " 1.5 0.4808 0.0000 1.323\n", + " 1.6 0.4769 0.0000 1.312\n", + " 1.7 0.4772 0.0000 1.313\n", + " 1.8 0.4833 0.0000 1.330\n", + " 1.9 0.4836 0.0000 1.331\n", + " 2.0 0.4821 0.0000 1.326\n", + " 2.1 0.4792 0.0000 1.318\n", + " 2.2 0.4755 0.0000 1.308\n", + " 2.3 0.4667 0.0000 1.284\n", + " 2.4 0.4588 0.0000 1.263\n", + " 2.5 0.4486 0.0000 1.234\n", + " 2.6 0.4474 0.0000 1.231\n", + " 2.7 0.4465 0.0000 1.228\n", + " 2.8 0.4458 0.0000 1.227\n", + " 2.9 0.4453 0.0000 1.225\n", + " 3.0 0.4449 0.0000 1.224\n", + " 3.1 0.4447 0.0000 1.223\n", + " 3.2 0.4445 0.0000 1.223\n", + " 3.3 0.4443 0.0000 1.223\n", + " 3.4 0.4442 0.0000 1.222\n", + " 3.5 0.4442 0.0000 1.222\n", + " 3.6 0.4441 0.0000 1.222\n", + " 3.7 0.4441 0.0000 1.222\n", + " 3.8 0.4441 0.0000 1.222\n", + " 3.9 0.4441 0.0000 1.222\n", + " 4.0 0.4441 0.0000 1.222\n", + " 4.1 0.4441 0.0000 1.222\n", + " 4.2 0.4441 0.0000 1.222\n", + " 4.3 0.4441 0.0000 1.222\n", + " 4.4 0.4441 0.0000 1.222\n", + " 4.5 0.4441 0.0000 1.222\n", + " 4.6 0.4441 0.0000 1.222\n", + " 4.7 0.4441 0.0000 1.222\n", + " 4.8 0.4441 0.0000 1.222\n" + ] + } + ], + "source": [ + "print(f\"{'Sigma':>6} {'Shuffled r':>12} {'Contiguous r':>14} {'Shuf/Ceiling':>14}\")\n", + "print('-' * 52)\n", + "for s in sigmas:\n", + " sr = results_shuffled[s]\n", + " cr = results_contiguous[s]\n", + " sn = sr / CEILING_RAW\n", + " print(f\"{s:>6.1f} {sr:>12.4f} {cr:>14.4f} {sn:>14.3f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-14", + "metadata": {}, + "source": [ + "## Per-subject evaluation\n", + "\n", + "The paper reports per-subject scores (each dot = one fMRI participant). We do the same:\n", + "evaluate the best OASM sigma separately on each of the 10 Pereira2018 subjects' neuroids." + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Per-subject evaluation for best sigma=0.9\n", + "Subjects in data: ['018', '199', '288', '289', '296', '343', '366', '407', '426']\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "per-subject evaluation: 100%|██████████| 9/9 [00:37<00:00, 4.15s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Subject Shuffled Contiguous\n", + "------------------------------------\n", + "018 0.4269 0.0000\n", + "199 0.4723 0.0000\n", + "288 0.5111 0.0000\n", + "289 0.4278 0.0000\n", + "296 0.5026 0.0000\n", + "343 0.5298 0.0000\n", + "366 0.5313 0.0000\n", + "407 0.4991 0.0000\n", + "426 0.4365 0.0000\n", + "------------------------------------\n", + "Mean 0.4819 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "best_sigma = max(results_shuffled, key=results_shuffled.get)\n", + "print(f\"Per-subject evaluation for best sigma={best_sigma:.1f}\")\n", + "print(f\"Subjects in data: {sorted(set(data['subject'].values))}\")\n", + "\n", + "model = OASMSubject(identifier=f'oasm-sigma{best_sigma}', sigma=best_sigma, max_features=MAX_FEATURES)\n", + "model.start_neural_recording(\n", + " recording_target=ArtificialSubject.RecordingTarget.language_system,\n", + " recording_type=ArtificialSubject.RecordingType.fMRI\n", + ")\n", + "oasm_predictions = get_model_predictions(model, data)\n", + "oasm_per_subject = evaluate_per_subject(oasm_predictions, data)\n", + "\n", + "print(f\"\\n{'Subject':<12} {'Shuffled':>10} {'Contiguous':>12}\")\n", + "print(\"-\" * 36)\n", + "for subj, s, c in zip(oasm_per_subject['subjects'],\n", + " oasm_per_subject['shuffled'],\n", + " oasm_per_subject['contiguous']):\n", + " print(f\"{subj:<12} {s:>10.4f} {c:>12.4f}\")\n", + "print(\"-\" * 36)\n", + "print(f\"{'Mean':<12} {oasm_per_subject['shuffled'].mean():>10.4f} \"\n", + " f\"{oasm_per_subject['contiguous'].mean():>12.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-15", + "metadata": {}, + "source": [ + "## Interpretation\n", + "\n", + "### What the results show\n", + "\n", + "OASM achieves high neural predictivity under shuffled CV despite encoding zero linguistic\n", + "content. Under contiguous CV (story-level GroupKFold), scores drop to exactly 0.0 for all\n", + "sigma values. Both evaluations use the same ridge regression -- only the split strategy differs.\n", + "\n", + "This confirms Hadidi et al.'s central finding: **shuffled cross-validation inflates scores**\n", + "by allowing temporal autocorrelation to leak between train and test sets. When adjacent\n", + "sentences from the same passage appear in both train and test, the Gaussian-smoothed identity\n", + "features are predictive -- not because of language understanding, but because of shared\n", + "temporal structure.\n", + "\n", + "### Why contiguous gives exactly zero\n", + "\n", + "OASM assigns each passage block to orthogonal dimensions in feature space. When entire stories\n", + "(groups of passages) are held out, the held-out stimuli occupy feature dimensions that are\n", + "all-zero in the training data. Ridge regression cannot learn any useful mapping from all-zero\n", + "columns, so predictions become constant and Pearson r = 0 for every neuroid.\n", + "\n", + "### Why this matters for brain-score\n", + "\n", + "Brain-score's standard evaluation uses shuffled `ShuffleSplit` on individual stimuli.\n", + "This means any model whose representations have temporal autocorrelation\n", + "(including all autoregressive LLMs) gets an inflated score. The OASM result\n", + "quantifies exactly how much of the score is attributable to this confound\n", + "rather than genuine linguistic alignment." + ] + }, + { + "cell_type": "markdown", + "id": "cell-16", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## GPT2-XL Comparison\n", + "\n", + "To validate that our evaluation pipeline is sound, we run GPT2-XL (1.5B params, layer 43)\n", + "through the same shuffled and contiguous evaluations. Unlike OASM, GPT2-XL encodes genuine\n", + "linguistic content and should retain non-zero predictivity under contiguous splits." + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "cell-17", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Loading GPT2-XL (1.5B params)...\n", + "Using device: mps\n", + "Getting GPT2-XL predictions (96 passages)...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n", + "/opt/anaconda3/envs/language-2026/lib/python3.11/site-packages/xarray/core/concat.py:500: FutureWarning: unique with argument that is not not a Series, Index, ExtensionArray, or np.ndarray is deprecated and will raise in a future version.\n", + " common_dims = tuple(pd.unique([d for v in vars for d in v.dims]))\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "GPT2-XL predictions shape: (384, 1600)\n", + "\n", + "Per-subject evaluation for GPT2-XL...\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "per-subject evaluation: 100%|██████████| 9/9 [00:54<00:00, 6.03s/it]" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Subject Shuffled Contiguous\n", + "------------------------------------\n", + "018 0.3107 0.0508\n", + "199 0.3480 -0.0179\n", + "288 0.3699 0.0018\n", + "289 0.4044 0.1223\n", + "296 0.3902 0.0549\n", + "343 0.4327 0.1304\n", + "366 0.3408 0.0352\n", + "407 0.4087 0.0186\n", + "426 0.4176 0.1775\n", + "------------------------------------\n", + "Mean 0.3804 0.0637\n", + "\n", + "Model Shuffled (mean) Contiguous (mean)\n", + "------------------------------------------------\n", + "GPT2-XL 0.3804 0.0637\n", + "OASM 0.4819 0.0000\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n" + ] + } + ], + "source": [ + "from brainscore_language.model_helpers.huggingface import HuggingfaceSubject\n", + "\n", + "print(\"Loading GPT2-XL (1.5B params)...\")\n", + "gpt2xl = HuggingfaceSubject(\n", + " model_id='gpt2-xl',\n", + " region_layer_mapping={\n", + " ArtificialSubject.RecordingTarget.language_system: 'transformer.h.43'\n", + " }\n", + ")\n", + "gpt2xl.start_neural_recording(\n", + " recording_target=ArtificialSubject.RecordingTarget.language_system,\n", + " recording_type=ArtificialSubject.RecordingType.fMRI\n", + ")\n", + "\n", + "print(\"Getting GPT2-XL predictions (96 passages)...\")\n", + "gpt2xl_predictions = get_model_predictions(gpt2xl, data)\n", + "print(f\"GPT2-XL predictions shape: {gpt2xl_predictions.shape}\")\n", + "\n", + "print(\"\\nPer-subject evaluation for GPT2-XL...\")\n", + "gpt2xl_per_subject = evaluate_per_subject(gpt2xl_predictions, data)\n", + "\n", + "print(f\"\\n{'Subject':<12} {'Shuffled':>10} {'Contiguous':>12}\")\n", + "print(\"-\" * 36)\n", + "for subj, s, c in zip(gpt2xl_per_subject['subjects'],\n", + " gpt2xl_per_subject['shuffled'],\n", + " gpt2xl_per_subject['contiguous']):\n", + " print(f\"{subj:<12} {s:>10.4f} {c:>12.4f}\")\n", + "print(\"-\" * 36)\n", + "print(f\"{'Mean':<12} {gpt2xl_per_subject['shuffled'].mean():>10.4f} \"\n", + " f\"{gpt2xl_per_subject['contiguous'].mean():>12.4f}\")\n", + "\n", + "print(f\"\\n{'Model':<12} {'Shuffled (mean)':>16} {'Contiguous (mean)':>18}\")\n", + "print(\"-\" * 48)\n", + "print(f\"{'GPT2-XL':<12} {gpt2xl_per_subject['shuffled'].mean():>16.4f} \"\n", + " f\"{gpt2xl_per_subject['contiguous'].mean():>18.4f}\")\n", + "print(f\"{'OASM':<12} {oasm_per_subject['shuffled'].mean():>16.4f} \"\n", + " f\"{oasm_per_subject['contiguous'].mean():>18.4f}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-18", + "metadata": {}, + "source": [ + "---\n", + "\n", + "## Figure 1 Reproduction: OASM vs GPT2-XL (Hadidi et al., 2025)\n", + "\n", + "Figure 1 is the paper's central result. It compares OASM (zero linguistic content)\n", + "against GPT2-XL variants across all three neural benchmarks, under both shuffled\n", + "and contiguous cross-validation splits, using **ridge regression (L2)**.\n", + "\n", + "Source data: downloaded from the paper's GitHub repo\n", + "([source_data/figure1/](https://github.com/ebrahimfeghhi/beyond-brainscore/tree/main/source_data/figure1))." + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "cell-19", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "OASM per-subject (Pereira):\n", + " Shuffled: mean=0.4819 range=[0.4269, 0.5313]\n", + " Contiguous: mean=0.0000 range=[0.0000, 0.0000]\n", + "\n", + "GPT2-XL per-subject (Pereira):\n", + " Shuffled: mean=0.3804 range=[0.3107, 0.4327]\n", + " Contiguous: mean=0.0637 range=[-0.0179, 0.1775]\n", + "\n", + "Paper's OASM on Pereira shuffled: mean=0.4511 (range [0.3859, 0.5333])\n", + "\n", + "Loaded 6 source CSVs\n" + ] + } + ], + "source": [ + "import pandas as pd\n", + "from pathlib import Path\n", + "\n", + "SOURCE_DIR = Path(\"source_data/figure1\")\n", + "\n", + "DATASETS = [\"pereira\", \"fedorenko\", \"blank\"]\n", + "DATASET_LABELS = {\"pereira\": \"Pereira2018\", \"fedorenko\": \"Fedorenko2016\", \"blank\": \"Blank2014\"}\n", + "CONDITIONS = [\"shuffled\", \"contig\"]\n", + "MODELS = [\"GPT2-XL\", \"GPT2-XL-mp\", \"GPT2-XL-sp\", \"OASM\"]\n", + "MODEL_COLORS = {\n", + " \"GPT2-XL\": \"#7f7f7f\",\n", + " \"GPT2-XL-mp\": \"#1f77b4\",\n", + " \"GPT2-XL-sp\": \"#2ca02c\",\n", + " \"OASM\": \"#d62728\",\n", + "}\n", + "\n", + "# Load Pearson r CSVs (L2-regularized, the paper's main analysis)\n", + "fig1_data = {}\n", + "for dataset in DATASETS:\n", + " for condition in CONDITIONS:\n", + " fname = SOURCE_DIR / f\"{dataset}_pearson_r_{condition}.csv\"\n", + " fig1_data[(dataset, condition)] = pd.read_csv(fname)\n", + "\n", + "# Our per-subject results (arrays of scores, one per fMRI participant)\n", + "OUR_OASM_PER_SUBJ = {}\n", + "OUR_GPT2XL_PER_SUBJ = {}\n", + "\n", + "if 'oasm_per_subject' in dir():\n", + " OUR_OASM_PER_SUBJ[(\"pereira\", \"shuffled\")] = oasm_per_subject['shuffled']\n", + " OUR_OASM_PER_SUBJ[(\"pereira\", \"contig\")] = oasm_per_subject['contiguous']\n", + " print(f\"OASM per-subject (Pereira):\")\n", + " print(f\" Shuffled: mean={oasm_per_subject['shuffled'].mean():.4f} \"\n", + " f\"range=[{oasm_per_subject['shuffled'].min():.4f}, {oasm_per_subject['shuffled'].max():.4f}]\")\n", + " print(f\" Contiguous: mean={oasm_per_subject['contiguous'].mean():.4f} \"\n", + " f\"range=[{oasm_per_subject['contiguous'].min():.4f}, {oasm_per_subject['contiguous'].max():.4f}]\")\n", + "\n", + "if 'gpt2xl_per_subject' in dir():\n", + " OUR_GPT2XL_PER_SUBJ[(\"pereira\", \"shuffled\")] = gpt2xl_per_subject['shuffled']\n", + " OUR_GPT2XL_PER_SUBJ[(\"pereira\", \"contig\")] = gpt2xl_per_subject['contiguous']\n", + " print(f\"\\nGPT2-XL per-subject (Pereira):\")\n", + " print(f\" Shuffled: mean={gpt2xl_per_subject['shuffled'].mean():.4f} \"\n", + " f\"range=[{gpt2xl_per_subject['shuffled'].min():.4f}, {gpt2xl_per_subject['shuffled'].max():.4f}]\")\n", + " print(f\" Contiguous: mean={gpt2xl_per_subject['contiguous'].mean():.4f} \"\n", + " f\"range=[{gpt2xl_per_subject['contiguous'].min():.4f}, {gpt2xl_per_subject['contiguous'].max():.4f}]\")\n", + "\n", + "# Paper's OASM for comparison\n", + "paper_pereira_shuf = fig1_data[(\"pereira\", \"shuffled\")]\n", + "paper_oasm = paper_pereira_shuf[paper_pereira_shuf[\"Model\"] == \"OASM\"][\"perf\"]\n", + "print(f\"\\nPaper's OASM on Pereira shuffled: mean={paper_oasm.mean():.4f} \"\n", + " f\"(range [{paper_oasm.min():.4f}, {paper_oasm.max():.4f}])\")\n", + "\n", + "print(f\"\\nLoaded {len(fig1_data)} source CSVs\")" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "cell-20", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "\n", + "Comparison: Paper vs Our Per-Subject Results (Pereira2018)\n", + "Model Condition Paper mean Paper range Ours mean Ours range\n", + "----------------------------------------------------------------------------\n", + "OASM shuffled 0.4511 [0.386, 0.533] 0.4819 [0.427, 0.531]\n", + "OASM contig 0.0000 [0.000, 0.000] 0.0000 [0.000, 0.000]\n", + "GPT2-XL shuffled 0.3981 [0.319, 0.457] 0.3804 [0.311, 0.433]\n", + "GPT2-XL contig 0.1402 [0.038, 0.274] 0.0637 [-0.018, 0.178]\n" + ] + } + ], + "source": [ + "from matplotlib.lines import Line2D\n", + "\n", + "fig, axes = plt.subplots(2, 3, figsize=(14, 8), sharey='row')\n", + "\n", + "condition_labels = {\"shuffled\": \"Shuffled splits (brain-score default)\",\n", + " \"contig\": \"Contiguous splits (story-level GroupKFold)\"}\n", + "bar_width = 0.6\n", + "has_our_results = bool(OUR_OASM_PER_SUBJ) or bool(OUR_GPT2XL_PER_SUBJ)\n", + "\n", + "# Map from model name -> our per-subject results dict\n", + "our_per_subj_map = {\n", + " \"OASM\": OUR_OASM_PER_SUBJ,\n", + " \"GPT2-XL\": OUR_GPT2XL_PER_SUBJ,\n", + "}\n", + "\n", + "for row, condition in enumerate(CONDITIONS):\n", + " for col, dataset in enumerate(DATASETS):\n", + " ax = axes[row, col]\n", + " df = fig1_data[(dataset, condition)]\n", + "\n", + " for i, model in enumerate(MODELS):\n", + " model_df = df[df[\"Model\"] == model]\n", + " values = model_df[\"perf\"].values\n", + " mean_val = values.mean()\n", + "\n", + " # Bar for the mean\n", + " ax.bar(i, mean_val, width=bar_width, color=MODEL_COLORS[model],\n", + " alpha=0.35, edgecolor=MODEL_COLORS[model], linewidth=1.2)\n", + " # Per-subject dots (paper)\n", + " rng = np.random.default_rng(42)\n", + " jitter = rng.uniform(-0.15, 0.15, len(values))\n", + " ax.scatter(i + jitter, values, color=MODEL_COLORS[model],\n", + " s=25, zorder=3, alpha=0.8, edgecolors='white', linewidth=0.5)\n", + " # Mean line (paper)\n", + " ax.plot([i - 0.2, i + 0.2], [mean_val, mean_val],\n", + " color=MODEL_COLORS[model], linewidth=2.5, zorder=4)\n", + "\n", + " # Overlay our per-subject results as gold dots + mean star\n", + " our_results = our_per_subj_map.get(model, {})\n", + " our_vals = our_results.get((dataset, condition))\n", + " if our_vals is not None:\n", + " our_mean = our_vals.mean()\n", + " rng2 = np.random.default_rng(123)\n", + " our_jitter = rng2.uniform(-0.12, 0.12, len(our_vals))\n", + " ax.scatter(i + our_jitter, our_vals, color='gold',\n", + " s=40, zorder=5, alpha=0.9, edgecolors='black',\n", + " linewidth=0.8, marker='D')\n", + " ax.plot([i - 0.2, i + 0.2], [our_mean, our_mean],\n", + " color='gold', linewidth=2.5, zorder=6, linestyle='--')\n", + "\n", + " ax.set_xticks(range(len(MODELS)))\n", + " short_labels = [\"GPT2\\nXL\", \"GPT2\\nXL-mp\", \"GPT2\\nXL-sp\", \"OASM\"]\n", + " ax.set_xticklabels(short_labels, fontsize=8)\n", + " ax.axhline(y=0, color='black', linewidth=0.5, alpha=0.3)\n", + " ax.grid(axis='y', alpha=0.2)\n", + "\n", + " if row == 0:\n", + " ax.set_title(DATASET_LABELS[dataset], fontsize=13, fontweight='bold')\n", + " if col == 0:\n", + " ax.set_ylabel(f\"Pearson r\\n({condition_labels[condition]})\", fontsize=10)\n", + "\n", + "# Build legend\n", + "legend_handles = [\n", + " Line2D([0], [0], marker='o', color='w', markerfacecolor='gray',\n", + " markersize=6, label='Paper: per-subject values'),\n", + " Line2D([0], [0], color='gray', linewidth=2.5, label='Paper: mean'),\n", + "]\n", + "if has_our_results:\n", + " legend_handles.extend([\n", + " Line2D([0], [0], marker='D', color='w', markerfacecolor='gold',\n", + " markeredgecolor='black', markersize=7,\n", + " label='Ours: per-subject values'),\n", + " Line2D([0], [0], color='gold', linewidth=2.5, linestyle='--',\n", + " label='Ours: mean'),\n", + " ])\n", + "fig.legend(handles=legend_handles, loc='upper right', fontsize=9,\n", + " framealpha=0.9, bbox_to_anchor=(0.99, 0.99))\n", + "\n", + "title = \"Figure 1 (Hadidi et al., 2025): OASM vs GPT2-XL\"\n", + "subtitle = \"All evaluations use ridge regression (L2). Per-subject dots for both paper and ours.\"\n", + "fig.suptitle(f\"{title}\\n{subtitle}\", fontsize=13, fontweight='bold', y=1.04)\n", + "plt.tight_layout()\n", + "plt.savefig('figure1_reproduction.png', dpi=150, bbox_inches='tight')\n", + "plt.show()\n", + "\n", + "# Print comparison table\n", + "print(\"\\nComparison: Paper vs Our Per-Subject Results (Pereira2018)\")\n", + "print(f\"{'Model':<10} {'Condition':<10} {'Paper mean':>11} {'Paper range':>16} \"\n", + " f\"{'Ours mean':>10} {'Ours range':>16}\")\n", + "print(\"-\" * 76)\n", + "for model_name, our_results in [(\"OASM\", OUR_OASM_PER_SUBJ), (\"GPT2-XL\", OUR_GPT2XL_PER_SUBJ)]:\n", + " for cond in CONDITIONS:\n", + " paper_vals = fig1_data[(\"pereira\", cond)]\n", + " paper_model_vals = paper_vals[paper_vals[\"Model\"] == model_name][\"perf\"].values\n", + " our_vals = our_results.get((\"pereira\", cond))\n", + " if our_vals is not None:\n", + " print(f\"{model_name:<10} {cond:<10} {paper_model_vals.mean():>11.4f} \"\n", + " f\"[{paper_model_vals.min():.3f}, {paper_model_vals.max():.3f}] \"\n", + " f\"{our_vals.mean():>10.4f} [{our_vals.min():.3f}, {our_vals.max():.3f}]\")\n", + " else:\n", + " print(f\"{model_name:<10} {cond:<10} {paper_model_vals.mean():>11.4f} \"\n", + " f\"[{paper_model_vals.min():.3f}, {paper_model_vals.max():.3f}] \"\n", + " f\"{'--':>10} {'--':>16}\")" + ] + }, + { + "cell_type": "markdown", + "id": "cell-21", + "metadata": {}, + "source": [ + "### Figure 1: Comparing our per-subject results to the paper\n", + "\n", + "**Gold diamonds** show our per-subject scores (one per fMRI participant, 10 total).\n", + "**Colored circles** show the paper's per-subject scores. Both use ridge regression (RidgeCV, L2).\n", + "\n", + "**OASM (Pereira2018):** Our per-subject distribution overlaps closely with the paper's\n", + "range for shuffled splits. Contiguous scores are exactly 0.0 for all subjects in both\n", + "the paper and our implementation, confirming OASM has zero genuine predictive power.\n", + "\n", + "**GPT2-XL (Pereira2018):** Our GPT2-XL scores are directionally consistent with the\n", + "paper but differ in magnitude, particularly under contiguous splits. This is may be expected\n", + "due to implementation differences that do not affect OASM (which is fully deterministic):\n", + "\n", + "- **Layer selection:** We use a fixed layer (`transformer.h.43`, the last layer).\n", + " The paper performs a layer sweep and selects the best layer, which may differ\n", + " between shuffled and contiguous evaluation and may not be the final layer.\n", + "- **Representation extraction:** Brain-score's `HuggingfaceSubject` uses the\n", + " last-token hidden state. The paper may aggregate across tokens differently\n", + " (e.g., mean-pooling), producing different features for regression.\n", + "- **Data preprocessing:** We load via brain-score's `load_dataset` and drop NaN\n", + " neuroids. The paper's pipeline may apply different voxel selection or z-scoring.\n", + "\n", + "These differences do not affect the central finding: **GPT2-XL retains non-zero\n", + "predictivity under contiguous splits (genuine linguistic signal) while OASM drops\n", + "to exactly zero (no linguistic content).** The qualitative conclusion holds regardless\n", + "of the exact GPT2-XL magnitude.\n", + "\n", + "**Fedorenko2016 and Blank2014:** Showing paper data only. Our evaluation covers Pereira2018;\n", + "extending to the other datasets requires running those benchmarks separately." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "language-2026", + "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.11.14" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/brainscore_language/models/oasm/validation/oasm_shuffled_vs_contiguous.png b/brainscore_language/models/oasm/validation/oasm_shuffled_vs_contiguous.png new file mode 100644 index 00000000..7d13b38f Binary files /dev/null and b/brainscore_language/models/oasm/validation/oasm_shuffled_vs_contiguous.png differ diff --git a/brainscore_language/models/oasm/validation/source_data/README.md b/brainscore_language/models/oasm/validation/source_data/README.md new file mode 100644 index 00000000..11f07663 --- /dev/null +++ b/brainscore_language/models/oasm/validation/source_data/README.md @@ -0,0 +1,24 @@ +# Source Data + +Per-subject Pearson r values from Hadidi et al. (2025) "Illusions of Alignment Between Large Language Models and Brains Emerge From Fragile Methods and Overlooked Confounds." + +Downloaded from: https://github.com/ebrahimfeghhi/beyond-brainscore/tree/main/source_data/figure1 + +## Files + +All CSVs have columns: `subjects, Network, Model, perf` + +Models: GPT2-XL, GPT2-XL-mp (mean-pooled), GPT2-XL-sp (sum-pooled), OASM + +### figure1/ + +| File | Dataset | CV Split | Subjects | +|------|---------|----------|----------| +| `pereira_pearson_r_shuffled.csv` | Pereira2018 | Shuffled | 10 | +| `pereira_pearson_r_contig.csv` | Pereira2018 | Contiguous (passage-level) | 10 | +| `fedorenko_pearson_r_shuffled.csv` | Fedorenko2016 | Shuffled | 5 | +| `fedorenko_pearson_r_contig.csv` | Fedorenko2016 | Contiguous (passage-level) | 5 | +| `blank_pearson_r_shuffled.csv` | Blank2014 | Shuffled | 5 | +| `blank_pearson_r_contig.csv` | Blank2014 | Contiguous (passage-level) | 5 | + +These are the L2-regularized (ridge regression) results used in the paper's Figure 1. diff --git a/brainscore_language/models/oasm/validation/source_data/figure1/blank_pearson_r_contig.csv b/brainscore_language/models/oasm/validation/source_data/figure1/blank_pearson_r_contig.csv new file mode 100644 index 00000000..7bba5484 --- /dev/null +++ b/brainscore_language/models/oasm/validation/source_data/figure1/blank_pearson_r_contig.csv @@ -0,0 +1,21 @@ +subjects,Network,Model,perf +0,language,GPT2-XL,0.07220138891724226 +0,language,GPT2-XL-mp,0.09571631494500044 +0,language,GPT2-XL-sp,0.08747649739812169 +0,language,OASM,0.0 +1,language,GPT2-XL,0.011106857963739003 +1,language,GPT2-XL-mp,0.017414663323736774 +1,language,GPT2-XL-sp,0.014038576738976608 +1,language,OASM,0.002839950586707237 +2,language,GPT2-XL,0.017727995827974352 +2,language,GPT2-XL-mp,0.029838162900192478 +2,language,GPT2-XL-sp,0.039573392800788976 +2,language,OASM,0.0030390148848630596 +3,language,GPT2-XL,0.022947151997441646 +3,language,GPT2-XL-mp,0.05178651210303816 +3,language,GPT2-XL-sp,0.04797006822532257 +3,language,OASM,0.004422205707802125 +4,language,GPT2-XL,0.0 +4,language,GPT2-XL-mp,0.0 +4,language,GPT2-XL-sp,0.0 +4,language,OASM,0.006326722478589915 diff --git a/brainscore_language/models/oasm/validation/source_data/figure1/blank_pearson_r_shuffled.csv b/brainscore_language/models/oasm/validation/source_data/figure1/blank_pearson_r_shuffled.csv new file mode 100644 index 00000000..db6d95ea --- /dev/null +++ b/brainscore_language/models/oasm/validation/source_data/figure1/blank_pearson_r_shuffled.csv @@ -0,0 +1,21 @@ +subjects,Network,Model,perf +0,language,GPT2-XL,0.08057108715817103 +0,language,GPT2-XL-mp,0.19209100947665414 +0,language,GPT2-XL-sp,0.17823206144446083 +0,language,OASM,0.5633979979944896 +1,language,GPT2-XL,0.008929434902181697 +1,language,GPT2-XL-mp,0.10418312587074101 +1,language,GPT2-XL-sp,0.08372259791841508 +1,language,OASM,0.4645187989729032 +2,language,GPT2-XL,0.06354523220521707 +2,language,GPT2-XL-mp,0.14500306548652186 +2,language,GPT2-XL-sp,0.14045774085655402 +2,language,OASM,0.5592956673262197 +3,language,GPT2-XL,0.060927733997912036 +3,language,GPT2-XL-mp,0.10298613856093268 +3,language,GPT2-XL-sp,0.09343440634146795 +3,language,OASM,0.4394840984322636 +4,language,GPT2-XL,0.031226469155534026 +4,language,GPT2-XL-mp,0.10959202214338164 +4,language,GPT2-XL-sp,0.09633169637601853 +4,language,OASM,0.48818989622015496 diff --git a/brainscore_language/models/oasm/validation/source_data/figure1/fedorenko_pearson_r_contig.csv b/brainscore_language/models/oasm/validation/source_data/figure1/fedorenko_pearson_r_contig.csv new file mode 100644 index 00000000..daa0a5ee --- /dev/null +++ b/brainscore_language/models/oasm/validation/source_data/figure1/fedorenko_pearson_r_contig.csv @@ -0,0 +1,21 @@ +subjects,Network,Model,perf +1,language,GPT2-XL,0.2531962428615742 +1,language,GPT2-XL-mp,0.2536414001126081 +1,language,GPT2-XL-sp,0.2675449599446727 +1,language,OASM,0.0 +2,language,GPT2-XL,0.09756753772383757 +2,language,GPT2-XL-mp,0.09742801152429637 +2,language,GPT2-XL-sp,0.0941148994520113 +2,language,OASM,0.0 +3,language,GPT2-XL,0.31259829314535786 +3,language,GPT2-XL-mp,0.31470006703645154 +3,language,GPT2-XL-sp,0.3204371660500738 +3,language,OASM,0.0 +4,language,GPT2-XL,0.21327082459956523 +4,language,GPT2-XL-mp,0.21586958867858239 +4,language,GPT2-XL-sp,0.2125194478657789 +4,language,OASM,0.0 +5,language,GPT2-XL,0.14001115313558704 +5,language,GPT2-XL-mp,0.14856808301994873 +5,language,GPT2-XL-sp,0.15325231511599408 +5,language,OASM,0.0 diff --git a/brainscore_language/models/oasm/validation/source_data/figure1/fedorenko_pearson_r_shuffled.csv b/brainscore_language/models/oasm/validation/source_data/figure1/fedorenko_pearson_r_shuffled.csv new file mode 100644 index 00000000..dfcb58ca --- /dev/null +++ b/brainscore_language/models/oasm/validation/source_data/figure1/fedorenko_pearson_r_shuffled.csv @@ -0,0 +1,21 @@ +subjects,Network,Model,perf +1,language,GPT2-XL,0.34896263570752317 +1,language,GPT2-XL-mp,0.3632317345906369 +1,language,GPT2-XL-sp,0.34499940775120036 +1,language,OASM,0.4270511335054035 +2,language,GPT2-XL,0.13392662046961318 +2,language,GPT2-XL-mp,0.1545791239259306 +2,language,GPT2-XL-sp,0.12473568916503006 +2,language,OASM,0.16037223022820074 +3,language,GPT2-XL,0.3657384796724074 +3,language,GPT2-XL-mp,0.3719569180796879 +3,language,GPT2-XL-sp,0.3673204593887698 +3,language,OASM,0.29057329850431324 +4,language,GPT2-XL,0.24713742843845501 +4,language,GPT2-XL-mp,0.25259369495842443 +4,language,GPT2-XL-sp,0.23867056440342482 +4,language,OASM,0.23077332877596096 +5,language,GPT2-XL,0.19116972337286864 +5,language,GPT2-XL-mp,0.19920357179742398 +5,language,GPT2-XL-sp,0.18894171878085173 +5,language,OASM,0.2567917104195885 diff --git a/brainscore_language/models/oasm/validation/source_data/figure1/pereira_pearson_r_contig.csv b/brainscore_language/models/oasm/validation/source_data/figure1/pereira_pearson_r_contig.csv new file mode 100644 index 00000000..f089b8f8 --- /dev/null +++ b/brainscore_language/models/oasm/validation/source_data/figure1/pereira_pearson_r_contig.csv @@ -0,0 +1,41 @@ +subjects,Network,Model,perf +018,language,GPT2-XL,0.14578051637840278 +018,language,GPT2-XL-mp,0.13563427881713885 +018,language,GPT2-XL-sp,0.1514872984318209 +018,language,OASM,0.0 +199,language,GPT2-XL,0.05219479952194437 +199,language,GPT2-XL-mp,0.038389015728642686 +199,language,GPT2-XL-sp,0.03950010128904683 +199,language,OASM,0.0 +215,language,GPT2-XL,0.11520714392075457 +215,language,GPT2-XL-mp,0.1352198906372439 +215,language,GPT2-XL-sp,0.14285146790079145 +215,language,OASM,0.0 +288,language,GPT2-XL,0.03781054791432703 +288,language,GPT2-XL-mp,0.02893575085663852 +288,language,GPT2-XL-sp,0.027811467449337803 +288,language,OASM,0.0 +289,language,GPT2-XL,0.23009409177705825 +289,language,GPT2-XL-mp,0.22916380273265263 +289,language,GPT2-XL-sp,0.2526674462210045 +289,language,OASM,0.0 +296,language,GPT2-XL,0.1427073601039065 +296,language,GPT2-XL-mp,0.1374394617766227 +296,language,GPT2-XL-sp,0.151085071585596 +296,language,OASM,0.0 +343,language,GPT2-XL,0.2343104954603496 +343,language,GPT2-XL-mp,0.2544405835454391 +343,language,GPT2-XL-sp,0.2530558012365958 +343,language,OASM,0.0 +366,language,GPT2-XL,0.07411343575248923 +366,language,GPT2-XL-mp,0.10450934630019292 +366,language,GPT2-XL-sp,0.09344268647638543 +366,language,OASM,0.0 +407,language,GPT2-XL,0.09504107396554322 +407,language,GPT2-XL-mp,0.10178009075487737 +407,language,GPT2-XL-sp,0.09047300455378827 +407,language,OASM,0.0 +426,language,GPT2-XL,0.27442101859252027 +426,language,GPT2-XL-mp,0.23587685596507482 +426,language,GPT2-XL-sp,0.2673726751545331 +426,language,OASM,0.0 diff --git a/brainscore_language/models/oasm/validation/source_data/figure1/pereira_pearson_r_shuffled.csv b/brainscore_language/models/oasm/validation/source_data/figure1/pereira_pearson_r_shuffled.csv new file mode 100644 index 00000000..32bdb715 --- /dev/null +++ b/brainscore_language/models/oasm/validation/source_data/figure1/pereira_pearson_r_shuffled.csv @@ -0,0 +1,41 @@ +subjects,Network,Model,perf +018,language,GPT2-XL,0.3442951669360902 +018,language,GPT2-XL-mp,0.29589984154535154 +018,language,GPT2-XL-sp,0.30395150193756704 +018,language,OASM,0.3859145871759404 +199,language,GPT2-XL,0.3644974873394911 +199,language,GPT2-XL-mp,0.31021432304053437 +199,language,GPT2-XL-sp,0.3177334788718606 +199,language,OASM,0.4392121333580187 +215,language,GPT2-XL,0.31874498972536186 +215,language,GPT2-XL-mp,0.3263331768451008 +215,language,GPT2-XL-sp,0.3277647897361882 +215,language,OASM,0.39916894793816005 +288,language,GPT2-XL,0.36287603484560177 +288,language,GPT2-XL-mp,0.30116227129847284 +288,language,GPT2-XL-sp,0.29652416588843056 +288,language,OASM,0.4840496788741042 +289,language,GPT2-XL,0.40276716888182484 +289,language,GPT2-XL-mp,0.3541060117368643 +289,language,GPT2-XL-sp,0.3648883682459654 +289,language,OASM,0.4089635265850968 +296,language,GPT2-XL,0.4274455994127759 +296,language,GPT2-XL-mp,0.35562811365138747 +296,language,GPT2-XL-sp,0.35613891703014366 +296,language,OASM,0.4741234476007776 +343,language,GPT2-XL,0.45686935058589384 +343,language,GPT2-XL-mp,0.3752334716733578 +343,language,GPT2-XL-sp,0.36730177314000684 +343,language,OASM,0.5332797466860137 +366,language,GPT2-XL,0.44676485071482674 +366,language,GPT2-XL-mp,0.38266573904760465 +366,language,GPT2-XL-sp,0.38047200536874104 +366,language,OASM,0.48768168755220703 +407,language,GPT2-XL,0.4527823611553371 +407,language,GPT2-XL-mp,0.36421827510196736 +407,language,GPT2-XL-sp,0.3724357519638481 +407,language,OASM,0.49362086698250895 +426,language,GPT2-XL,0.4034578776932959 +426,language,GPT2-XL-mp,0.38425345135426536 +426,language,GPT2-XL-sp,0.40487508824102914 +426,language,OASM,0.4045312019944507