OSCR

Spacing effect improves generalization in biological and artificial systems.

Code ↔ Paper

6 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 6 matches · 1 of them tie a paragraph to a whole file, not to given lines: a weak match, whose lines are not tinted
  1. [1] § Results › Neuronal level: Dropout ↔ dropout/train.py, lines 7–87 · score 0.65 · MaxDropout, standard dropout, Tiny ImageNet, spaced interval, benchmark, model
  2. [2] § Methods › KD ↔ self_KD/train.py, lines 213–261 · score 0.60 · feature loss coefficient, deepest, shallower, KD, distillation, teacher
  3. [3] § Results › Spacing effect with input and innate variations enhances generalization in ANNs ↔ dropout/util/cutout.py, lines 5–43 · score 0.54 · square patches, randomly masking, cutout
  4. [4] § Results › Spacing effect with input and innate variations enhances generalization in ANNs ↔ self_KD/cutout.py, the whole file · a weak match · score 0.54 · square patches, randomly masking, cutout
  5. [5] § Methods › KD ↔ online_KD/train_kd.py, lines 215–267 · score 0.52 · KL divergence, temperature, distillation, student, teacher, interval
  6. [6] § Methods › KD ↔ self_KD/train.py, lines 148–211 · score 0.51 · distillation loss, softened, KD, weighting, student, teacher

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 · 318 lines · 14 KB · no license · 2 matches

  1. import torch
  2. import torch.nn as nn
  3. import torch.optim as optim
  4. import torchvision
  5. import torchvision.transforms as transforms
  6. import argparse
  7. from resnet import *
  8. import torch.nn.functional as F
  9. from autoaugment import CIFAR10Policy
  10. from cutout import Cutout
  11. import wandb
  13. parser = argparse.ArgumentParser(description='Self-Distillation CIFAR Training')
  14. parser.add_argument('--model', default="resnet18", type=str, help="resnet18|resnet34|resnet50|resnet101|resnet152|"
  15. "wideresnet50|wideresnet101|resnext50|resnext101")
  16. parser.add_argument('--dataset', default="cifar100", type=str, help="cifar100|cifar10")
  17. # parser.add_argument('--epoch', default=250, type=int, help="training epochs")
  18. parser.add_argument('--epoch', default=80, type=int, help="training epochs")
  19. parser.add_argument('--loss_coefficient', default=0.3, type=float)
  20. parser.add_argument('--feature_loss_coefficient', default=0.03, type=float)
  21. parser.add_argument('--dataset_path', default="data", type=str)
  22. parser.add_argument('--autoaugment', default=True, type=bool)
  23. parser.add_argument('--temperature', default=3.0, type=float)
  24. parser.add_argument('--batchsize', default=128, type=int)
  25. # parser.add_argument('--init_lr', default=0.1, type=float)
  26. parser.add_argument('--init_lr', default=0.01, type=float)
  27. parser.add_argument('--wandb_entity', default='none', type=str, help='wandb_entity')
  28. parser.add_argument('--wandb_project', default='SKD', type=str, help='wandb_project')
  29. parser.add_argument('--interval_rate', default=1.0, type=float)
  30. parser.add_argument('--gpu_ids', default='0,1', type=str, help='gpu ids for training')
  31. args = parser.parse_args()
  32. print(args)
  34. import os
  35. os.environ["CUDA_VISIBLE_DEVICES"]= str(args.gpu_ids)
  36. device_ids = [i for i in range(torch.cuda.device_count())]
  37. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  39. def CrossEntropy(outputs, targets):
  40. log_softmax_outputs = F.log_softmax(outputs/args.temperature, dim=1)
  41. softmax_targets = F.softmax(targets/args.temperature, dim=1)
  42. return -(log_softmax_outputs * softmax_targets).sum(dim=1).mean()
  45. if args.autoaugment:
  46. transform_train = transforms.Compose([transforms.RandomCrop(32, padding=4, fill=128),
  47. transforms.RandomHorizontalFlip(), CIFAR10Policy(), transforms.ToTensor(),
  48. Cutout(n_holes=1, length=16),
  49. transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010))])
  50. else:
  51. transform_train = transforms.Compose([transforms.RandomCrop(32, padding=4, fill=128),
  52. transforms.RandomHorizontalFlip(), transforms.ToTensor(),
  53. transforms.Normalize((0.4914, 0.4822, 0.4465),
  54. (0.2023, 0.1994, 0.2010))])
  56. transform_test = transforms.Compose([
  57. transforms.ToTensor(),
  58. transforms.Normalize((0.4914, 0.4822, 0.4465), (0.2023, 0.1994, 0.2010)),
  59. ])
  60. if args.dataset == "cifar100":
  61. trainset = torchvision.datasets.CIFAR100(
  62. root=args.dataset_path,
  63. train=True,
  64. download=True,
  65. transform=transform_train
  66. )
  67. testset = torchvision.datasets.CIFAR100(
  68. root=args.dataset_path,
  69. train=False,
  70. download=True,
  71. transform=transform_test
  72. )
  73. trainloader = torch.utils.data.DataLoader(
  74. trainset,
  75. batch_size=args.batchsize,
  76. shuffle=True,
  77. num_workers=4
  78. )
  79. testloader = torch.utils.data.DataLoader(
  80. testset,
  81. batch_size=args.batchsize,
  82. shuffle=False,
  83. num_workers=4
  84. )
  85. elif args.dataset == 'tiny_imagenet':
  86. from utils import load_tinyimagenet
  87. id_dic = {}
  88. root = '/data/datasets/tiny-imagenet-200'
  89. for i, line in enumerate(open(root+'/wnids.txt','r')):
  90. id_dic[line.replace('\n', '')] = i
  91. # num_classes = len(id_dic)
  92. trainloader = load_tinyimagenet(root=root, batch_size=args.batchsize, num_workers=4, split='train', shuffle=True, id_dic=id_dic)
  93. testloader = load_tinyimagenet(root=root, batch_size=args.batchsize, num_workers=4, split='val', shuffle=True, id_dic=id_dic)
  95. elif args.dataset == "cifar10":
  96. trainset = torchvision.datasets.CIFAR10(
  97. root=args.dataset_path,
  98. train=True,
  99. download=True,
  100. transform=transform_train
  101. )
  102. testset = torchvision.datasets.CIFAR10(
  103. root=args.dataset_path,
  104. train=False,
  105. download=True,
  106. transform=transform_test
  107. )
  109. if args.dataset == "cifar100":
  110. if args.model == "resnet18":
  111. net = resnet18()
  112. if args.model == "resnet34":
  113. net = resnet34()
  114. if args.model == "resnet50":
  115. net = resnet50()
  116. if args.model == "resnet101":
  117. net = resnet101()
  118. if args.model == "resnet152":
  119. net = resnet152()
  120. if args.model == "wideresnet50":
  121. net = wide_resnet50_2()
  122. if args.model == "wideresnet101":
  123. net = wide_resnet101_2()
  124. if args.model == "resnext50_32x4d":
  125. net = resnet18()
  126. if args.model == "resnext101_32x8d":
  127. net = resnext101_32x8d()
  128. elif args.dataset == "tiny_imagenet":
  129. if args.model == "resnet18":
  130. net = resnet18(num_classes=200)
  131. if args.model == "resnet34":
  132. net = resnet34(num_classes=200)
  133. if args.model == "resnet50":
  134. net = resnet50(num_classes=200)
  135. if args.model == "resnet101":
  136. net = resnet101(num_classes=200)
  137. if args.model == "resnet152":
  138. net = resnet152(num_classes=200)
  139. if args.model == "wideresnet50":
  140. net = wide_resnet50_2(num_classes=200)
  141. if args.model == "wideresnet101":
  142. net = wide_resnet101_2(num_classes=200)
  143. if args.model == "resnext50_32x4d":
  144. net = resnet18(num_classes=200)
  145. if args.model == "resnext101_32x8d":
  146. net = resnext101_32x8d(num_classes=200)
  148. # print(net)
  149. net.to(device)
  151. if torch.cuda.device_count() > 0:
  152. net=nn.DataParallel(net, device_ids=device_ids)
  154. criterion = nn.CrossEntropyLoss()
  155. optimizer = optim.SGD(net.parameters(), lr=args.init_lr, weight_decay=5e-4, momentum=0.9)
  156. init = False
  158. if __name__ == "__main__":
  159. best_acc = 0
  160. interval = int(len(trainloader)*args.interval_rate)
  161. #so the only way is to create a new wandb log
  162. wandb.init(dir='./wandb',entity=args.wandb_entity, project=args.wandb_project, name='self_'+args.model+'_interval'+str(args.interval_rate) +
  163. '_batchsize' + str(args.batchsize) + '_' + str(args.dataset), config=args)
  164. wandb_url = wandb.run.get_url()
  165. print(f"Wandb URL: {wandb_url}")
  167. buffer={'inputs':[], 'labels':[]}
  168. for epoch in range(args.epoch):
  169. correct = [0 for _ in range(5)]
  170. predicted = [0 for _ in range(5)]
  171. # adjust learning rate
  172. # if epoch in [args.epoch // 3, args.epoch * 2 // 3, args.epoch - 10]:
  173. # for param_group in optimizer.param_groups:
  174. # param_group['lr'] /= 10
  175. net.train()
  176. sum_loss, total = 0.0, 0.0
  177. for i, data in enumerate(trainloader, 0):
  179. n_iter = (epoch - 1) * len(trainloader) + i + 1
  181. length = len(trainloader)
  182. inputs, labels = data
  183. buffer['inputs'].append(inputs)
  184. buffer['labels'].append(labels)
  185. inputs, labels = inputs.to(device), labels.to(device)
  186. outputs, outputs_feature = net(inputs)
  187. ensemble = sum(outputs[:-1])/len(outputs)
  188. ensemble.detach_()
  190. if interval == 0:
  191. kd = True
  192. elif n_iter % interval == 0:
  193. kd = (n_iter % interval == 0)
  194. else:
  195. kd = False
  197. if init is False:
  198. # init the adaptation layers.
  199. # we add feature adaptation layers here to soften the influence from feature distillation loss
  200. # the feature distillation in our conference version : | f1-f2 | ^ 2
  201. # the feature distillation in the final version : |Fully Connected Layer(f1) - f2 | ^ 2
  202. layer_list = []
  203. teacher_feature_size = outputs_feature[0].size(1)
  204. for index in range(1, len(outputs_feature)):
  205. student_feature_size = outputs_feature[index].size(1)
  206. layer_list.append(nn.Linear(student_feature_size, teacher_feature_size))
  207. net.adaptation_layers = nn.ModuleList(layer_list)
  208. net.adaptation_layers.cuda()
  209. optimizer = optim.SGD(net.parameters(), lr=args.init_lr, weight_decay=5e-4, momentum=0.9)
  210. # define the optimizer here again so it will optimize the net.adaptation_layers
  211. init = True
  213. # compute loss
  214. loss = torch.FloatTensor([0.]).to(device)
  216. # teacher_output = outputs[0].detach()
  217. # teacher_feature = outputs_feature[0].detach()
  219. if kd is True:
  220. for t_inputs, t_labels in zip(buffer['inputs'], buffer['labels']):
  221. t_inputs, t_labels = t_inputs.to(device), t_labels.to(device)
  222. loss = torch.FloatTensor([0.]).to(device)
  223. if interval == 0:
  224. loss += criterion(outputs[0], labels)
  225. teacher_output = outputs[0].detach()
  226. teacher_feature = outputs_feature[0].detach()
  227. else:
  228. # with torch.no_grad():
  229. outputs, outputs_feature = net(t_inputs)
  230. loss += criterion(outputs[0], t_labels)
  231. teacher_output = outputs[0].detach()
  232. teacher_feature = outputs_feature[0].detach()
  234. # for shallow classifiers
  235. for index in range(1, len(outputs)):
  236. # logits distillation
  237. loss += CrossEntropy(outputs[index], teacher_output) * args.loss_coefficient
  238. loss += criterion(outputs[index], t_labels) * (1 - args.loss_coefficient)
  239. # feature distillation
  240. if index != 1:
  241. loss += torch.dist(net.adaptation_layers[index-1](outputs_feature[index]), teacher_feature) * \
  242. args.feature_loss_coefficient
  244. sum_loss += loss.item()
  245. optimizer.zero_grad()
  246. loss.backward()
  247. optimizer.step()
  248. total += float(labels.size(0))
  249. outputs.append(ensemble)
  251. buffer={'inputs':[], 'labels':[]}
  253. elif kd is False:
  254. # for deepest classifier
  255. loss += criterion(outputs[0], labels)
  256. sum_loss += loss.item()
  257. optimizer.zero_grad()
  258. loss.backward()
  259. optimizer.step()
  260. total += float(labels.size(0))
  261. outputs.append(ensemble)
  263. # the feature distillation loss will not be applied to the shallowest classifier
  264. # elif space is False:
  265. # for index in range(1, len(outputs)):
  266. # loss += criterion(outputs[index], labels) * (1 - args.loss_coefficient)
  268. # sum_loss += loss.item()
  269. # optimizer.zero_grad()
  270. # loss.backward()
  271. # optimizer.step()
  272. # total += float(labels.size(0))
  273. # outputs.append(ensemble)
  275. for classifier_index in range(len(outputs)):
  276. _, predicted[classifier_index] = torch.max(outputs[classifier_index].data, 1)
  277. correct[classifier_index] += float(predicted[classifier_index].eq(labels.data).cpu().sum())
  278. print('[epoch:%d, iter:%d] Loss: %.03f | Acc: 4/4: %.2f%% 3/4: %.2f%% 2/4: %.2f%% 1/4: %.2f%%'
  279. ' Ensemble: %.2f%%' % (epoch + 1, (i + 1 + epoch * length), sum_loss / (i + 1),
  280. 100 * correct[0] / total, 100 * correct[1] / total,
  281. 100 * correct[2] / total, 100 * correct[3] / total,
  282. 100 * correct[4] / total))
  284. wandb.log({'Train/loss': sum_loss / (i + 1), 'Train/acc_4': 100 * correct[0] / total,
  285. 'Train/acc_3': 100 * correct[1] / total, 'Train/acc_2': 100 * correct[2] / total, 'Train/acc_1': 100 * correct[3] / total, 'Train/acc_ensemble': 100 * correct[4] / total})
  287. print("Waiting Test!")
  288. with torch.no_grad():
  289. correct = [0 for _ in range(5)]
  290. predicted = [0 for _ in range(5)]
  291. total = 0.0
  292. for data in testloader:
  293. net.eval()
  294. images, labels = data
  295. images, labels = images.to(device), labels.to(device)
  296. outputs, outputs_feature = net(images)
  297. ensemble = sum(outputs) / len(outputs)
  298. outputs.append(ensemble)
  299. for classifier_index in range(len(outputs)):
  300. _, predicted[classifier_index] = torch.max(outputs[classifier_index].data, 1)
  301. correct[classifier_index] += float(predicted[classifier_index].eq(labels.data).cpu().sum())
  302. total += float(labels.size(0))
  304. print('Test Set AccuracyAcc: 4/4: %.4f%% 3/4: %.4f%% 2/4: %.4f%% 1/4: %.4f%%'
  305. ' Ensemble: %.4f%%' % (100 * correct[0] / total, 100 * correct[1] / total,
  306. 100 * correct[2] / total, 100 * correct[3] / total,
  307. 100 * correct[4] / total))
  308. wandb.log({'Test/acc_4': 100 * correct[0] / total, 'Test/acc_3': 100 * correct[1] / total,
  309. 'Test/acc_2': 100 * correct[2] / total, 'Test/acc_1': 100 * correct[3] / total, 'Test/acc_ensemble': 100 * correct[4] / total})
  311. if correct[4] / total > best_acc:
  312. best_acc = correct[4]/total
  313. print("Best Accuracy Updated: ", best_acc * 100)
  314. # torch.save(net.state_dict(), "./checkpoints/"+str(args.model)+".pth")
  315. wandb.log({'Best_acc': best_acc})
  317. print("Training Finished, TotalEPOCH=%d, Best Accuracy=%.3f" % (args.epoch, best_acc))
  318. wandb.finish()

train.py at commit bc0f466, no license · at the source

Overview

Authors: Guanglong Sun1,2,3, Ning Huang1,2, Hongwei Yan1,2,3, Jun Zhou1,2, Qian Li4, Bo Lei3, Yi Zhong1,2, Liyuan Wang5
ORCID iDs: Qian Li, Yi Zhong
  1. School of Life Sciences, IDG/McGovern Institute for Brain Research, Tsinghua University, Beijing, China
  2. Tsinghua-Peking Center for Life Sciences, Beijing, China
  3. Beijing Academy of Artificial Intelligence, Beijing, China
  4. School of Medicine, Shenzhen Campus of Sun Yat-Sen University, Shenzhen, Guangdong, China
  5. Department of Psychological and Cognitive Sciences, Tsinghua University, Beijing, China
Institutions: Beijing Academy of Artificial Intelligence (China); Center for Life Sciences (China); Tsinghua University (China); Sun Yat-sen University (China)
Journal: Patterns (New York, N.Y.), volume 7, issue 6, article 101564
Dates: received 28 November 2025; accepted 21 April 2026; published online 19 May 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.1016/j.patter.2026.101564 · PMID 42328203 · PMCID PMC13280723 · OpenAlex W7161645048
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: cognitive (subfield)
Methods: Smoothing, state filtering, decompositions
Keywords: spacing effect, generalization, ensemble learning, bio-inspired learning, NeuroAI
Topic: Neurobiology and Insect Physiology Research (Cellular and Molecular Neuroscience, Neuroscience), according to OpenAlex
Funding: STI2030-Major Projects (2022ZD0204900); Beijing Major Science and Technology Project (Z251100008425003); NSFC Projects (62406160, 32021002); National Science and Technology Major Project (2022ZD01163013)
Citations: not cited yet (Europe PMC); 78 references in the paper

Abstract

Generalization is a fundamental criterion for evaluating learning effectiveness, a domain where biological intelligence excels yet artificial intelligence faces challenges. In biological learning and memory, the well-documented spacing effect shows that appropriately spaced intervals between learning trials significantly improve behavioral performance. While multiple theories have been proposed to explain its underlying mechanisms, one compelling hypothesis is that spaced training promotes integration of input and innate variations, thereby enhancing generalization to novel but related scenarios. Here, we examine this hypothesis by introducing a bio-inspired spacing effect into artificial neural networks, integrating input and innate variations across spaced intervals at neuronal, synaptic, and network levels. These spaced ensemble strategies yield significant performance gains across benchmark datasets and network architectures. Biological experiments on Drosophila further validate the complementary effect of appropriate variations and spaced intervals in improving generalization, which together reveal a convergent computational principle of biological learning and machine learning.

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 6 matches between paragraphs and lines of code.

SunGL001/spacing_generalization

License: none: the authors keep all their rights
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Commit: bc0f466f9742b0a5a15f5185443d9a0524163dd9, 27 October 2025
Languages: Python (48), Shell (2)
Size: 64 files, 50 scripts
Software Heritage: not archived
Found in: “Data and code availability”
Holds: README, environment (requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: PyTorch (42 files), NumPy (13 files), Matplotlib (4 files), Pillow (4 files), OpenCV (1 file), scikit-image (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers
  • 28 September 2026: the link answers
51 files
At the source: github.com/SunGL001/spacing_generalization

Zenodo 17959984

License: CC-BY-4.0
State: the link answers, verified on 28 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: the references
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: PyTorch (42 files), NumPy (13 files), Matplotlib (4 files), Pillow (4 files), OpenCV (1 file), scikit-image (1 file)
Availability: 1 check, the latest on 28 September 2026: the link answers (HTTP 200)
  • 28 September 2026: the link answers (HTTP 200)
51 files
At the source:

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;
  • 100 scripts, each with its path and the digest of its content;
  • 6 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.

Data and code availability

• All benchmark datasets used in this paper are publicly available, including CIFAR-10/10043 (https://www.cs.toronto.edu/∼kriz/cifar.html (https://www.cs.toronto.edu/~kriz/cifar.html)) and Tiny-ImageNet72 (https://www.image-net.org/download.php). Statistical analysis is performed using GraphPad Prism software. Data are considered normally distributed if they pass the Shapiro-Wilk test (for n < 8) or the Anderson-Darling test (for n ≥ 8). For normally distributed data, comparisons between the two groups are performed using the two-tailed unpaired t test; comparisons between multiple groups are performed using the one-way ANOVA test followed by Dunnett’s multiple comparisons test and the two-way ANOVA test followed by Sidak’s multiple comparisons test. Results are reported as n.s. (not significant) p > 0.05, ∗p < 0.05, ∗∗p < 0.01, ∗∗∗p < 0.001, and ∗∗∗∗p < 0.0001. • Our source code is available at GitHub (https://github.com/SunGL001/spacing_generalization) and has been archived at Zenodo.78

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 2, 28 September 2026

  • Authors: added Yi Zhong (0000-0002-7927-5976); removed Yi Zhong

Version 1, 28 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 8 authors, 5 keywords, 4 funders, 33 references.

Cite

This paper

Sun, G., Huang, N., Yan, H., Zhou, J., Li, Q., Lei, B., Zhong, Y., & Wang, L. (2026). Spacing effect improves generalization in biological and artificial systems. Patterns (New York, N.Y.), 7(6), 101564. https://doi.org/10.1016/j.patter.2026.101564

BibTeX

@article{sun2026spacing,
author = {Sun, Guanglong and Huang, Ning and Yan, Hongwei and Zhou, Jun and Li, Qian and Lei, Bo and Zhong, Yi and Wang, Liyuan},
title = {{Spacing effect improves generalization in biological and artificial systems}},
journal = {Patterns (New York, N.Y.)},
year = {2026},
month = may,
volume = {7},
number = {6},
pages = {101564},
publisher = {Elsevier},
issn = {2666-3899},
doi = {10.1016/j.patter.2026.101564},
url = {https://doi.org/10.1016/j.patter.2026.101564},
pmid = {42328203},
pmcid = {PMC13280723}
}

RIS

TY - JOUR
AU - Sun, Guanglong
AU - Huang, Ning
AU - Yan, Hongwei
AU - Zhou, Jun
AU - Li, Qian
AU - Lei, Bo
AU - Zhong, Yi
AU - Wang, Liyuan
TI - Spacing effect improves generalization in biological and artificial systems
T2 - Patterns (New York, N.Y.)
J2 - Patterns (N Y)
PY - 2026
DA - 2026/05/19
VL - 7
IS - 6
SP - 101564
SN - 2666-3899
PB - Elsevier
DO - 10.1016/j.patter.2026.101564
UR - https://doi.org/10.1016/j.patter.2026.101564
LA - en
ER -

CSL-JSON

{
"id": "10.1016/j.patter.2026.101564",
"type": "article-journal",
"title": "Spacing effect improves generalization in biological and artificial systems",
"container-title": "Patterns (New York, N.Y.)",
"author": [
{
"family": "Sun",
"given": "Guanglong"
},
{
"family": "Huang",
"given": "Ning"
},
{
"family": "Yan",
"given": "Hongwei"
},
{
"family": "Zhou",
"given": "Jun"
},
{
"family": "Li",
"given": "Qian"
},
{
"family": "Lei",
"given": "Bo"
},
{
"family": "Zhong",
"given": "Yi"
},
{
"family": "Wang",
"given": "Liyuan"
}
],
"container-title-short": "Patterns (N Y)",
"volume": "7",
"issue": "6",
"page": "101564",
"DOI": "10.1016/j.patter.2026.101564",
"PMID": "42328203",
"PMCID": "PMC13280723",
"ISSN": "2666-3899",
"publisher": "Elsevier",
"URL": "https://doi.org/10.1016/j.patter.2026.101564",
"language": "en",
"issued": {
"date-parts": [
[
2026,
5,
19
]
]
}
}

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-74358-5 [code]
Brain-inspired spatial intelligence for embodied agents.
Journal: Nature communications
In common: OpenCV, Pillow, PyTorch, 2 other tools, cognitive, 1 reference
[2] doi:10.1038/s41598-026-43529-1 [code]
A spiking neural network inspired by neuroscience and psychology for Western mode- and key-conditioned music learning and composition.
Journal: Scientific reports
In common: OpenCV, Pillow, PyTorch, 2 other tools, cognitive, 1 reference
[3] doi:10.1126/sciadv.aef6263 [code]
Deep learning-enabled versatile shape perception for soft robots via single-ended multimode fiber.
Journal: Science advances
In common: OpenCV, scikit-image, Pillow, 3 other tools, cognitive
[4] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: OpenCV, scikit-image, Pillow, 3 other tools, cognitive
[5] doi:10.1007/s00429-026-03166-w [code]
Autoencoders for unsupervised analysis of rat myeloarchitecture.
Journal: Brain structure & function
In common: OpenCV, scikit-image, Pillow, 3 other tools
[6] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: OpenCV, scikit-image, Pillow, 3 other tools
[7] doi:10.1038/s41467-026-76956-9 [code]
Innervated human cardiac muscle model reveals sympathetic drivers of KCNH2-associated arrhythmias.
Journal: Nature communications
In common: OpenCV, scikit-image, Pillow, 3 other tools
[8] doi:10.1038/s41598-026-61605-4 [code]
Learning precise segmentation of neurofibrillary tangles from rapid manual point annotations.
Journal: Scientific reports
In common: OpenCV, scikit-image, Pillow, 3 other tools
[9] doi:10.1126/sciadv.aed3650 [code]
Truthful visualizations for mass spectrometry imaging enable high-spatial-resolution interactive &lt;i&gt;m/z&lt;/i&gt; mapping and exploration.
Journal: Science advances
In common: OpenCV, scikit-image, Pillow, 3 other tools
[10] doi:10.1038/s41467-026-76837-1 [code]
Drug screen and machine learning predict neuroprotective agents in a preclinical human model of childhood dementia.
Journal: Nature communications
In common: OpenCV, scikit-image, Pillow, 3 other tools

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.