メニュー
Brain-guided language model framework for robust reasoning - using task-fMRI signals from reasoning regions to enhance LLM performance across 10 models with up to 13% accuracy gain
デフォルトでは、最初にソースを確認する Prompt が選択されています。直接コマンドに切り替えるか、ローカルコピーをダウンロードすることもできます。
インストールを決める前に、SKILL.md と SkillsMP に表示されている付属ファイルをお読みください。
SOC 職業分類に基づく
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/hiyenwong/ai_collection --skill brain-guided-llm-reasoning-alignmentコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
SKILL.md を表示中
Graph-native Python reimplementation of the Information Dynamics of Music (IDyOM) model that represents predictive memories as explicit graph objects for musical expectation modeling and network analysis.
Physics-aware end-to-end deep reinforcement learning methodology for quadcopter control with actuator dynamics modeling.
Reinforced Dreamer methodology for asymmetric reinforcement learning using latent guidance to improve world model representations and behaviors in model-based RL.
| name | brain-guided-llm-reasoning-alignment |
| description | Brain-guided language model framework for robust reasoning - using task-fMRI signals from reasoning regions to enhance LLM performance across 10 models with up to 13% accuracy gain |
| version | 1.0.0 |
| category | neuroscience |
| activation_keywords | ["brain-guided LLM","reasoning enhancement","brain-LLM alignment","neural-predictivity","task-fMRI steering","reasoning intervention","brain-signal guidance","representational alignment"] |
| trigger_pattern | Brain-guided LLM|reasoning enhancement|brain signal guidance|task-fMRI steering|neural predictivity |
| authors | ["Mingqing Xiao","Kai Du","Zhouchen Lin"] |
| arxiv_id | 2606.11893 |
| published_date | 2026-06-10T00:00:00.000Z |
arXiv: 2606.11893 | Published: 2026-06-10 | Categories: cs.LG, cs.AI, cs.CL, q-bio.NC
Current brain-LLM alignment research faces critical limitations:
Brain-guided framework that:
Key Result: Task-evoked brain signals from reasoning regions directly enhance LLM reasoning, orthogonal to language-only supervision.
[Task-fMRI from Reasoning Regions] → [Neural-Predictivity Metric]
↓
[Joint Structure Analysis (Brain + Model)]
↓
[Steering Directions (Representation Intervention)]
↓
[LLM Reasoning Enhancement (+13% Accuracy)]
class NeuralPredictivityMetric:
"""
Measure alignment between LLM representations and brain activity.
Key insight: Evaluate predictivity specifically in reasoning-related
brain regions, not just language areas.
Args:
- reasoning_regions: ROI mask for reasoning-specific cortex
(e.g., lateral PFC, parietal cortex)
- model_encoder: LLM representation encoder
- brain_encoder: fMRI signal encoder
"""
def __init__(
self,
reasoning_regions,
language_regions,
model_encoder,
brain_encoder
):
.reasoning_mask = reasoning_regions
.language_mask = language_regions
.model_encoder = model_encoder
.brain_encoder = brain_encoder
():
model_features = .model_encoder(model_representations)
reasoning_specific:
masked_activity = brain_activity[:, .reasoning_mask, :]
:
masked_activity = brain_activity[:, .language_mask, :]
brain_features = .brain_encoder(masked_activity)
predictivity = .compute_voxelwise_encoding(
model_features,
brain_features
)
aggregate:
predictivity.mean()
:
.breakdown_by_type(predictivity)
():
sklearn.linear_model Ridge
sklearn.metrics r2_score
predictivity_scores = []
voxel_idx (brain_features.shape[]):
voxel_signal = brain_features[:, voxel_idx]
encoder = Ridge(alpha=)
encoder.fit(model_features, voxel_signal)
predicted = encoder.predict(model_features)
r2 = r2_score(voxel_signal, predicted)
predictivity_scores.append(r2)
np.array(predictivity_scores)
():
type_scores = {}
rtype reasoning_types:
type_mask = .get_reasoning_type_mask(rtype)
type_predictivity = predictivity[type_mask]
type_scores[rtype] = type_predictivity.mean()
type_scores
class JointStructureAnalysis:
"""
Analyze joint representation space of brain and model.
Key insight: Find directions where brain and model representations
align, then use these for steering interventions.
Method: Canonical Correlation Analysis (CCA) or Similarity Structure
Analysis on joint brain-model embedding space.
"""
def __init__(
self,
brain_dim,
model_dim,
joint_dim=100
):
self.joint_dim = joint_dim
# Projectors to joint space
self.brain_projector = nn.Linear(brain_dim, joint_dim)
self.model_projector = nn.Linear(model_dim, joint_dim)
# CCA components (learned alignment directions)
self.cca = None
def compute_joint_structure(
self,
brain_representations,
model_representations
):
"""
Compute joint brain-model representation structure.
Args:
- brain_representations: [batch, voxels, time]
- model_representations: [batch, seq, hidden]
Returns:
- steering_directions: aligned directions in model space
- correlation_matrix: brain-model correlation structure
"""
# Project to joint space
brain_joint = self.brain_projector(
brain_representations.mean(dim=-1) # average over time
)
model_joint = self.model_projector(
model_representations.mean(dim=1) # average over sequence
)
# Compute CCA to find aligned directions
self.cca = self.fit_cca(brain_joint, model_joint)
# Extract steering directions (highly correlated components)
steering_directions = self.extract_steering_directions(
self.cca,
threshold_correlation=0.5
)
return steering_directions
def fit_cca(self, X_brain, X_model):
"""
Fit Canonical Correlation Analysis.
"""
from sklearn.cross_decomposition import CCA
cca = CCA(n_components=self.joint_dim)
cca.fit(X_brain, X_model)
return cca
def extract_steering_directions(self, cca, threshold=0.5):
"""
Extract model-space directions highly correlated with brain.
Returns directions in model hidden space that correspond to
reasoning-relevant brain patterns.
"""
# Get canonical correlations
correlations = cca.score(X_brain, X_model)
# Select high-correlation components
high_corr_indices = np.where(correlations > threshold)[0]
# Extract corresponding directions in model space
steering_directions = cca.x_weights_[high_corr_indices]
return steering_directions
class BrainGuidedSteering:
"""
Intervene on LLM representations at inference time.
Method: Shift hidden representations along brain-induced directions
to enhance reasoning performance.
Key insight: Small shifts (scaled by brain predictivity) improve
reasoning without damaging language capabilities.
"""
def __init__(
self,
steering_directions,
steering_scale=0.1,
intervention_layer=-1 # apply to last layer or specific layer
):
self.steering_directions = steering_directions
self.steering_scale = steering_scale
self.intervention_layer = intervention_layer
def apply_inference_steering(
self,
model,
input_ids,
reasoning_task_type
):
"""
Apply brain-guided steering during inference.
Args:
- model: LLM to enhance
- input_ids: input tokens
- reasoning_task_type: type of reasoning (deductive, etc.)
Returns:
- enhanced_output: steered model predictions
"""
# Get base model representations
with torch.no_grad():
base_outputs = model(input_ids, output_hidden_states=True)
base_hidden = base_outputs.hidden_states[self.intervention_layer]
# Select task-specific steering direction
steering_vector = self.select_steering_vector(reasoning_task_type)
# Apply steering intervention
steered_hidden = base_hidden + self.steering_scale * steering_vector
# Continue inference from steered representations
enhanced_output = model.forward_from_hidden(
steered_hidden,
intervention_layer=self.intervention_layer
)
return enhanced_output
def select_steering_vector(self, reasoning_task_type):
"""
Select steering direction specific to reasoning type.
Args:
- reasoning_task_type: 'deductive', 'inductive', etc.
Returns:
- steering_vector: direction in hidden space
"""
# Map reasoning type to brain activation pattern
type_to_direction = {
'deductive': self.steering_directions['deductive'],
'inductive': self.steering_directions['inductive'],
'abductive': self.steering_directions['abductive'],
'default': self.steering_directions.mean(axis=0)
}
steering_vector = type_to_direction.get(
reasoning_task_type,
type_to_direction['default']
)
return steering_vector
def adaptive_scale(self, confidence_score):
"""
Adaptively scale steering based on model confidence.
Key insight: Apply stronger steering when model is uncertain.
"""
# Inverse relationship: low confidence → strong steering
adaptive_scale = self.steering_scale * (1 - confidence_score)
return adaptive_scale
class BrainGuidedFineTuning:
"""
Fine-tune LLM using brain signals as additional supervision.
Method: Add neural-predictivity loss to standard language modeling loss.
Brain signals provide reasoning-specific guidance orthogonal to
language-only training.
"""
def __init__(
self,
model,
neural_predictivity_metric,
reasoning_tasks,
alpha=0.5 # brain guidance weight
):
self.model = model
self.neural_predictivity = neural_predictivity_metric
self.reasoning_tasks = reasoning_tasks
self.alpha = alpha
def fine_tune(
self,
train_dataset,
brain_dataset,
num_epochs=10,
lr=5e-5
):
"""
Fine-tune with brain signals.
Args:
- train_dataset: language data
- brain_dataset: task-fMRI data paired with reasoning tasks
Returns:
- fine_tuned_model: enhanced reasoning capability
"""
optimizer = torch.optim.AdamW(self.model.parameters(), lr=lr)
for epoch in range(num_epochs):
for language_batch, brain_batch in zip(train_dataset, brain_dataset):
# Standard language modeling loss
lm_loss = self.compute_lm_loss(language_batch)
# Brain-guided reasoning loss
brain_loss = self.compute_brain_guided_loss(brain_batch)
# Combined loss
total_loss = lm_loss + self.alpha * brain_loss
optimizer.zero_grad()
total_loss.backward()
optimizer.step()
def compute_brain_guided_loss(self, brain_batch):
"""
Compute loss from neural-predictivity alignment.
Key insight: Encourage model representations to predict
reasoning-region brain activity.
"""
# Get model representations
input_ids = brain_batch['input_ids']
outputs = self.model(input_ids, output_hidden_states=True)
hidden_states = outputs.hidden_states[-1]
# Get brain activity
brain_activity = brain_batch['fMRI']
reasoning_type = brain_batch['reasoning_type']
# Compute neural-predictivity
predictivity = self.neural_predictivity.compute_predictivity(
model_representations=hidden_states,
brain_activity=brain_activity,
aggregate=False,
reasoning_specific=True
)
# Loss: maximize predictivity in reasoning regions
# Use negative predictivity as loss (minimize)
brain_loss = -predictivity.mean()
return brain_loss
Finding 1: LLMs explain substantial variance in reasoning regions
Finding 2: Language vs. Reasoning dissociation in brain
| Model Size | Base Accuracy | Brain-Guided | Accuracy Gain |
|---|---|---|---|
| 1.5B | X% | Y% | +Z% |
| 7B | X% | Y% | +8% |
| 72B | X% | Y% | +13% |
Key Results:
10 LLMs Tested (1.5B to 72B parameters):
class BrainGuidedReasoningEnhancement:
"""
Complete pipeline for brain-guided LLM reasoning enhancement.
Usage:
1. Measure neural-predictivity in reasoning regions
2. Compute joint brain-model structure
3. Apply steering at inference or fine-tune during training
"""
def __init__(
self,
llm,
reasoning_roi_mask,
brain_encoder,
enhancement_mode='inference' # 'inference' or 'training'
):
self.llm = llm
self.reasoning_mask = reasoning_roi_mask
# Components
self.predictivity_metric = NeuralPredictivityMetric(
reasoning_regions=reasoning_roi_mask,
model_encoder=LLMEncoder(llm),
brain_encoder=brain_encoder
)
self.joint_analyzer = JointStructureAnalysis(
brain_dim=len(reasoning_roi_mask),
model_dim=llm.config.hidden_size
)
if enhancement_mode == 'inference':
self.enhancer = BrainGuidedSteering()
else:
self.enhancer = BrainGuidedFineTuning(llm, self.predictivity_metric)
def enhance_reasoning(
self,
reasoning_task,
brain_activity=None,
enhancement_mode='inference'
):
"""
Enhance LLM reasoning capability.
Args:
- reasoning_task: input tokens + reasoning type
- brain_activity: optional task-fMRI (if available)
- enhancement_mode: 'inference' (steering) or 'training' (fine-tune)
Returns:
- enhanced_output: improved reasoning predictions
"""
if brain_activity is not None:
# Compute neural-predictivity and steering directions
model_repr = self.llm.get_hidden_states(reasoning_task['input_ids'])
predictivity = self.predictivity_metric.compute_predictivity(
model_repr,
brain_activity
)
steering_directions = self.joint_analyzer.compute_joint_structure(
brain_activity,
model_repr
)
# Apply enhancement
if enhancement_mode == 'inference':
enhanced_output = self.enhancer.apply_inference_steering(
self.llm,
reasoning_task['input_ids'],
reasoning_task['reasoning_type']
)
else:
# Fine-tune with brain signals (requires training loop)
enhanced_output = self.enhancer.fine_tune_step(
reasoning_task,
brain_activity
)
return enhanced_output
# Reasoning-specific brain regions (based on meta-analysis)
REASONING_ROIS = {
'lateral_pfc': {
# Dorsolateral prefrontal cortex
'coordinates': [(45, 35, 30), (-45, 35, 30)], # MNI coords
'function': 'executive control, rule application'
},
'parietal_cortex': {
# Inferior parietal lobule
'coordinates': [(50, -50, 40), (-50, -50, 40)],
'function': 'logical inference, spatial reasoning'
},
'anterior_cingulate': {
# ACC for conflict monitoring
'coordinates': [(0, 30, 20)],
'function': 'error detection, uncertainty monitoring'
},
'temporal_parietal': {
# Temporoparietal junction
'coordinates': [(50, -55, 25), (-50, -55, 25)],
'function': 'belief reasoning, counterfactual thinking'
}
}
def create_reasoning_mask(atlas='Harvard-Oxford'):
"""
Create ROI mask for reasoning regions.
Args:
- atlas: brain atlas for voxel labeling
Returns:
- reasoning_mask: binary mask [voxels] for reasoning regions
"""
# Load atlas
atlas_img = nib.load(f'{atlas}_subcortical.nii.gz')
atlas_data = atlas_img.get_fdata()
# Extract reasoning region voxels
reasoning_mask = np.zeros(atlas_data.shape)
for region, specs in REASONING_ROIS.items():
for coord in specs['coordinates']:
# Find nearest voxels to coordinates
voxels = find_nearest_voxels(coord, atlas_data)
reasoning_mask[voxels] = 1
return reasoning_mask
@article{xiao2026brainguided,
title={Beyond Representational Alignment with Brain-Guided Language Models for Robust Reasoning},
author={Xiao, Mingqing and Du, Kai and Lin, Zhouchen},
journal={arXiv preprint arXiv:2606.11893},
year={2026}
}