OSCR

BioLAMR: A Biomimetically Inspired Large Language Model Adaptation Framework for Automatic Modulation Recognition.

Code ↔ Paper

9 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 9 matches
  1. [1] § 4. Experiments › 4.1. Experimental Setup › 4.1.3. Implementation Details ↔ train_radioml2016a.py, lines 165–313 · score 0.83 · AdamW, OneCycleLR, weight decay, hierarchical learning rate, gradients, scheduler
  2. [2] § 4. Experiments › 4.1. Experimental Setup › 4.1.3. Implementation Details ↔ train_radioml2016b.py, lines 231–344 · score 0.77 · AdamW, OneCycleLR, weight decay, scheduler, CPU, patience
  3. [3] § 3. Proposed Method › 3.3. Lightweight Dual-Domain Fusion ↔ biolamr.py, lines 49–118 · score 0.76 · channel attention learns, lightweight dual domain, frequency domain features, concatenation, tensor, learnable
  4. [4] § 4. Experiments › 4.1. Experimental Setup › 4.1.3. Implementation Details ↔ biolamr.py, lines 153–239 · score 0.71 · classification head, lightweight dual domain, GPU, compress, hidden, dropout
  5. [5] § 3. Proposed Method › 3.1. Overall Architecture ↔ biolamr.py, lines 153–239 · score 0.64 · classification head, signal embedding, frequency domain, backbone, BioLAMR, global
  6. [6] § 3. Proposed Method › 3.3. Lightweight Dual-Domain Fusion ↔ biolamr.py, lines 49–118 · score 0.62 · concatenated feature, channel attention, sigmoid, LDDF, adaptive, lightweight
  7. [7] § 3. Proposed Method › 3.1. Overall Architecture ↔ train_radioml2016b.py, lines 122–228 · score 0.61 · signal embedding layer, classification head, trainable, BioLAMR, dual domain, sequence
  8. [8] § 4. Experiments › 4.3. Ablation Studies › 4.3.3. Hierarchical Parameter Fine-Tuning Strategy and Pretraining Efficacy ↔ train_radioml2016b.py, lines 122–228 · score 0.60 · LayerNorm, parameter fine tuning, MLP, BioLAMR, unfreezes, pretrained
  9. [9] § 4. Experiments › 4.3. Ablation Studies › 4.3.3. Hierarchical Parameter Fine-Tuning Strategy and Pretraining Efficacy ↔ train_radioml2016a.py, lines 22–89 · score 0.57 · LayerNorm, parameter fine tuning, MLP, BioLAMR, unfreezes, layers

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 · 359 lines · 13 KB · no license · 4 matches

  1. #!/usr/bin/env python3
  2. """
  3. BioLAMR: GPT-2 based radio modulation recognition model
  4. """
  6. import numpy as np
  7. import torch
  8. import torch.nn as nn
  9. import torch.nn.functional as F
  10. from transformers import GPT2Model
  12. class ChannelAttention(nn.Module):
  13. """Channel attention mechanism"""
  14. def __init__(self, in_planes, ratio=4):
  15. super(ChannelAttention, self).__init__()
  16. self.avg_pool = nn.AdaptiveAvgPool1d(1) # 1D pooling for signal data
  17. self.max_pool = nn.AdaptiveMaxPool1d(1)
  19. self.fc1 = nn.Conv1d(in_planes, in_planes // ratio, 1, bias=False)
  20. self.relu1 = nn.ReLU()
  21. self.fc2 = nn.Conv1d(in_planes // ratio, in_planes, 1, bias=False)
  22. self.sigmoid = nn.Sigmoid()
  24. def forward(self, x):
  25. avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
  26. max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
  27. out = avg_out + max_out
  28. return self.sigmoid(out)
  31. class ResidualBlock1D(nn.Module):
  32. """1D residual block with channel attention for signal processing"""
  33. def __init__(self, in_planes):
  34. super(ResidualBlock1D, self).__init__()
  35. self.conv1 = nn.Conv1d(in_planes, in_planes, 3, 1, 1)
  36. self.conv2 = nn.Conv1d(in_planes, in_planes, 3, 1, 1)
  37. self.ca = ChannelAttention(in_planes=in_planes, ratio=1)
  38. self.relu = nn.ReLU(inplace=True)
  40. def forward(self, x):
  41. rs1 = self.relu(self.conv1(x))
  42. rs1 = self.conv2(rs1)
  43. channel_attn = self.ca(rs1)
  44. output = channel_attn * rs1
  45. rs = torch.add(x, output)
  46. return rs
  49. class LDDF(nn.Module):
  50. """
  51. Lightweight Dual-Domain Fusion (LDDF) module
  53. Design highlights:
  54. 1. Output dimension matches input [B, 2, 128], fully compatible with GPT-2
  55. 2. Lightweight design (~1000 params), does not interfere with GPT-2 pretrained knowledge
  56. 3. Channel attention + spatial attention for adaptive time-frequency feature fusion
  57. 4. Residual connection preserves original time-domain information
  58. """
  59. def __init__(self, channels=2, seq_len=128, reduction=2):
  60. super().__init__()
  61. self.channels = channels
  62. self.seq_len = seq_len
  64. # Channel attention - learns channel importance of time-frequency features
  65. self.channel_attention = nn.Sequential(
  66. nn.AdaptiveAvgPool1d(1), # [B, 4, 128] -> [B, 4, 1]
  67. nn.Conv1d(channels * 2, channels * 2 // reduction, kernel_size=1, bias=False),
  68. nn.ReLU(inplace=True),
  69. nn.Conv1d(channels * 2 // reduction, channels * 2, kernel_size=1, bias=False),
  70. nn.Sigmoid()
  71. )
  73. # Spatial attention - learns spatial importance of time-frequency features
  74. self.spatial_attention = nn.Sequential(
  75. nn.Conv1d(2, 1, kernel_size=7, padding=3, bias=False),
  76. nn.Sigmoid()
  77. )
  79. # Fusion convolution - fuses concatenated features back to original dimension
  80. self.fusion_conv = nn.Sequential(
  81. nn.Conv1d(channels * 2, channels, kernel_size=1, bias=False),
  82. nn.BatchNorm1d(channels),
  83. nn.ReLU(inplace=True)
  84. )
  86. # Learnable residual weight
  87. self.residual_weight = nn.Parameter(torch.tensor(0.1))
  89. def forward(self, time_features, freq_features):
  90. """
  91. Args:
  92. time_features: [batch, 2, 128] - Time-domain features
  93. freq_features: [batch, 2, 128] - Frequency-domain features
  94. Returns:
  95. fused: [batch, 2, 128] - Fused features (dimension unchanged, compatible with GPT-2)
  96. """
  97. # Concatenate time-frequency features
  98. concat = torch.cat([time_features, freq_features], dim=1) # [B, 4, 128]
  100. # Channel attention
  101. ca_weights = self.channel_attention(concat) # [B, 4, 1]
  102. concat_ca = concat * ca_weights # [B, 4, 128]
  104. # Spatial attention
  105. # Compute channel-wise mean and max
  106. avg_out = torch.mean(concat_ca, dim=1, keepdim=True) # [B, 1, 128]
  107. max_out, _ = torch.max(concat_ca, dim=1, keepdim=True) # [B, 1, 128]
  108. spatial_input = torch.cat([avg_out, max_out], dim=1) # [B, 2, 128]
  109. sa_weights = self.spatial_attention(spatial_input) # [B, 1, 128]
  110. concat_sa = concat_ca * sa_weights # [B, 4, 128]
  112. # Fuse to original dimension
  113. fused = self.fusion_conv(concat_sa) # [B, 4, 128] -> [B, 2, 128]
  115. # Residual connection (preserve original time-domain information)
  116. fused = fused + self.residual_weight * time_features # [B, 2, 128]
  118. return fused # [B, 2, 128] - dimension preserved
  121. class SignalEmbedding(nn.Module):
  122. """Signal embedding module for I/Q signal processing"""
  123. def __init__(self, input_dim, d_model, seq_len=1024):
  124. super(SignalEmbedding, self).__init__()
  125. self.input_dim = input_dim
  126. self.d_model = d_model
  127. self.seq_len = seq_len
  129. # Value embedding - maps I/Q signals to high-dimensional space
  130. self.value_embedding = nn.Conv1d(input_dim, d_model, kernel_size=3, padding=1, bias=False)
  132. # Position embedding - learns temporal position information
  133. self.position_embedding = nn.Parameter(torch.randn(1, seq_len, d_model) * 0.02)
  135. # Dropout
  136. self.dropout = nn.Dropout(0.1)
  138. def forward(self, x):
  139. # x: [batch_size, 2, seq_len] -> [batch_size, d_model, seq_len]
  140. x = self.value_embedding(x).transpose(1, 2) # [B, seq_len, d_model]
  142. # Add position embedding
  143. seq_len = x.size(1)
  144. pos_emb = self.position_embedding[:, :seq_len, :]
  145. x = x + pos_emb
  147. return self.dropout(x)
  150. class BioLAMR(nn.Module):
  151. """BioLAMR: GPT-2 based modulation recognition model"""
  153. def __init__(self,
  154. gpt_type='gpt2',
  155. d_model=768,
  156. gpt_layers=6,
  157. seq_len=1024,
  158. input_channels=2,
  159. num_classes=24,
  160. res_layers=4,
  161. res_dim=64,
  162. patch_size=16,
  163. use_dual_domain=True,
  164. dropout=0.1,
  165. gpu_id=0):
  166. super(BioLAMR, self).__init__()
  168. self.device = torch.device(f'cuda:{gpu_id}' if torch.cuda.is_available() else 'cpu')
  169. self.d_model = d_model
  170. self.seq_len = seq_len
  171. self.input_channels = input_channels
  172. self.num_classes = num_classes
  173. self.patch_size = patch_size
  174. self.use_dual_domain = use_dual_domain
  175. self.res_dim = res_dim
  176. self.res_layers = res_layers
  178. # Signal embedding module
  179. self.signal_embedding = SignalEmbedding(input_channels, d_model, seq_len)
  181. # GPT-2 backbone
  182. if gpt_type == 'gpt2-medium':
  183. self.gpt2 = GPT2Model.from_pretrained('gpt2-medium', output_attentions=True, output_hidden_states=True)
  184. self.gpt2.h = self.gpt2.h[:gpt_layers]
  185. self.gpt_dim = 1024
  186. elif gpt_type == 'gpt2-large':
  187. self.gpt2 = GPT2Model.from_pretrained('gpt2-large', output_attentions=True, output_hidden_states=True)
  188. self.gpt2.h = self.gpt2.h[:gpt_layers]
  189. self.gpt_dim = 1280
  190. else:
  191. self.gpt2 = GPT2Model.from_pretrained('gpt2', output_attentions=True, output_hidden_states=True)
  192. self.gpt2.h = self.gpt2.h[:gpt_layers]
  193. self.gpt_dim = 768
  195. # Freeze GPT-2 parameters, only train selected layers
  196. for i, (name, param) in enumerate(self.gpt2.named_parameters()):
  197. if 'ln' in name or 'wpe' in name: # LayerNorm and position encoding
  198. param.requires_grad = True
  199. else:
  200. param.requires_grad = False
  202. # Dual-domain processing module (optional)
  203. if use_dual_domain:
  204. # Time-domain branch
  205. self.time_branch = nn.Sequential(nn.Conv1d(input_channels, self.res_dim, 3, 1, 1))
  206. # Frequency-domain branch
  207. self.freq_branch = nn.Sequential(nn.Conv1d(input_channels, self.res_dim, 3, 1, 1))
  209. # Residual blocks
  210. for i in range(self.res_layers):
  211. self.time_branch.append(ResidualBlock1D(self.res_dim))
  212. self.freq_branch.append(ResidualBlock1D(self.res_dim))
  214. self.time_branch.append(nn.Conv1d(self.res_dim, input_channels, 3, 1, 1))
  215. self.freq_branch.append(nn.Conv1d(self.res_dim, input_channels, 3, 1, 1))
  217. # Lightweight Dual-Domain Fusion (LDDF) module
  218. self.lddf = LDDF(
  219. channels=input_channels,
  220. seq_len=seq_len,
  221. reduction=2
  222. )
  224. # Dimension alignment layer
  225. self.dim_align = nn.Linear(d_model, self.gpt_dim) if d_model != self.gpt_dim else nn.Identity()
  227. # Classification head
  228. self.classifier = nn.Sequential(
  229. nn.Linear(self.gpt_dim, 512),
  230. nn.ReLU(inplace=True),
  231. nn.Dropout(dropout),
  232. nn.Linear(512, 256),
  233. nn.ReLU(inplace=True),
  234. nn.Dropout(dropout),
  235. nn.Linear(256, num_classes)
  236. )
  238. # Global average pooling for sequence compression
  239. self.global_pool = nn.AdaptiveAvgPool1d(1)
  241. def dual_domain_processing(self, x):
  242. """
  243. Dual-domain parallel processing with lightweight attention fusion
  245. Args:
  246. x: [batch_size, 2, seq_len] - Input I/Q signal
  247. Returns:
  248. fused_features: [batch_size, 2, seq_len] - Fused features
  249. """
  250. if not self.use_dual_domain:
  251. return x
  253. # Time-domain processing
  254. time_features = self.time_branch(x) # [B, 2, seq_len]
  256. # Frequency-domain processing
  257. # Convert I/Q signal to complex for FFT
  258. x_complex = torch.complex(x[:, 0, :], x[:, 1, :]) # [B, seq_len]
  259. x_fft = torch.fft.fft(x_complex, dim=1) # FFT transform
  261. # Separate real and imaginary parts
  262. x_freq = torch.stack([torch.real(x_fft), torch.imag(x_fft)], dim=1) # [B, 2, seq_len]
  263. freq_features = self.freq_branch(x_freq) # [B, 2, seq_len]
  265. # Lightweight attention fusion (replaces simple addition)
  266. fused_features = self.lddf(time_features, freq_features) # [B, 2, seq_len]
  268. return fused_features
  270. def forward(self, x):
  271. """
  272. Forward pass
  273. Args:
  274. x: [batch_size, 2, seq_len] - I/Q signal data
  275. Returns:
  276. logits: [batch_size, num_classes] - Classification logits
  277. """
  278. batch_size, channels, seq_len = x.shape
  280. # Per-sample normalization
  281. mean = torch.mean(x, dim=[1, 2], keepdim=True)
  282. std = torch.std(x, dim=[1, 2], keepdim=True) + 1e-8
  283. x = (x - mean) / std
  285. # Dual-domain processing (optional)
  286. if self.use_dual_domain:
  287. x = self.dual_domain_processing(x)
  289. # Signal embedding
  290. embedded = self.signal_embedding(x) # [B, seq_len, d_model]
  292. # Dimension alignment to GPT-2
  293. gpt_input = self.dim_align(embedded) # [B, seq_len, gpt_dim]
  295. # Sequence modeling via GPT-2
  296. gpt_output = self.gpt2(inputs_embeds=gpt_input).last_hidden_state # [B, seq_len, gpt_dim]
  298. # Sequence compression: global average pooling
  299. pooled = gpt_output.mean(dim=1) # [B, gpt_dim]
  301. # Classification
  302. logits = self.classifier(pooled) # [B, num_classes]
  304. return logits
  307. class BioLAMRLoss(nn.Module):
  308. """BioLAMR loss function with label smoothing"""
  310. def __init__(self, num_classes=24, label_smoothing=0.1):
  311. super(BioLAMRLoss, self).__init__()
  312. self.ce_loss = nn.CrossEntropyLoss(label_smoothing=label_smoothing)
  313. self.num_classes = num_classes
  315. def forward(self, logits, targets):
  316. """
  317. Args:
  318. logits: [batch_size, num_classes]
  319. targets: [batch_size] - Class labels
  320. """
  321. return self.ce_loss(logits, targets)
  324. def create_biolamr_model(num_classes=24, gpt_type='gpt2', **kwargs):
  325. """Factory function to create a BioLAMR model"""
  326. model = BioLAMR(
  327. gpt_type=gpt_type,
  328. num_classes=num_classes,
  329. **kwargs
  330. )
  331. return model
  334. if __name__ == "__main__":
  335. # Test model
  336. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  338. # Create model
  339. model = create_biolamr_model(num_classes=24, gpt_type='gpt2').to(device)
  341. # Test input (simulating RML2018 data format)
  342. batch_size = 4
  343. seq_len = 1024
  344. test_input = torch.randn(batch_size, 2, seq_len).to(device) # [B, 2, 1024]
  346. # Forward pass test
  347. with torch.no_grad():
  348. output = model(test_input)
  349. print(f"Output shape: {output.shape}") # Expected: [4, 24]
  350. print(f"Output sample: {output[0, :5]}") # First sample's top-5 class logits
  352. # Model parameter statistics
  353. total_params = sum(p.numel() for p in model.parameters())
  354. trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
  356. print(f"\nModel statistics:")
  357. print(f"Total parameters: {total_params:,}")
  358. print(f"Trainable parameters: {trainable_params:,}")
  359. print(f"Frozen ratio: {(total_params-trainable_params)/total_params*100:.1f}%")

biolamr.py at commit 710a152, no license · at the source

Overview

Authors: Yubo Mao1, Wei Xu1, Jijia Sang2, Haoan Liu1,3
ORCID iDs: Yubo Mao, Jijia Sang, Haoan Liu
  1. China Academy of Information and Communication Technology, Beijing 100191, China; (Y.M.); (W.X.)
  2. School of Engineering and Design, Technical University of Munich, 80333 Munich, Germany
  3. University of Chinese Academy of Sciences, Beijing 100049, China
Institutions: Technical University of Munich (Germany); University of Chinese Academy of Sciences (China)
Journal: Biomimetics (Basel, Switzerland), volume 11, issue 4, article 288
Dates: received 31 March 2026; accepted 18 April 2026; published online 21 April 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3390/biomimetics11040288 · PMID 42041518 · PMCID PMC13114044 · OpenAlex W7155085791
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: methods / tools (subfield)
Methods: Spectral & time-frequency, Machine learning
Keywords: automatic modulation recognition, signal processing, large language model, communication
Topic: Wireless Signal Modulation Classification (Artificial Intelligence, Computer Science), according to OpenAlex
Citations: not cited yet (Europe PMC); 71 references in the paper

Abstract

Automatic modulation recognition (AMR) is increasingly relevant to communication-sensing front ends in robotic and human–robot collaborative systems, where reliable spectrum awareness and adaptive wireless reception are desired. However, existing methods often degrade sharply at low signal-to-noise ratios (SNRs), and large language models (LLMs) are not natively compatible with continuous I/Q signals due to the inherent modality gap. We propose BioLAMR, a GPT-2 adaptation framework for AMR inspired by the auditory system’s parallel time–frequency processing and cortical hierarchy. The framework combines bio-inspired dual-domain feature extraction with parameter-efficient LLM adaptation. BioLAMR includes three components. First, a lightweight dual-domain fusion (LDDF) module extracts complementary time- and frequency-domain features and fuses them through channel and spatial attention. Second, a convolutional embedding module converts continuous I/Q signals into GPT-2-compatible sequences without discrete tokenization. Third, a hierarchical fine-tuning strategy updates only 8.9% of parameters to preserve pretrained knowledge while adapting to modulation recognition. Experiments on the RadioML2016.10a and RadioML2016.10b benchmarks show that BioLAMR achieves overall accuracies of 64.99% and 67.43%, outperforming the strongest competing method by 2.60 and 2.47 percentage points, respectively. Under low-SNR conditions, it reaches 36.78% and 38.14%, the best results among the compared methods. Ablation studies verify the contribution of each component. These results demonstrate that combining dual-domain signal modeling with parameter-efficient GPT-2 adaptation is an effective route to robust AMR in challenging wireless environments.

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

Repository

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

saber778899/BioLAMR

License: none: the authors keep all their rights
State: the link answers, verified on 29 September 2026
Evidence: files inventoried
Commit: 710a152e65e1a0b5c669b9ccd1e2a695cbb3847b, 15 April 2026
Languages: Python (3)
Size: 6 files, 3 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README, environment (requirements.txt)
Not found: license file, CITATION.cff, tests, continuous integration, documentation
Tools: NumPy (3 files), PyTorch (3 files), Matplotlib (2 files), scikit-learn (2 files), Hugging Face Transformers (2 files)
Availability: 1 check, the latest on 29 September 2026: the link answers
  • 29 September 2026: the link answers
4 files
At the source: github.com/saber778899/BioLAMR

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:

  • 1 repository of the authors' code, each at its verified commit, with its license and how the link was found in the paper;
  • 3 scripts, each with its path and the digest of its content;
  • 9 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 Availability Statement

The datasets used in this study, including RadioML2016.10a and RadioML2016.10b, are publicly available benchmark datasets provided by DeepSig Inc. The complete training and inference source code for the proposed BioLAMR framework is publicly available at https://github.com/saber778899/BioLAMR (accessed on 17 April 2026). The repository contains the model definition, training scripts for both datasets, and environment configuration files sufficient to reproduce the main experimental results reported in this paper.

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

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 4 keywords, 54 references.

Cite

This paper

Mao, Y., Xu, W., Sang, J., & Liu, H. (2026). BioLAMR: A Biomimetically Inspired Large Language Model Adaptation Framework for Automatic Modulation Recognition. Biomimetics (Basel, Switzerland), 11(4), 288. https://doi.org/10.3390/biomimetics11040288

BibTeX

@article{mao2026biolamr,
author = {Mao, Yubo and Xu, Wei and Sang, Jijia and Liu, Haoan},
title = {{BioLAMR: A Biomimetically Inspired Large Language Model Adaptation Framework for Automatic Modulation Recognition}},
journal = {Biomimetics (Basel, Switzerland)},
year = {2026},
month = apr,
volume = {11},
number = {4},
pages = {288},
publisher = {Multidisciplinary Digital Publishing Institute (MDPI)},
issn = {2313-7673},
doi = {10.3390/biomimetics11040288},
url = {https://doi.org/10.3390/biomimetics11040288},
pmid = {42041518},
pmcid = {PMC13114044}
}

RIS

TY - JOUR
AU - Mao, Yubo
AU - Xu, Wei
AU - Sang, Jijia
AU - Liu, Haoan
TI - BioLAMR: A Biomimetically Inspired Large Language Model Adaptation Framework for Automatic Modulation Recognition
T2 - Biomimetics (Basel, Switzerland)
J2 - Biomimetics (Basel)
PY - 2026
DA - 2026/04/21
VL - 11
IS - 4
SP - 288
SN - 2313-7673
PB - Multidisciplinary Digital Publishing Institute (MDPI)
DO - 10.3390/biomimetics11040288
UR - https://doi.org/10.3390/biomimetics11040288
LA - en
ER -

CSL-JSON

{
"id": "10.3390/biomimetics11040288",
"type": "article-journal",
"title": "BioLAMR: A Biomimetically Inspired Large Language Model Adaptation Framework for Automatic Modulation Recognition",
"container-title": "Biomimetics (Basel, Switzerland)",
"author": [
{
"family": "Mao",
"given": "Yubo"
},
{
"family": "Xu",
"given": "Wei"
},
{
"family": "Sang",
"given": "Jijia"
},
{
"family": "Liu",
"given": "Haoan"
}
],
"container-title-short": "Biomimetics (Basel)",
"volume": "11",
"issue": "4",
"page": "288",
"DOI": "10.3390/biomimetics11040288",
"PMID": "42041518",
"PMCID": "PMC13114044",
"ISSN": "2313-7673",
"publisher": "Multidisciplinary Digital Publishing Institute (MDPI)",
"URL": "https://doi.org/10.3390/biomimetics11040288",
"language": "en",
"issued": {
"date-parts": [
[
2026,
4,
21
]
]
}
}

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/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: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, 1 reference
[2] doi:10.1038/s41598-026-53152-9 [code]
Layer-specific feature preference in a trained AlexNet model revealed by stylized image analysis.
Journal: Scientific reports
In common: Hugging Face Transformers, PyTorch, Matplotlib, 1 other tool, 1 reference
[3] doi:10.1371/journal.pone.0354511 [code]
TokenUNet: A new case for transformers integration in efficient and interpretable 3D UNets for brain imaging segmentation.
Journal: PloS one
In common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, methods / tools
[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, PyTorch, scikit-learn, 2 other tools, methods / tools
[5] doi:10.1038/s41586-026-10658-6 [code]
An AI system to help scientists write expert-level empirical software.
Journal: Nature
In common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, methods / tools
[6] doi:10.1038/s41467-026-72253-7 [code]
Spurious alignment between large language models and brains can emerge from non-robust methods and overlooked confounds.
Journal: Nature communications
In common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, methods / tools
[7] doi:10.1371/journal.pone.0346575 [code]
Statistically valid explainable black-box machine learning: applications in sex classification across species using brain imaging.
Journal: PloS one
In common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, methods / tools
[8] doi:10.1038/s41598-025-29587-x [code]
Evaluating EEG-to-text models through noise-based performance analysis
Journal: n/a
In common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, methods / tools
[9] doi:10.3390/biomimetics11070516 [code]
Evolutionary, Neural, or LLM-Driven Heuristic Generation? A Unified Ant Colony Optimization Benchmark for Nature-Inspired Routing Heuristics on the TSP and CVRP.
Journal: Biomimetics (Basel, Switzerland)
In common: PyTorch, scikit-learn, Matplotlib, 1 other tool, methods / tools, 1 reference
[10] doi:10.1038/s42003-026-10957-8 [code]
Brain defence by the extracellular matrix protein Cochlin.
Journal: Communications biology
In common: Hugging Face Transformers, PyTorch, scikit-learn, 2 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.