OSCR

E/I imbalance and internal noise cause weak neural representations and face recognition challenges in ASD.

Code ↔ Paper

4 matches between paragraphs of the paper and lines of its authors' code, computed by the harvester (lexical-v1). Click a colored paragraph or line to see its counterpart.

The 4 matches
  1. [1] § Methods › Training and testing procedures ↔ large-scale-cornet/src/models/cornet.py, lines 254–401 · score 0.79 · cross entropy loss, training epoch, Adam, optimizer, weights, loops
  2. [2] § Methods › General CNN model architecture ↔ large-scale-cornet/src/models/custom_layers.py, lines 11–35 · score 0.58 · standard deviation, Gaussian noise, ReLU, layer, activations, models
  3. [3] § Methods › General CNN model architecture ↔ large-scale-cornet/src/models/cornet.py, lines 162–251 · score 0.58 · dense Layer, ReLU, flattening, identity, dropout, architecture
  4. [4] § Results and discussions ↔ large-scale-cornet/src/models/custom_layers.py, lines 11–35 · score 0.54 · standard deviation, Gaussian noises, ReLU, internal noise, layers, activation

Paper

Loaded from Europe PMC by your browser, not stored by OSCR: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 401 lines · 15 KB · MIT · 2 matches

  1. # src/models/cornet_wrapper.py
  3. import torch
  4. import torch.nn as nn
  5. import cornet
  6. from torchvision import transforms
  8. class CornetWithPathology(nn.Module):
  9. """
  10. A wrapper around CORnet (Z/S) that injects ASD-like pathology
  11. (E/I Imbalance and Internal Noise) without retraining the weights.
  12. """
  13. def __init__(self, model_name='Z', slope=1.0, noise_std=0.0, device='cuda'):
  14. super().__init__()
  15. self.device = device
  16. self.slope = slope # Corresponds to slope_positive (E/I gain)
  17. self.noise_std = noise_std
  18. self.model_name = model_name
  20. print(f"Loading CORnet-{model_name} (Pre-trained on ImageNet)...")
  22. # 1. Load pretrained model
  23. # map_location ensures direct loading to GPU or CPU
  24. if model_name == 'Z':
  25. self.core_model = cornet.cornet_z(pretrained=True, map_location=device)
  26. elif model_name == 'S':
  27. self.core_model = cornet.cornet_s(pretrained=True, map_location=device)
  28. elif model_name == 'RT':
  29. self.core_model = cornet.cornet_rt(pretrained=True, map_location=device)
  30. else:
  31. raise ValueError("Model must be Z, S, or RT")
  33. # Unwrap once (works for DataParallel or not)
  34. self.base = self.core_model.module if isinstance(self.core_model, nn.DataParallel) else self.core_model
  36. # 2. Freeze all parameters (Freeze Backbone)
  37. # Key for reviewers: No retraining - we want to see pretrained brain's response under pathology
  38. for param in self.core_model.parameters():
  39. param.requires_grad = False
  41. self.core_model.eval() # Critical: Lock BatchNorm and Dropout
  42. self.core_model.to(device)
  44. # 3. Register Hooks (Key step for injecting E/I and Noise)
  45. self.hooks = []
  46. self._register_pathology_hooks()
  48. def _pathology_hook(self, module, input, output):
  49. """
  50. This function automatically executes after forward propagation of each layer.
  51. Output is the raw output features of that layer (e.g., V1, V2...).
  52. """
  53. # A. Simulate E/I Imbalance (Gain Modulation)
  54. # If slope > 1.0, simulate E > I (ASD)
  55. # If slope < 1.0, simulate I > E
  56. modulated_output = output * self.slope
  58. # B. Simulate Internal Noise
  59. # Inject Gaussian noise into neural activity
  60. if self.noise_std > 0:
  61. noise = torch.randn_like(modulated_output) * self.noise_std
  62. modulated_output = modulated_output + noise
  64. return modulated_output
  66. def _register_pathology_hooks(self):
  67. """
  68. Attach hooks to nonlinearity outputs (more faithful E/I manipulation)
  69. Hooks inject pathology AFTER nonlinear activation, simulating altered E/I balance
  70. """
  71. # CORblock_Z has .nonlin attribute for nonlinearity
  72. target_modules = [
  73. self.base.V1.nonlin,
  74. self.base.V2.nonlin,
  75. self.base.V4.nonlin,
  76. self.base.IT.nonlin,
  77. ]
  79. for mod in target_modules:
  80. # register_forward_hook allows us to modify outputs
  81. h = mod.register_forward_hook(self._pathology_hook)
  82. self.hooks.append(h)
  84. print(f"Pathology Injected (nonlin hooks): Slope={self.slope}, Noise={self.noise_std}")
  86. def forward(self, x):
  87. return self.core_model(x)
  89. def close(self):
  90. """Remove hooks and clean up memory"""
  91. for h in self.hooks:
  92. h.remove()
  94. # ==========================================
  95. # Utility Functions: Data Preprocessing
  96. # ==========================================
  97. def get_cornet_transforms():
  98. """
  99. CORnet requires standard ImageNet preprocessing
  100. """
  101. return transforms.Compose([
  102. transforms.Resize(256),
  103. transforms.CenterCrop(224),
  104. transforms.ToTensor(),
  105. transforms.Normalize(mean=[0.485, 0.456, 0.406], # ImageNet standard mean
  106. std=[0.229, 0.224, 0.225]) # ImageNet standard std
  107. ])
  109. # ==========================================
  110. # Main Function (Corresponds to original build_cnn)
  111. # ==========================================
  112. def extract_features(data_tensor, model_name='Z', slope=1.0, noise_level=0.0, device='cuda'):
  113. """
  114. Extract IT-layer features from a CORnet model with pathology injection.
  116. Uses a forward hook on the IT area to capture internal representations
  117. rather than the final decoder logits.
  119. Inputs:
  120. data_tensor: PyTorch Tensor [Batch, 3, Height, Width] (already normalized)
  121. model_name: 'Z' or 'S'
  122. slope: E/I ratio
  123. noise_level: Noise std
  125. Outputs:
  126. features: numpy array of IT layer output (flattened)
  127. """
  128. # 1. Build model
  129. model = CornetWithPathology(model_name, slope=slope, noise_std=noise_level, device=device)
  131. # 2. Register a hook on the IT area to capture its output
  132. it_features = {}
  134. def _capture_it(module, input, output):
  135. it_features['out'] = output.detach()
  137. hook = model.base.IT.register_forward_hook(_capture_it)
  139. # 3. Inference — run the full forward pass so pathology hooks also fire
  140. with torch.no_grad():
  141. if device == 'cuda':
  142. data_tensor = data_tensor.cuda()
  143. model(data_tensor)
  145. hook.remove()
  147. # 4. Flatten spatial dims: (B, C, H, W) -> (B, C*H*W)
  148. feat = it_features['out'].cpu()
  149. if feat.dim() > 2:
  150. feat = feat.flatten(1)
  152. # Cleanup
  153. model.close()
  155. return feat.numpy()
  158. # ==========================================
  159. # Post-Training Functions
  160. # ==========================================
  162. def build_cornet_for_training(
  163. num_classes,
  164. alpha=1.0,
  165. noise_std=0.0,
  166. freeze_backbone=False,
  167. pretrained=True,
  168. penultimate_dim=64,
  169. penultimate_dropout=0.5
  170. ):
  171. """
  172. Build CORnet for post-training with custom activation and penultimate dense head.
  174. Parameters:
  175. num_classes: number of output classes
  176. alpha: E/I gain modulation
  177. noise_std: internal noise level
  178. freeze_backbone: if True, only train decoder
  179. pretrained: use ImageNet pretrained weights
  180. penultimate_dim: dimension of penultimate dense layer (default 64, like Keras CNN)
  181. penultimate_dropout: dropout rate for penultimate layer
  183. Returns:
  184. Modified CORnet model ready for training
  185. """
  186. import cornet
  187. from collections import OrderedDict
  188. from .custom_layers import EIRectifiedLinear
  190. print(f"Building CORnet for training: alpha={alpha}, noise={noise_std}")
  192. # Load pretrained CORnet-Z
  193. model = cornet.cornet_z(pretrained=pretrained)
  195. # Handle DataParallel wrapper robustly
  196. actual_model = model.module if isinstance(model, nn.DataParallel) else model
  198. # Replace all ReLU and existing EIRectifiedLinear with updated alpha/noise
  199. def replace_nonlin(module):
  200. for name, child in module.named_children():
  201. # Replace ReLU
  202. if isinstance(child, nn.ReLU):
  203. setattr(module, name, EIRectifiedLinear(alpha, noise_std))
  204. # Also replace existing EIRectifiedLinear to ensure alpha/noise take effect
  205. elif child.__class__.__name__ == "EIRectifiedLinear":
  206. setattr(module, name, EIRectifiedLinear(alpha, noise_std))
  207. else:
  208. replace_nonlin(child)
  210. replace_nonlin(actual_model)
  212. # Rebuild decoder
  213. in_features = actual_model.decoder.linear.in_features # 512
  214. old_avgpool = actual_model.decoder.avgpool
  215. old_flatten = actual_model.decoder.flatten
  217. if penultimate_dim == 0:
  218. # Use original architecture: 512 -> num_classes
  219. actual_model.decoder = nn.Sequential(OrderedDict([
  220. ("avgpool", old_avgpool),
  221. ("flatten", old_flatten),
  222. ("linear", nn.Linear(in_features, num_classes)),
  223. ("output", nn.Identity()),
  224. ]))
  225. print(f"Decoder rebuilt: 512 -> {num_classes} classes (original architecture)")
  226. else:
  227. # Use custom architecture with penultimate layer: 512 -> penultimate_dim -> num_classes
  228. actual_model.decoder = nn.Sequential(OrderedDict([
  229. ("avgpool", old_avgpool),
  230. ("flatten", old_flatten),
  231. # Penultimate dense: 512 -> penultimate_dim (matches your Keras Dense(64, relu))
  232. ("penultimate_dense", nn.Linear(in_features, penultimate_dim)),
  233. ("penultimate_dense_relu", nn.ReLU(inplace=True)),
  234. ("penultimate_dense_drop", nn.Dropout(p=penultimate_dropout)),
  235. # Logits layer: penultimate_dim -> num_classes
  236. ("linear", nn.Linear(penultimate_dim, num_classes)),
  237. ("output", nn.Identity()),
  238. ]))
  239. print(f"Decoder rebuilt: 512 -> {penultimate_dim} (ReLU + Dropout) -> {num_classes} classes")
  241. # Optionally freeze backbone
  242. if freeze_backbone:
  243. print("Freezing backbone (V1-V4/IT), training decoder only")
  244. for name, param in actual_model.named_parameters():
  245. if not name.startswith("decoder."):
  246. param.requires_grad = False
  247. else:
  248. print("Training full model")
  250. # Return the unwrapped model (we'll handle device placement in training)
  251. return actual_model
  254. def train_cornet(model, train_loader, val_loader=None, test_loader=None, epochs=10, lr=1e-4,
  255. device='cuda', weight_decay=1e-3, use_augmentation=True):
  256. """
  257. Train CORnet model with Validation and Testing steps.
  259. Enhanced with data augmentation and regularization to prevent overfitting.
  261. Parameters:
  262. model: CORnet model
  263. train_loader: Training DataLoader
  264. val_loader: Validation DataLoader (Optional, evaluated every epoch)
  265. test_loader: Test DataLoader (Optional, evaluated once at the end)
  266. epochs: number of training epochs
  267. lr: learning rate
  268. device: 'cuda' or 'cpu'
  269. weight_decay: L2 regularization strength (default: 1e-3)
  270. use_augmentation: whether to apply data augmentation during training (default: True)
  272. Returns:
  273. tuple: (trained_model, history)
  274. """
  275. import torch.optim as optim
  276. import torch.nn as nn
  277. import torchvision.transforms as transforms
  279. try:
  280. from tqdm.auto import tqdm
  281. except ImportError:
  282. from tqdm import tqdm
  284. model.to(device)
  286. # Add weight decay for strong regularization to prevent memorization
  287. optimizer = optim.Adam(model.parameters(), lr=lr, weight_decay=weight_decay)
  288. criterion = nn.CrossEntropyLoss()
  290. # Define batch-level data augmentation
  291. # Applied on GPU for efficiency
  292. if use_augmentation:
  293. batch_augmenter = nn.Sequential(
  294. transforms.RandomHorizontalFlip(p=0.5),
  295. transforms.RandomAffine(
  296. degrees=10, # Random rotation ±10 degrees
  297. translate=(0.1, 0.1), # Random translation ±10%
  298. scale=(0.9, 1.1) # Random zoom 90-110%
  299. ),
  300. transforms.ColorJitter(
  301. brightness=0.2, # Random brightness ±20%
  302. contrast=0.2, # Random contrast ±20%
  303. saturation=0.1, # Random saturation ±10%
  304. hue=0.05 # Random hue shift ±5%
  305. )
  306. ).to(device)
  307. print(f"Training with augmentation enabled (weight_decay={weight_decay})")
  308. else:
  309. batch_augmenter = None
  310. print(f"Training without augmentation (weight_decay={weight_decay})")
  312. # Initialize history with separate keys for train and val
  313. history = {
  314. 'train_loss': [], 'train_acc': [],
  315. 'val_loss': [], 'val_acc': []
  316. }
  318. print(f"Starting training for {epochs} epochs on {device}...")
  320. # Helper function for Evaluation
  321. def evaluate_pass(loader, description="Evaluating"):
  322. model.eval()
  323. running_loss = 0.0
  324. correct = 0
  325. total = 0
  327. with torch.no_grad():
  328. for images, labels, _ in loader:
  329. images, labels = images.to(device), labels.to(device)
  330. outputs = model(images)
  331. loss = criterion(outputs, labels)
  333. running_loss += loss.item()
  334. _, predicted = outputs.max(1)
  335. total += labels.size(0)
  336. correct += predicted.eq(labels).sum().item()
  338. avg_loss = running_loss / len(loader)
  339. avg_acc = 100. * correct / total
  340. return avg_loss, avg_acc
  342. # Main Training Loop
  343. for epoch in range(epochs):
  344. model.train()
  345. running_loss = 0.0
  346. correct = 0
  347. total = 0
  349. # Training Pass
  350. pbar = tqdm(train_loader, desc=f"Epoch {epoch+1}/{epochs}", leave=False)
  351. for images, labels, _ in pbar:
  352. images, labels = images.to(device), labels.to(device)
  354. # Apply data augmentation during training (no gradient computation needed)
  355. if use_augmentation and batch_augmenter is not None:
  356. with torch.no_grad():
  357. images = batch_augmenter(images)
  359. optimizer.zero_grad()
  360. outputs = model(images)
  361. loss = criterion(outputs, labels)
  362. loss.backward()
  363. optimizer.step()
  365. running_loss += loss.item()
  366. _, predicted = outputs.max(1)
  367. total += labels.size(0)
  368. correct += predicted.eq(labels).sum().item()
  370. pbar.set_postfix({'Loss': f'{running_loss/total:.4f}',
  371. 'Acc': f'{100.*correct/total:.1f}%'})
  373. # Calculate Train Metrics
  374. train_loss = running_loss / len(train_loader)
  375. train_acc = 100. * correct / total
  376. history['train_loss'].append(train_loss)
  377. history['train_acc'].append(train_acc)
  379. # Validation Pass (If val_loader provided)
  380. val_str = ""
  381. if val_loader:
  382. val_loss, val_acc = evaluate_pass(val_loader, description="Validating")
  383. history['val_loss'].append(val_loss)
  384. history['val_acc'].append(val_acc)
  385. val_str = f" | Val Loss: {val_loss:.4f} | Val Acc: {val_acc:.2f}%"
  387. print(f"Epoch {epoch+1}: Train Loss: {train_loss:.4f} | Train Acc: {train_acc:.2f}%{val_str}")
  389. # Final Test Pass (After all epochs)
  390. if test_loader:
  391. print("\nRunning Final Test Set Evaluation...")
  392. test_loss, test_acc = evaluate_pass(test_loader, description="Testing")
  393. print("="*60)
  394. print(f"FINAL TEST RESULT: Accuracy = {test_acc:.2f}% | Loss = {test_loss:.4f}")
  395. print("="*60)
  397. history['final_test_acc'] = test_acc
  398. history['final_test_loss'] = test_loss
  400. print("Training complete")
  401. return model, history

cornet.py at commit f768ce1, under MIT · at the source

Overview

Authors: Xijing Wang1, Emily Rios2, Lang Chen2,3
ORCID iDs: Xijing Wang, Lang Chen
  1. Mathematics and Computer Science, Santa Clara University, Santa Clara, CA USA
  2. Neuroscience Program, Santa Clara University, Santa Clara, CA USA
  3. Psychology, Santa Clara University, Santa Clara, CA USA
Institutions: Santa Clara University (United States)
Journal: Communications biology, volume 9, issue 1, article 872
Dates: received 9 April 2025; accepted 9 April 2026; published online 24 April 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s42003-026-10094-2 · PMID 42031948 · PMCID PMC13316099 · OpenAlex W7155534404
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: computational modeling (no new data) (modality), human (organism), autism (population)
Methods: Connectivity, Machine learning
Keywords: Cognitive neuroscience, Autism spectrum disorders, Network models
MeSH: Autism Spectrum Disorder*, Facial Recognition*, Convolutional Neural Networks, Female, Humans, Male (* major topic)
Topic: Autism Spectrum Disorder Research (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: not cited yet (Europe PMC); 91 references in the paper

Abstract

The abstract is not reproduced here: the paper's license (CC BY-NC-ND) does not allow it. Read it in the paper, at the publisher or on Europe PMC.

Repository

Its files are read in the Code ↔ Paper reader above, with 4 matches between paragraphs and lines of code.

xthomaswang/ASD_FaceReg_Modeling_CNN

License: MIT
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: f768ce15ace9b82e24d52ca7afe632ebfbc56d50, 30 April 2026
Languages: Python (20), Jupyter (9), R (8)
Size: 1,808 files, 37 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, CITATION.cff, environment (large-scale-cornet/requirements.txt, small-scale-custom-cnn/requirements.txt), documentation, 9 notebooks
Not found: tests, continuous integration
Tools: ggplot2 (8 files), NumPy (8 files), rstatix (8 files), ggpubr (7 files), PyTorch (6 files), reshape2 (6 files), Matplotlib (4 files), pandas (4 files), seaborn (4 files), tidyverse (4 files), Pillow (2 files), scikit-learn (2 files), SciPy (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
29 files
At the source: github.com/xthomaswang/ASD_FaceReg_Modeling_CNN

Code availability statement

The paper has a code availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s42003-026-10094-2.

Tracing map

Proposed by the machine: these links were found in the paper and verified at the source, without human review. The map will receive a Zenodo DOI once one of the paper's authors has validated it with their ORCID.

What the map holds:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 27 scripts, each with its path and the digest of its content;
  • 4 matches between paragraphs of the paper and lines of the code (method lexical-v1);
  • neither the text of the paper nor the code itself.

Its JSON (tracing-map.json) is deposited on Zenodo with its DOI once the map is validated.

Data

No dataset and no data link were found in the paper.

Code and data availability statement

The paper has a code and data availability statement. Its license (CC BY-NC-ND) does not allow reproducing it here; in short, from what the harvester recognized in it:

Read it in the paper: doi.org/10.1038/s42003-026-10094-2.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 30 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 3 authors, 3 keywords, 6 MeSH terms, 82 references.

Cite

This paper

Wang, X., Rios, E., & Chen, L. (2026). E/I imbalance and internal noise cause weak neural representations and face recognition challenges in ASD. Communications biology, 9(1), 872. https://doi.org/10.1038/s42003-026-10094-2

BibTeX

@article{wang2026e,
author = {Wang, Xijing and Rios, Emily and Chen, Lang},
title = {{E/I imbalance and internal noise cause weak neural representations and face recognition challenges in ASD}},
journal = {Communications biology},
year = {2026},
month = apr,
volume = {9},
number = {1},
pages = {872},
publisher = {Nature Publishing Group},
issn = {2399-3642},
doi = {10.1038/s42003-026-10094-2},
url = {https://doi.org/10.1038/s42003-026-10094-2},
pmid = {42031948},
pmcid = {PMC13316099}
}

RIS

TY - JOUR
AU - Wang, Xijing
AU - Rios, Emily
AU - Chen, Lang
TI - E/I imbalance and internal noise cause weak neural representations and face recognition challenges in ASD
T2 - Communications biology
J2 - Commun Biol
PY - 2026
DA - 2026/04/24
VL - 9
IS - 1
SP - 872
SN - 2399-3642
PB - Nature Publishing Group
DO - 10.1038/s42003-026-10094-2
UR - https://doi.org/10.1038/s42003-026-10094-2
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s42003-026-10094-2",
"type": "article-journal",
"title": "E/I imbalance and internal noise cause weak neural representations and face recognition challenges in ASD",
"container-title": "Communications biology",
"author": [
{
"family": "Wang",
"given": "Xijing"
},
{
"family": "Rios",
"given": "Emily"
},
{
"family": "Chen",
"given": "Lang"
}
],
"container-title-short": "Commun Biol",
"volume": "9",
"issue": "1",
"page": "872",
"DOI": "10.1038/s42003-026-10094-2",
"PMID": "42031948",
"PMCID": "PMC13316099",
"ISSN": "2399-3642",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s42003-026-10094-2",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
24
]
]
}
}

The tracing map gets a citation of its own once an author has validated it and it has a DOI.

Similar papers

The papers with a page that share the most with this one: the tools found in their code, their categories, datasets, cited references and authors, the rarest counting most.

[1] doi:10.1038/s41467-026-76098-y [code]
A single computational objective can produce specialization of streams in visual cortex.
Journal: Nature communications
In common: Pillow, PyTorch, seaborn, 5 other tools, 5 references
[2] doi:10.1126/sciadv.aec9291 [code]
Computational mechanisms of perception in autism revealed using games inspired by rodent operant tasks.
Journal: Science advances
In common: rstatix, reshape2, ggpubr, 2 other tools, autism, 4 references
[3] doi:10.1186/s13059-026-04177-w [code]
Genomic sequence evolution underlying human neocortical interareal diversification.
Journal: Genome biology
In common: rstatix, reshape2, ggpubr, 9 other tools
[4] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: Pillow, PyTorch, seaborn, 5 other tools, 4 references
[5] doi:10.1002/imt2.70163 [code]
Spatial multi-omics unveils sphingolipid metabolic reprogramming within the retinal pathological niche.
Journal: iMeta
In common: rstatix, reshape2, ggpubr, 9 other tools
[6] doi:10.1038/s42003-026-10169-0 [code]
Shared representations in brains and models reveal a two-route cortical organization during scene perception.
Journal: Communications biology
In common: Pillow, PyTorch, seaborn, 5 other tools, 4 references
[7] doi:10.1038/s41467-026-76675-1 [code]
Long-read proteogenomic atlas of human neuronal differentiation reveals isoform diversity informing neurodevelopmental risk mechanisms.
Journal: Nature communications
In common: rstatix, reshape2, ggpubr, 8 other tools, autism
[8] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: reshape2, ggpubr, Pillow, 9 other tools
[9] doi:10.1038/s41592-026-03194-8 [code]
Beyond benchmarking: an expert-guided consensus approach to spatially aware clustering.
Journal: Nature methods
In common: reshape2, ggpubr, Pillow, 9 other tools
[10] doi:10.1186/s13229-026-00730-3 [code]
Predicting emotional valence in autism: a preregistered study in the Bayesian Brain framework.
Journal: Molecular autism
In common: rstatix, reshape2, ggpubr, 6 other tools, autism, 1 reference

Contribute

The authors of this paper can claim it, correct its record and validate its tracing map, and the maintainers of its code (its owner, or a public member of its organization) correct what it says of their repository; anyone signed in can ask for its removal. Every request goes to OSCR's own machine, which answers it; your account page follows them.

Sign in with ORCID to claim this paper as one of its authors, correct its record or validate its tracing map: when the paper's metadata lists your ORCID iD, you are recognized at once. Maintainers of its code: sign in with GitHub, then claim the repository on your account page.

Request its removal

To ask OSCR to remove this record, the copies of its authors' scripts or its tracing map, use the removal request page: signed in, you say who you are, what to remove and why, then review and confirm the request. Published rules decide every request (how).

Discussion, reproductions, activity

Discussion: questions and error reports about this paper and its code, from signed-in readers and its authors. It opens with sign-in.

Reproductions: reports from readers who ran the authors' code: what they reproduced, with which environment, commit and data. It opens with sign-in.

Activity: what happens around this paper: new versions of its record, its map's validation, discussions and reproductions. It opens with sign-in.