OSCR

Cluster Haptic Texture Dataset: Haptic Texture Dataset with Varied Velocity-Direction Sliding Contacts.

Code ↔ Paper

13 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 13 matches
  1. [1] § Technical Validation › Setup › Classifiers ↔ train/haptics_texture_classification.py, lines 49 to 85 · score 0.76 · decision tree, random forest, machine learning, texture classification, SVC, ViT · Report a mismatch
  2. [2] § Technical Validation › Setup › Classifiers ↔ train/haptics_texture_classification_motion.py, lines 44 to 79 · score 0.76 · decision tree, random forest, machine learning, texture classification, SVC, ViT · Report a mismatch
  3. [3] § Methods › Active Noise Cancellation System ↔ preprocessing/noise_cancel/active_filter/LMSnoise_cancel.py, lines 17 to 108 · score 0.71 · NLMS algorithm, noise cancellation, sub, filtering, active, coefficients · Report a mismatch
  4. [4] § Technical Validation › Setup › Data Preprocessing ↔ train/haptics_texture_classification.py, lines 49 to 85 · score 0.68 · vertical flipping, random erasing, augmentation, horizontal, resized, training · Report a mismatch
  5. [5] § Technical Validation › Setup › Data Preprocessing ↔ train/haptics_texture_classification_motion.py, lines 44 to 79 · score 0.68 · vertical flipping, random erasing, augmentation, horizontal, resized, training · Report a mismatch
  6. [6] § Technical Validation › Setup › Data Preprocessing ↔ train/datasets/accel_vel_dir_dataset.py, lines 14 to 136 · score 0.61 · log mel spectrogram, hop length, FFT, intervals · Report a mismatch
  7. [7] § Methods › Active Noise Cancellation System ↔ preprocessing/noise_cancel/active_noise_filter.py, lines 22 to 42 · score 0.60 · active noise cancellation, NLMS, filtering, algorithm, coefficients, error · Report a mismatch
  8. [8] § Technical Validation › Setup › Classifiers ↔ train/classification/AudioAccelMultiClassification.py, lines 2 to 41 · score 0.60 · ResNet, fused, architecture, modality, classifier, acceleration · Report a mismatch
  9. [9] § Methods › Active Noise Cancellation System ↔ preprocessing/noise_cancel/active_filter/LMSnoise_cancel.py, lines 343 to 384 · score 0.60 · noise cancelled signal, transfer function, Active, 20 dB · Report a mismatch
  10. [10] § Technical Validation › Setup › Data Preprocessing ↔ train/datasets/accel_dataset_mel.py, lines 137 to 144 · score 0.58 · log mel spectrogram, hop length, FFT · Report a mismatch
  11. [11] § Technical Validation › Setup › Training and Evaluation ↔ train/classification/AudioAccelMultiClassification.py, lines 149 to 192 · score 0.55 · Adam, CPU, optimizer, scheduler, trained, classifiers · Report a mismatch
  12. [12] § Technical Validation › Setup › Training and Evaluation ↔ train/classification/MotionTokenClassification.py, lines 166 to 217 · score 0.55 · Adam, CPU, optimizer, scheduler, trained, classifiers · Report a mismatch
  13. [13] § Technical Validation › Experiment II: Texture Classification with Motion Labels ↔ train/classification/AudioAccelMultiClassification.py, lines 2 to 41 · score 0.54 · ResNet, texture classification, architecture, trained, acceleration, 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 · 349 lines · 13 KB · Apache-2.0 · 3 matches

  2. """
  3. This module implements a multi-modal classification system that combines audio and accelerometer data.
  4. It uses a dual-stream architecture where each modality (audio and accelerometer data) is processed
  5. by a separate feature extractor, and then the features are fused for final classification.
  7. The architecture supports different backbone models (ResNet, ViT, RegNet) for feature extraction
  8. from each modality, and provides flexibility in how the features are combined.
  10. Key components:
  11. - FeatureExtractor: A wrapper for various backbone models to extract features
  12. - AudioAccelMultiClassification: The main class that handles the dual-stream architecture,
  13. training, evaluation, and visualization of results
  15. This approach allows for effective texture classification by leveraging complementary information
  16. from both acoustic and vibration signals.
  17. """
  20. import copy
  21. import torch
  22. import torch.nn as nn
  23. import torch.optim as optim
  24. import torchvision
  25. from torchvision import datasets, transforms, models
  26. from torch.utils.data import DataLoader, random_split
  27. import torch.nn.functional as F
  28. from transformers import ViTForImageClassification, ViTFeatureExtractor
  29. import matplotlib.pyplot as plt
  30. import seaborn as sns
  31. from tensorboardX import SummaryWriter
  32. import numpy as np
  33. import time
  34. from torchmetrics.classification import MulticlassConfusionMatrix
  35. from sklearn.metrics import precision_score, recall_score, f1_score, confusion_matrix
  36. import timm # ファイルの先頭に追加
  37. import os
  38. import torch.nn as nn
  39. from torchvision.models.resnet import ResNet34_Weights
  41. os.environ['PYTORCH_CUDA_ALLOC_CONF'] = 'expandable_segments:True'
  43. class FeatureExtractor(nn.Module):
  44. def __init__(self, base_model, feature_size, in_channels=1, model_type='resnet'):
  45. super(FeatureExtractor, self).__init__()
  46. self.model_type = model_type
  48. if model_type == 'vit':
  49. self.model = base_model
  50. # ViTの出力次元を変更
  51. self.model.head = nn.Linear(self.model.head.in_features, feature_size)
  52. else: # resnet or regnet
  53. # 入力チャンネル数に合わせて最初の畳み込み層を変更
  54. original_conv = base_model.conv1
  55. base_model.conv1 = nn.Conv2d(
  56. in_channels,
  57. original_conv.out_channels,
  58. kernel_size=original_conv.kernel_size,
  59. stride=original_conv.stride,
  60. padding=original_conv.padding,
  61. bias=False
  62. )
  64. num_features = base_model.fc.in_features
  65. base_model.fc = nn.Linear(num_features, feature_size)
  66. self.model = base_model
  68. def forward(self, x):
  69. x = self.model(x)
  70. x = F.relu(x)
  71. return x
  73. class TransformerBlock(nn.Module):
  74. def __init__(self, embed_dim, num_heads, ff_dim, dropout=0.1):
  75. super(TransformerBlock, self).__init__()
  76. self.attention = nn.MultiheadAttention(embed_dim, num_heads, dropout=dropout)
  77. self.norm1 = nn.LayerNorm(embed_dim)
  78. self.norm2 = nn.LayerNorm(embed_dim)
  79. self.ff = nn.Sequential(
  80. nn.Linear(embed_dim, ff_dim),
  81. nn.ReLU(),
  82. nn.Dropout(dropout),
  83. nn.Linear(ff_dim, embed_dim),
  84. nn.Dropout(dropout)
  85. )
  87. def forward(self, x):
  88. # x shape: (batch_size, seq_len, embed_dim)
  89. # MultiheadAttention expects (seq_len, batch_size, embed_dim)
  90. x = x.transpose(0, 1)
  91. attended, _ = self.attention(x, x, x)
  92. # Add & Norm
  93. x = self.norm1(attended + x)
  94. # Feed forward
  95. ff_output = self.ff(x)
  96. # Add & Norm
  97. x = self.norm2(ff_output + x)
  98. # Return to original shape
  99. return x.transpose(0, 1)
  101. class AudioAccelModel(nn.Module):
  102. def __init__(self, audio_model, accel_model, feature_size, num_classes, num_transformer_layers=1, model_type='resnet'):
  103. super(AudioAccelModel, self).__init__()
  104. # 入力チャンネル数を指定して特徴抽出器を初期化
  105. self.audio_encoder = FeatureExtractor(audio_model, feature_size, in_channels=1, model_type=model_type)
  106. self.accel_encoder = FeatureExtractor(accel_model, feature_size, in_channels=3, model_type=model_type)
  109. # 特徴量を結合した後の次元
  110. combined_dim = feature_size * 2
  112. # Transformer層の追加
  113. transformer_layers = []
  114. for _ in range(num_transformer_layers):
  115. transformer_layers.append(TransformerBlock(
  116. embed_dim=combined_dim,
  117. num_heads=8,
  118. ff_dim=combined_dim*4,
  119. dropout=0.1
  120. ))
  121. self.transformer = nn.Sequential(*transformer_layers)
  123. # 分類層
  124. self.fc = nn.Linear(combined_dim, num_classes)
  126. def forward(self, audio, accel):
  127. # encoder
  128. audio_features = self.audio_encoder(audio)
  129. accel_features = self.accel_encoder(accel)
  131. # concat
  132. combined = torch.cat((audio_features, accel_features), dim=1)
  134. # Transformerに入力するために形状を変更 (batch_size, sequence_length=1, features)
  135. combined = combined.unsqueeze(1)
  137. # Transformer処理
  138. transformed = self.transformer(combined)
  140. # 分類のために形状を変更
  141. transformed = transformed.squeeze(1)
  143. # 分類
  144. output = self.fc(transformed)
  146. return output
  148. class AudioAccelMultiClassification:
  149. def __init__(self, dataloaders, dataset_sizes, class_names, feature_size=256, experiment_name='audio_accel_texture_classification', num_epochs=25, learning_rate=0.00005, model="resnet"):
  150. self.dataloaders = dataloaders
  151. self.dataset_sizes = dataset_sizes
  152. self.class_names = class_names
  153. self.feature_size = feature_size
  154. self.experiment_name = experiment_name
  155. self.num_epochs = num_epochs
  156. self.learning_rate = learning_rate
  158. # writer
  159. self.writer = None
  161. self.device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
  162. print(f"Device: {self.device}")
  164. # Load pre-trained models
  165. if model == "resnet":
  166. model_audio = models.resnet34(weights=ResNet34_Weights.DEFAULT)
  167. model_accel = models.resnet34(weights=ResNet34_Weights.DEFAULT)
  168. model_type = 'resnet'
  169. elif model == "regnet":
  170. model_audio = models.regnet_y_16gf(weights=models.RegNet_Y_16GF_Weights.IMAGENET1K_V1)
  171. model_accel = models.regnet_y_16gf(weights=models.RegNet_Y_16GF_Weights.IMAGENET1K_V1)
  172. model_type = 'regnet'
  173. elif model == "vit":
  174. model_audio = timm.create_model('vit_small_patch32_224', pretrained=True, in_chans=1)
  175. model_accel = timm.create_model('vit_small_patch32_224', pretrained=True, in_chans=3)
  176. model_type = 'vit'
  177. else:
  178. raise ValueError("Invalid model name. Choose from: 'resnet', 'regnet', 'vit'")
  180. # Create the multimodal classifier model
  181. self.model = AudioAccelModel(
  182. audio_model=model_audio,
  183. accel_model=model_accel,
  184. feature_size=feature_size,
  185. num_classes=len(class_names),
  186. model_type=model_type # モデルタイプを渡す
  187. )
  188. self.model = self.model.to(self.device)
  190. self.criterion = torch.nn.CrossEntropyLoss()
  191. self.optimizer = torch.optim.Adam(self.model.parameters(), lr=self.learning_rate)
  192. self.scheduler = torch.optim.lr_scheduler.StepLR(self.optimizer, step_size=7, gamma=0.1)
  194. def train_model(self, log_visualization=True):
  195. since = time.time()
  197. best_model_wts = copy.deepcopy(self.model.state_dict())
  198. best_acc = 0.0
  200. train_loss_history = []
  201. train_acc_history = []
  202. val_loss_history = []
  203. val_acc_history = []
  205. for epoch in range(self.num_epochs):
  206. if log_visualization:
  207. print(f'Epoch {epoch}/{self.num_epochs - 1}')
  208. print('-' * 10)
  210. # Each epoch has a training and validation phase
  211. for phase in ['train', 'val']:
  212. if phase == 'train':
  213. self.model.train() # Set model to training mode
  214. else:
  215. self.model.eval() # Set model to evaluate mode
  217. running_loss = 0.0
  218. running_corrects = 0
  220. # Iterate over data.
  221. for audio_data, accel_data, labels in self.dataloaders[phase]:
  222. audio_data = audio_data.to(self.device)
  223. accel_data = accel_data.to(self.device)
  224. labels = labels.to(self.device)
  226. # Zero the parameter gradients
  227. self.optimizer.zero_grad()
  229. # Forward
  230. # Track history if only in train
  231. with torch.set_grad_enabled(phase == 'train'):
  232. outputs = self.model(audio_data, accel_data)
  233. _, preds = torch.max(outputs, 1)
  234. loss = self.criterion(outputs, labels)
  236. # Backward + optimize only if in training phase
  237. if phase == 'train':
  238. loss.backward()
  239. self.optimizer.step()
  241. # Statistics
  242. running_loss += loss.item() * audio_data.size(0)
  243. running_corrects += torch.sum(preds == labels.data)
  245. epoch_loss = running_loss / self.dataset_sizes[phase]
  246. epoch_acc = running_corrects.double() / self.dataset_sizes[phase]
  248. if log_visualization:
  249. print(f'{phase} Loss: {epoch_loss:.4f} Acc: {epoch_acc:.4f}')
  251. if phase == 'train':
  252. self.scheduler.step(epoch_loss)
  254. # Log history
  255. if phase == 'train':
  256. train_loss_history.append(epoch_loss)
  257. train_acc_history.append(epoch_acc.item())
  258. if self.writer:
  259. self.writer.add_scalar('Loss/train', epoch_loss, epoch)
  260. self.writer.add_scalar('Accuracy/train', epoch_acc, epoch)
  261. else:
  262. val_loss_history.append(epoch_loss)
  263. val_acc_history.append(epoch_acc.item())
  264. if self.writer:
  265. self.writer.add_scalar('Loss/val', epoch_loss, epoch)
  266. self.writer.add_scalar('Accuracy/val', epoch_acc, epoch)
  268. # Deep copy the model
  269. if phase == 'val' and epoch_acc > best_acc:
  270. best_acc = epoch_acc
  271. best_model_wts = copy.deepcopy(self.model.state_dict())
  273. if log_visualization:
  274. print()
  276. time_elapsed = time.time() - since
  278. print(f'Training complete in {time_elapsed // 60:.0f}m {time_elapsed % 60:.0f}s')
  279. print(f'Best val Acc: {best_acc:4f}')
  281. # Load best model weights
  282. self.model.load_state_dict(best_model_wts)
  284. def save_model(self, path=None):
  285. if path is None:
  286. path = '.log/' + self.experiment_name + '/best_model.pth'
  287. torch.save(self.model.state_dict(), path)
  289. def evaluate_model(self, log_visualization=True):
  290. self.model.eval()
  291. running_corrects = 0
  293. all_preds = []
  294. all_labels = []
  296. with torch.no_grad():
  297. for audio_data, accel_data, labels in self.dataloaders['test']:
  298. audio_data = audio_data.to(self.device)
  299. accel_data = accel_data.to(self.device)
  300. labels = labels.to(self.device)
  302. outputs = self.model(audio_data, accel_data)
  303. _, preds = torch.max(outputs, 1)
  305. all_preds.append(preds)
  306. all_labels.append(labels)
  308. running_corrects += torch.sum(preds == labels.data)
  310. test_acc = running_corrects.double() / self.dataset_sizes['test']
  312. # Calculate Precision, Recall, F1 Score
  313. all_preds = torch.cat(all_preds).cpu().numpy()
  314. all_labels = torch.cat(all_labels).cpu().numpy()
  315. precision = precision_score(all_labels, all_preds, average='macro')
  316. recall = recall_score(all_labels, all_preds, average='macro')
  317. f1 = f1_score(all_labels, all_preds, average='macro')
  320. if log_visualization:
  321. print(f'Test Acc: {test_acc:.4f}')
  322. print(f'Precision: {precision:.4f}')
  323. print(f'Recall: {recall:.4f}')
  324. print(f'F1 Score: {f1:.4f}')
  326. # Confusion matrix
  327. cm = confusion_matrix(all_labels, all_preds)
  329. # Plot confusion matrix
  330. if self.writer:
  331. fig = plt.figure(figsize=(10, 10))
  332. sns.heatmap(cm, annot=True, fmt="d", cmap="Blues", xticklabels=self.class_names, yticklabels=self.class_names)
  333. plt.ylabel('Actual')
  334. plt.xlabel('Predicted')
  335. plt.title('Confusion Matrix')
  336. self.writer.add_figure('Confusion Matrix', fig, self.num_epochs)
  337. plt.close(fig)
  339. # tensor -> float
  340. test_acc = test_acc.item()
  342. return test_acc
  344. def open_writer(self):
  345. self.writer = SummaryWriter(log_dir='.log/' + self.experiment_name)
  347. def close_writer(self):
  348. if self.writer:
  349. self.writer.close()

AudioAccelMultiClassification.py at commit e05d6b0, under Apache-2.0 · at the source

Overview

Authors: Michikuni Eguchi1,2, Tomohiro Hayase1, Yuichi Hiroi1, Takefumi Hiraki1,3
  1. Cluster Metaverse Lab, 8-9-5 Nishigotanda, Shinagawa, Tokyo Japan
  2. Graduate School of Comprehensive Human Sciences, University of Tsukuba, 1-2 Kasuga, Tsukuba, Ibaraki Japan
  3. Institute of Library, Information and Media Science, University of Tsukuba, 1-2 Kasuga, Tsukuba, Ibaraki Japan
Institutions: University of Tsukuba (Japan)
Journal: Scientific data, volume 13, issue 1, article 756
Dates: received 7 July 2025; accepted 29 January 2026; published online 27 March 2026
Type: Data paper · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41597-026-06760-z · PMID 41896585 · PMCID PMC13186998 · OpenAlex W7141476884
Open access: gold, a free copy (OpenAlex)
Status: code verified (how the code is found and verified)
Categories: methods / tools (subfield)
Keywords: Engineering, Touch receptors, Mechanical engineering
Topic: Tactile and Sensory Interactions (Cognitive Neuroscience, Neuroscience), according to OpenAlex
Citations: cited by 1 paper (Europe PMC); 37 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 13 matches between paragraphs and lines of code.

cluster-lab/Cluster-Haptic-Texture-Dataset

License: Apache-2.0
State: the link answers, verified on 30 September 2026
Evidence: files inventoried
Commit: e05d6b022d127e24f73583146f0aa229c6934449, 6 November 2025
Languages: Python (35), Shell (2)
Size: 45 files, 37 scripts
Software Heritage: not archived
Found in: “Code availability”
Holds: README, license file, environment (Dockerfile, requirements.txt)
Not found: CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (29 files), Matplotlib (28 files), PyTorch (18 files), seaborn (11 files), scikit-learn (7 files), SciPy (7 files), pandas (5 files), Hugging Face Transformers (3 files), Pillow (1 file)
Availability: 1 check, the latest on 30 September 2026: the link answers
  • 30 September 2026: the link answers
39 files
At the source: github.com/cluster-lab/Cluster-Haptic-Texture-Dataset

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/s41597-026-06760-z.

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;
  • 37 scripts, each with its path and the digest of its content;
  • 13 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 statement

The paper has a 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/s41597-026-06760-z.

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, 4 authors, 3 keywords, 32 references.

Cite

This paper

Eguchi, M., Hayase, T., Hiroi, Y., & Hiraki, T. (2026). Cluster Haptic Texture Dataset: Haptic Texture Dataset with Varied Velocity-Direction Sliding Contacts. Scientific data, 13(1), 756. https://doi.org/10.1038/s41597-026-06760-z

BibTeX

@article{eguchi2026cluster,
author = {Eguchi, Michikuni and Hayase, Tomohiro and Hiroi, Yuichi and Hiraki, Takefumi},
title = {{Cluster Haptic Texture Dataset: Haptic Texture Dataset with Varied Velocity-Direction Sliding Contacts}},
journal = {Scientific data},
year = {2026},
month = mar,
volume = {13},
number = {1},
pages = {756},
publisher = {Nature Publishing Group},
issn = {2052-4463},
doi = {10.1038/s41597-026-06760-z},
url = {https://doi.org/10.1038/s41597-026-06760-z},
pmid = {41896585},
pmcid = {PMC13186998}
}

RIS

TY - JOUR
AU - Eguchi, Michikuni
AU - Hayase, Tomohiro
AU - Hiroi, Yuichi
AU - Hiraki, Takefumi
TI - Cluster Haptic Texture Dataset: Haptic Texture Dataset with Varied Velocity-Direction Sliding Contacts
T2 - Scientific data
J2 - Sci Data
PY - 2026
DA - 2026/03/27
VL - 13
IS - 1
SP - 756
SN - 2052-4463
PB - Nature Publishing Group
DO - 10.1038/s41597-026-06760-z
UR - https://doi.org/10.1038/s41597-026-06760-z
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41597-026-06760-z",
"type": "article-journal",
"title": "Cluster Haptic Texture Dataset: Haptic Texture Dataset with Varied Velocity-Direction Sliding Contacts",
"container-title": "Scientific data",
"author": [
{
"family": "Eguchi",
"given": "Michikuni"
},
{
"family": "Hayase",
"given": "Tomohiro"
},
{
"family": "Hiroi",
"given": "Yuichi"
},
{
"family": "Hiraki",
"given": "Takefumi"
}
],
"container-title-short": "Sci Data",
"volume": "13",
"issue": "1",
"page": "756",
"DOI": "10.1038/s41597-026-06760-z",
"PMID": "41896585",
"PMCID": "PMC13186998",
"ISSN": "2052-4463",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41597-026-06760-z",
"language": "en",
"issued": {
"date-parts": [
[
2026,
3,
27
]
]
}
}

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/s41598-024-81824-x [code]
Transformer-based transfer learning on self-reported voice recordings for Parkinson's disease diagnosis.
Journal: Scientific reports
In common: Hugging Face Transformers, PyTorch, seaborn, 4 other tools, 3 references
[2] doi:10.7554/elife.107933 [code]
Modality-agnostic decoding of vision and language from fMRI.
Journal: eLife
In common: Hugging Face Transformers, Pillow, PyTorch, 6 other tools, 1 reference
[3] doi:10.3389/fninf.2025.1527582 [code]
Contrastive self-supervised learning for neurodegenerative disorder classification.
Journal: Frontiers in neuroinformatics
In common: Pillow, PyTorch, seaborn, 5 other tools, methods / tools, 2 references
[4] doi:10.1162/imag.a.1299 [code]
A modular semantic-structural pipeline for visual decoding from primate spiking data via selective temporal integration.
Journal: Imaging neuroscience (Cambridge, Mass.)
In common: Hugging Face Transformers, Pillow, PyTorch, 6 other tools, methods / tools
[5] doi:10.1177/03000605261422820 [code]
Brain tumor detection on magnetic resonance imaging scans using the artificial intelligence-based You Only Look Once algorithm.
Journal: The Journal of international medical research
In common: Hugging Face Transformers, Pillow, PyTorch, 6 other tools, methods / tools
[6] doi:10.1002/hbm.70469 [code]
VarCoNet: A Variability-Aware Self-Supervised Framework for Functional Connectome Extraction From Resting-State fMRI.
Journal: Human brain mapping
In common: Hugging Face Transformers, Pillow, PyTorch, 6 other tools, methods / tools
[7] doi:10.1038/s41746-025-02108-w [code]
Understanding the robustness of vision-language models to medical image artefacts.
Journal: NPJ digital medicine
In common: Hugging Face Transformers, Pillow, PyTorch, 6 other tools, methods / tools
[8] doi:10.3389/fninf.2025.1515873 [code]
Net2Brain: a toolbox to compare artificial vision models with human brain responses.
Journal: Frontiers in neuroinformatics
In common: Hugging Face Transformers, Pillow, PyTorch, 6 other tools, methods / tools
[9] doi:10.1038/s41467-026-71267-5 [code]
Human-like cognitive generalization for large models via mental representation-guided supervision.
Journal: Nature communications
In common: Hugging Face Transformers, Pillow, PyTorch, 5 other tools, 1 reference
[10] doi: [code]
Brain Representation in Conscious and Unconscious Vision
Journal: Journal of cognition
In common: Pillow, PyTorch, seaborn, 5 other tools, 2 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.1038/s41597-026-06760-z.svg)](https://openscicode.org/badge/doi/10.1038/s41597-026-06760-z)
<!-- oscr-badge:end -->
reStructuredText
.. oscr-badge:start

.. image:: https://openscicode.org/badge/doi/10.1038/s41597-026-06760-z.svg
   :target: https://openscicode.org/badge/doi/10.1038/s41597-026-06760-z
   :alt: OSCR

.. oscr-badge:end
HTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.1038/s41597-026-06760-z"><img src="https://openscicode.org/badge/doi/10.1038/s41597-026-06760-z.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.