OSCR

Larger language models better align with neural representations of natural language.

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] § Materials and methods › Contextual embeddings ↔ scripts/tfsemb_download.py, lines 1 to 45 · score 0.79 · gpt2 xl, GPT Neox, EleutherAI, OPT, models · Report a mismatch
  2. [2] § Materials and methods › Encoding models ↔ scripts/tfsenc_encoding.py, lines 148 to 195 · score 0.69 · RidgeCV, himalaya, alpha, OLS, fitting, PCA · Report a mismatch
  3. [3] § Results ↔ scripts/tfsemb_download.py, lines 1 to 45 · score 0.60 · gpt neox, MEDIUM, OPT, XL, model · Report a mismatch
  4. [4] § Materials and methods › Contextual embeddings ↔ scripts/tfsenc_config.py, lines 39 to 57 · score 0.60 · EleutherAI, GPT Neo, language model · Report a mismatch

Paper

Loaded from Europe PMC by your browser; OSCR does not store it: doi.org · Europe PMC

The paper is loaded when this pane is shown.

The authors' code

Python · 269 lines · 7.4 KB · no license · 2 matches

  1. import os
  3. from transformers import (
  4. AutoConfig,
  5. AutoModel,
  6. AutoModelForCausalLM,
  7. AutoModelForMaskedLM,
  8. AutoModelForSeq2SeqLM,
  9. AutoTokenizer,
  10. )
  12. CAUSAL_MODELS = [
  13. "gpt2",
  14. "gpt2-large",
  15. "gpt2-xl",
  16. "EleutherAI/gpt-neo-125M",
  17. "EleutherAI/gpt-neo-1.3B",
  18. "EleutherAI/gpt-neo-2.7B",
  19. "EleutherAI/gpt-neox-20b",
  20. "facebook/opt-125m",
  21. "facebook/opt-350m",
  22. "facebook/opt-1.3b",
  23. "facebook/opt-2.7b",
  24. "facebook/opt-6.7b",
  25. "facebook/opt-30b",
  26. "bigscience/bloom",
  27. ]
  28. SEQ2SEQ_MODELS = ["facebook/blenderbot_small-90M", "facebook/blenderbot-3B"]
  30. MLM_MODELS = [
  31. # "gpt2-xl", # uncomment to run this model with MLM input
  32. # "gpt2-medium", # uncomment to run this model with MLM input
  33. "bert-base-uncased",
  34. "bert-large-uncased",
  35. "bert-base-cased",
  36. "bert-large-cased",
  37. "roberta-base",
  38. "roberta-large",
  39. ]
  41. MODEL_CLASS_MAP = {
  42. "causal": (CAUSAL_MODELS, AutoModelForCausalLM),
  43. "seq2seq": (SEQ2SEQ_MODELS, AutoModelForSeq2SeqLM),
  44. "mlm": (MLM_MODELS, AutoModelForMaskedLM),
  45. }
  48. def clean_lm_model_name(item):
  49. """Remove unnecessary parts from the language model name.
  51. Args:
  52. item (str/list): full model name from HF Hub
  54. Returns:
  55. (str/list): pretty model name
  57. Example:
  58. clean_lm_model_name(EleutherAI/gpt-neo-1.3B) == 'gpt-neo-1.3B'
  59. """
  60. if isinstance(item, str):
  61. return item.split("/")[-1]
  63. if isinstance(item, list):
  64. return [clean_lm_model_name(i) for i in item]
  66. print("Invalid input. Please check.")
  69. def get_max_context_length(model_name, tokenizer_class=None):
  70. """Return maximum possible context length for the model/tokenizer
  72. Args:
  73. model_name (str): Model name as seen on https://hugginface.co/models.
  74. tokenizer_class (Tokenizer, optional):
  75. Tokenizer class to be instantiated for the model.
  76. Defaults to None.
  78. Returns:
  79. int: Maximum allowed context for the model/tokenizer
  80. """
  81. tokenizer = download_hf_tokenizer(
  82. model_name,
  83. tokenizer_class=tokenizer_class,
  84. cache_dir=None,
  85. local_files_only=False,
  86. )
  88. return tokenizer.max_len_single_sentence
  91. def get_model_num_layers(model_name):
  92. """Return number of hidden layers in the model
  94. Args:
  95. model_name (str): Model name as seen on https://hugginface.co/models.
  97. Returns:
  98. int: value of {n_layer|num_layers|num_hidden_layers} attribute
  99. """
  100. config = AutoConfig.from_pretrained(model_name)
  101. num_layers = getattr(
  102. config,
  103. "n_layer",
  104. getattr(
  105. config,
  106. "num_layers",
  107. getattr(config, "num_hidden_layers", None),
  108. ),
  109. )
  111. if not num_layers:
  112. print(f"{model_name} has no hidden layers")
  113. exit()
  115. return num_layers
  118. def download_hf_model(
  119. model_name, model_class=None, cache_dir=None, local_files_only=False
  120. ):
  121. """Download a Huggingface model from the model repository (cache)."""
  122. if model_class is None:
  123. model_class = AutoModel
  125. if cache_dir is None:
  126. cache_dir = set_cache_dir()
  128. model = model_class.from_pretrained(
  129. model_name,
  130. output_hidden_states=True,
  131. cache_dir=cache_dir,
  132. local_files_only=local_files_only,
  133. )
  135. return model
  138. def download_hf_tokenizer(
  139. model_name, tokenizer_class=None, cache_dir=None, local_files_only=False
  140. ):
  141. """Download a Huggingface tokenizer from the model repository (cache)."""
  142. if tokenizer_class is None:
  143. tokenizer_class = AutoTokenizer
  145. if cache_dir is None:
  146. cache_dir = set_cache_dir()
  148. tokenizer = tokenizer_class.from_pretrained(
  149. model_name,
  150. add_prefix_space=True,
  151. cache_dir=cache_dir,
  152. local_files_only=local_files_only,
  153. )
  155. return tokenizer
  158. def download_tokenizer_and_model(
  159. CACHE_DIR, tokenizer_class, model_class, model_name, local_files_only
  160. ):
  161. """Cache (or load) the model and tokenizer from the model repository (or cache).
  163. Args:
  164. CACHE_DIR (str): path where the model and tokenizer will be cached.
  165. tokenizer_class (Tokenizer): Tokenizer class to be instantiated for the model.
  166. model_class (Huggingface Model): Model class corresponding to model_name.
  167. model_name (str): Model name as seen on https://hugginface.co/models.
  168. local_files_only (bool, optional): False (Default) if caching.
  169. True if loading from cache.
  171. Returns:
  172. tuple: (tokenizer, model)
  173. """
  174. print("Downloading model")
  175. model = download_hf_model(model_name, model_class, CACHE_DIR, local_files_only)
  177. print("Downloading tokenizer")
  178. tokenizer = download_hf_tokenizer(
  179. model_name, tokenizer_class, CACHE_DIR, local_files_only
  180. )
  182. return (model, tokenizer)
  185. def set_cache_dir():
  186. CACHE_DIR = os.path.join(os.path.dirname(os.getcwd()), ".cache")
  187. os.makedirs(CACHE_DIR, exist_ok=True)
  188. return CACHE_DIR
  191. def get_models_and_class(model_name):
  192. """Return the appropriate model class and model to download
  193. Args:
  194. model_name (str): Model name as seen on https://hugginface.co/models.
  196. Returns:
  197. models (list): model name or models in the same class
  198. mod_class (Huggingface Model): Model class corresponding to model_name.
  200. """
  201. models, mod_class = None, None
  202. for model_key, (model_list, model_class) in MODEL_CLASS_MAP.items():
  203. if model_name == model_key:
  204. models, mod_class = model_list, model_class
  205. break
  206. elif model_name in model_list:
  207. models, mod_class = [model_name], model_class
  208. break
  209. else:
  210. continue
  212. if not models or not model_class:
  213. print("Invalid Model List or Model Class")
  215. return models, mod_class
  218. def download_tokenizers_and_models(model_name=None, local_files_only=False, debug=True):
  219. """This function downloads the tokenizer and model for the specified model name.
  221. Args:
  222. model_name (str, optional): Model name as seen on https://hugginface.co/models.
  223. Defaults to None.
  224. local_files_only (bool, optional): False (Default) if caching.
  225. True if loading from cache.
  226. debug (bool, optional): Check if caching was successful. Defaults to True.
  228. Returns:
  229. dict: Dictionary with model name as key and (tokenizer, model) as value.
  230. """
  231. CACHE_DIR = set_cache_dir()
  233. if model_name is None:
  234. print("Input argument cannot be empty")
  235. return
  237. models, model_class = get_models_and_class(model_name)
  239. model_dict = {}
  240. for model_name in models:
  241. print(f"Model Name: {model_name}")
  243. model_dict[model_name] = download_tokenizer_and_model(
  244. CACHE_DIR,
  245. AutoTokenizer,
  246. model_class,
  247. model_name,
  248. local_files_only,
  249. )
  251. # check if caching was successful
  252. if debug:
  253. print("Checking if model has been cached successfully")
  254. try:
  255. download_tokenizer_and_model(
  256. CACHE_DIR,
  257. AutoTokenizer,
  258. model_class,
  259. model_name,
  260. True,
  261. )
  262. except:
  263. print(f"Caching of {model_name} failed")
  265. return model_dict
  268. if __name__ == "__main__":
  269. download_tokenizers_and_models("causal", local_files_only=False, debug=True)

tfsemb_download.py at commit b7a6fcb, no license · at the source

Overview

Authors: Zhuoqiao Hong1, Haocheng Wang1, Zaid Zada1, Harshvardhan Gazula2, David Turner1, Bobbi Aubrey1, Leonard Niekerken1, Werner Doyle3, Sasha Devore3, Patricia Dugan3, Daniel Friedman3, Orrin Devinsky3, Adeen Flinker3, Uri Hasson1, Samuel Nastase1, Ariel Y Goldstein4
ORCID iDs: Haocheng Wang, Adeen Flinker, Samuel Nastase
  1. Department of Psychology and the Neuroscience Institute, Princeton University, Princeton, United States
  2. McGovern Institute for Brain Research, Massachusetts Institute of Technology, Cambridge, United States
  3. New York University Grossman School of Medicine, New York, United States
  4. Business School, Data Science Department and Cognitive Science Department, Hebrew University, Jerusalem, Israel
Institutions: Princeton University (United States); McGovern Institute for Brain Research (United States); Massachusetts Institute of Technology (United States); New York University (United States); Hebrew University of Jerusalem (Israel)
Journal: eLife, volume 13, article RP101204
Dates: published online 16 September 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.7554/elife.101204 · PMID 42746838 · PMCID PMC13581289 · OpenAlex W4403650892
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: intracranial EEG (iEEG / ECoG / SEEG) (modality), human (organism)
Methods: Connectivity, Statistics, Smoothing, state filtering, decompositions, Machine learning, Preprocessing, Spectral & time-frequency
Keywords: Human
MeSH: Brain*, Language*, Large Language Models*, Natural Language Processing*, Electrocorticography, Humans (* major topic)
Topic: Topic Modeling (Artificial Intelligence, Computer Science), according to OpenAlex
Funding: NIDCD NIH HHS (R01 DC022534); NIH HHS (DP1HD091948, R01NS109367, R01DC022534); NINDS NIH HHS (R01 NS109367); NICHD NIH HHS (DP1 HD091948)
Citations: not cited yet (Europe PMC); 54 references in the paper

Abstract

Recent research has used large language models (LLMs) to study the neural basis of naturalistic language processing in the human brain. LLMs have rapidly grown in complexity, leading to improved language processing capabilities. Here, we utilized several families of transformer-based LLMs to investigate the relationship between model size and their ability to capture linguistic information in the human brain. Crucially, a subset of LLMs were trained on a fixed training set, enabling us to dissociate model size from architecture and training set size. We used electrocorticography (ECoG) to measure neural activity in epilepsy patients while they listened to a 30 min naturalistic audio story. We fit electrode-wise encoding models using contextual embeddings extracted from each hidden layer of the LLMs to predict word-level neural signals. In line with prior work, we found that larger LLMs better capture the structure of natural language and better predict neural activity. We also found a logarithmic relationship where the encoding performance peaks in relatively earlier layers as model size increases. We also observed variations in the best-performing layer across different brain regions, corresponding to an organized language processing hierarchy.

Reproduced under the paper's license (CC BY), from the paper cited above.

Repositories

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

hassonlab/247-pickling

License: none: the authors keep all their rights
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: b7a6fcb060ecb8276b5dcb090b97e6f5b2983558, 1 March 2023
Languages: Python (15), Jupyter (1), Shell (1)
Size: 23 files, 17 scripts
Software Heritage: archived
Found in: “Data availability”
Holds: README, tests, 1 notebook
Not found: license file, CITATION.cff, environment file, continuous integration, documentation
Tools: NumPy (8 files), pandas (6 files), PyTorch (3 files), Hugging Face Transformers (3 files), SciPy (2 files), scikit-learn (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
18 files
At the source: github.com/hassonlab/247-pickling/tree/scaling-paper-1

hassonlab/247-encoding

License: MIT
State: the link answers, verified on 26 September 2026
Evidence: files inventoried
Commit: 48c27e61a9fd8629d3f5da840d9f1ec2882a365f, 4 September 2026
Languages: Python (8), Shell (1)
Size: 25 files, 9 scripts
Software Heritage: archived
Found in: the references
Holds: README, license file
Not found: CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (6 files), pandas (5 files), scikit-learn (3 files), PyTorch (2 files), SciPy (2 files), Numba (1 file)
Availability: 1 check, the latest on 26 September 2026: the link answers
  • 26 September 2026: the link answers
11 files
At the source: archive.softwareheritage.org/swh:1:dir:f049da571e3cbb9e7315afb70898cb075b631e0d;origin=https://github.com/hassonlab/247-encoding;visit=swh:1:snp:2d491c93ce7bd00d3d21cffe9a66b1c171bb647d;anchor=swh:1:rev:48c27e61a9fd8629d3f5da840d9f1ec2882a365f

The paper's code and data availability statement is in the Data section.

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:

  • 2 repositories of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 26 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

Datasets cited

Data availability

We have recently made the data publicly available (Zada et al., 2025). We have also provided tutorials for preprocessing the data and training encoding models: https://hassonlab.github.io/podcast-ecog-tutorials. For this specific project, the analysis code is available at https://github.com/hassonlab/247-pickling/tree/scaling-paper-1 (copy archived at Kokaja et al., 2026) and https://github.com/hassonlab/247-encoding/tree/scaling-paper-2 (copy archived at Wang, 2026).

The following previously published dataset was used:

Zada Z, Nastase SA, Aubrey B, Jalon I, Goldstein A, Michelmann S, Wang H, Hasenfratz L, Doyle W, Friedman D, Dugan P, Melloni L, Devore S, Devinsky O, Flinker A, Hasson U. 2025. The "Podcast" ECoG dataset. OpenNeuro.

Reproduced under the paper's license (CC BY), from the paper cited above.

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, 27 September 2026: the first record

Recorded: type, language, journal, volume, pages, dates, 16 authors, 1 keyword, 6 MeSH terms, 4 funders, 32 references.

Cite

This paper

Hong, Z., Wang, H., Zada, Z., Gazula, H., Turner, D., Aubrey, B., Niekerken, L., Doyle, W., Devore, S., Dugan, P., Friedman, D., Devinsky, O., Flinker, A., Hasson, U., Nastase, S., & Goldstein, A. Y. (2026). Larger language models better align with neural representations of natural language. eLife, 13, RP101204. https://doi.org/10.7554/elife.101204

BibTeX

@article{hong2026larger,
author = {Hong, Zhuoqiao and Wang, Haocheng and Zada, Zaid and Gazula, Harshvardhan and Turner, David and Aubrey, Bobbi and Niekerken, Leonard and Doyle, Werner and Devore, Sasha and Dugan, Patricia and Friedman, Daniel and Devinsky, Orrin and Flinker, Adeen and Hasson, Uri and Nastase, Samuel and Goldstein, Ariel Y},
title = {{Larger language models better align with neural representations of natural language}},
journal = {eLife},
year = {2026},
month = sep,
volume = {13},
pages = {RP101204},
publisher = {eLife Sciences Publications, Ltd},
issn = {2050-084X},
doi = {10.7554/elife.101204},
url = {https://doi.org/10.7554/elife.101204},
pmid = {42746838},
pmcid = {PMC13581289}
}

RIS

TY - JOUR
AU - Hong, Zhuoqiao
AU - Wang, Haocheng
AU - Zada, Zaid
AU - Gazula, Harshvardhan
AU - Turner, David
AU - Aubrey, Bobbi
AU - Niekerken, Leonard
AU - Doyle, Werner
AU - Devore, Sasha
AU - Dugan, Patricia
AU - Friedman, Daniel
AU - Devinsky, Orrin
AU - Flinker, Adeen
AU - Hasson, Uri
AU - Nastase, Samuel
AU - Goldstein, Ariel Y
TI - Larger language models better align with neural representations of natural language
T2 - eLife
J2 - eLife
PY - 2026
DA - 2026/09/16
VL - 13
SP - RP101204
SN - 2050-084X
PB - eLife Sciences Publications, Ltd
DO - 10.7554/elife.101204
UR - https://doi.org/10.7554/elife.101204
LA - en
ER -

CSL-JSON

{
"id": "10.7554/elife.101204",
"type": "article-journal",
"title": "Larger language models better align with neural representations of natural language",
"container-title": "eLife",
"author": [
{
"family": "Hong",
"given": "Zhuoqiao"
},
{
"family": "Wang",
"given": "Haocheng"
},
{
"family": "Zada",
"given": "Zaid"
},
{
"family": "Gazula",
"given": "Harshvardhan"
},
{
"family": "Turner",
"given": "David"
},
{
"family": "Aubrey",
"given": "Bobbi"
},
{
"family": "Niekerken",
"given": "Leonard"
},
{
"family": "Doyle",
"given": "Werner"
},
{
"family": "Devore",
"given": "Sasha"
},
{
"family": "Dugan",
"given": "Patricia"
},
{
"family": "Friedman",
"given": "Daniel"
},
{
"family": "Devinsky",
"given": "Orrin"
},
{
"family": "Flinker",
"given": "Adeen"
},
{
"family": "Hasson",
"given": "Uri"
},
{
"family": "Nastase",
"given": "Samuel"
},
{
"family": "Goldstein",
"given": "Ariel Y"
}
],
"container-title-short": "eLife",
"volume": "13",
"page": "RP101204",
"DOI": "10.7554/elife.101204",
"PMID": "42746838",
"PMCID": "PMC13581289",
"ISSN": "2050-084X",
"publisher": "eLife Sciences Publications, Ltd",
"URL": "https://doi.org/10.7554/elife.101204",
"language": "en",
"issued": {
"date-parts": [
[
2026,
9,
16
]
]
}
}

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-024-46631-y [code]
Alignment of brain embeddings and artificial contextual embeddings in natural language points to common geometric patterns.
Journal: Nature communications
In common: scikit-learn, pandas, SciPy, 1 other tool, 11 references, 3 authors
[2] doi:10.1038/s41597-025-05462-2 [code]
The "Podcast" ECoG dataset for modeling neural activity during natural language comprehension.
Journal: Scientific data
In common: PyTorch, scikit-learn, pandas, 2 other tools, hassonlab.github.io/podcast-ecog-tutorials, intracranial EEG (iEEG / ECoG / SEEG), 9 references, 2 authors
[3] doi:10.1038/s41562-025-02105-9 [code]
A unified acoustic-to-speech-to-language embedding space captures the neural basis of natural language processing in everyday conversations.
Journal: Nature human behaviour
In common: Hugging Face Transformers, Numba, PyTorch, 4 other tools, intracranial EEG (iEEG / ECoG / SEEG), 5 references, 3 authors
[4] doi:10.1038/s41467-024-49173-5 [code]
Shared functional specialization in transformer-based language models and the human brain.
Journal: Nature communications
In common: Hugging Face Transformers, PyTorch, scikit-learn, 3 other tools, 12 references, author Samuel Nastase
[5] doi:10.1038/s41467-025-65518-0 [code]
Temporal structure of natural language processing in the human brain corresponds to layered hierarchy of large language models.
Journal: Nature communications
In common: Hugging Face Transformers, Numba, PyTorch, 4 other tools, intracranial EEG (iEEG / ECoG / SEEG), 7 references, 2 authors
[6] doi:10.7554/elife.106543 [code]
Stimulus dependencies-rather than next-word prediction-can explain pre-onset brain encoding in naturalistic listening designs.
Journal: eLife
In common: Hugging Face Transformers, PyTorch, scikit-learn, 3 other tools, 7 references
[7] doi:10.1162/nol_a_00116 [code]
Lexical-Semantic Content, Not Syntactic Structure, Is the Main Contributor to ANN-Brain Similarity of fMRI Responses in the Language Network.
Journal: Neurobiology of language (Cambridge, Mass.)
In common: Hugging Face Transformers, PyTorch, scikit-learn, 3 other tools, 6 references
[8] doi:10.1038/s43588-025-00863-0 [code]
Increasing alignment of large language models with language processing in the human brain.
Journal: Nature computational science
In common: Hugging Face Transformers, PyTorch, scikit-learn, 3 other tools, 6 references
[9] doi:10.1038/s42003-025-09377-x [code]
Hierarchical linguistic predictions and cross-level information updating during narrative comprehension.
Journal: Communications biology
In common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, 3 references, author Adeen Flinker
[10] doi:10.1162/imag.a.1227 [code]
Large language models reveal the neural tracking of linguistic context in attended and unattended multi-talker speech.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Hugging Face Transformers, PyTorch, scikit-learn, 3 other tools, intracranial EEG (iEEG / ECoG / SEEG), 5 references

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.

Add the badge to the code's README

OSCR: the badge of this paper

If you are an author or a maintainer of this paper's code, you can add this badge. It says what OSCR knows of the paper (its code, its validated tracing map) and links the code to this page. Paste one of these snippets under the README's title. Keep the two marks around it, so that the badge can be replaced in place and is never added twice. OSCR changes nothing in your repository.

Markdown
<!-- oscr-badge:start -->
[![OSCR](https://openscicode.org/badge/doi/10.7554/elife.101204.svg)](https://openscicode.org/badge/doi/10.7554/elife.101204)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.7554/elife.101204.svg
   :target: https://openscicode.org/badge/doi/10.7554/elife.101204
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.7554/elife.101204"><img src="https://openscicode.org/badge/doi/10.7554/elife.101204.svg" alt="OSCR"></a>
<!-- oscr-badge:end -->

On GitHub, open the README, choose Edit (the pencil), paste the snippet under the title, then "Commit changes".

If you choose to, you can have the badge kept up to date for you, with oscr badge --write from the command line or with the GitHub Action in your repository's workflows. Every other form and option (a card, AsciiDoc, LaTeX, shields.io) is on the badge 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: code errors and mismatches between the code and the paper about this paper and its code, from readers and its authors, beside the paper and its tracing map.

Report a mismatch between the code and the paper · Report a code error (signed in)

Reproductions: reports from readers who ran the authors' code and did not get the paper's result, what they ran, with which environment, commit and data.

Report a reproduction failure (signed in)

Versions of its code: the releases of its code tied to a version of this paper (the preprint, the accepted manuscript, the version of record…), each with the tracing map versioned with it.

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