菜单
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 当前展示的配套文件。
用 Codex 或 Claude 帮你安装 复制这段 Prompt，粘贴到 Codex、Claude 或其他助手里，让它检查 Skill 页面并帮你完成安装。
直接命令不会经过审查 Prompt；运行前请先检查来源。
npx skills add https://github.com/hiyenwong/ai_collection --skill brain-guided-llm-reasoning-alignment命令会保持在同一行。复制前请横向滚动并检查完整内容。
想先保存到本地？可下载 SkillsMP 当前能够提供的文件。
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.
基于 SOC 职业分类
正在显示 SKILL.md
| 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}
}