BioLAMR: A Biomimetically Inspired Large Language Model Adaptation Framework for Automatic Modulation Recognition.
6 blocks of code here have a permanent identifier (oscr:b:…), listed with the matches below: citable for good, with a page of its own. Select a match and press Cite to copy it. What a block identifier is.
The 9 matches
- [1] § 4. Experiments › 4.1. Experimental Setup › 4.1.3. Implementation Details ↔ train_radioml2016a.py, lines 165 to 313 · score 0.83 · AdamW, OneCycleLR, weight decay, hierarchical learning rate, gradients, scheduler · block
oscr:b:B7CJ364BMJ57C-K· Report a mismatch - [2] § 4. Experiments › 4.1. Experimental Setup › 4.1.3. Implementation Details ↔ train_radioml2016b.py, lines 231 to 344 · score 0.77 · AdamW, OneCycleLR, weight decay, scheduler, CPU, patience · block
oscr:b:XX3G53NE0VMYB-Y· Report a mismatch - [3] § 3. Proposed Method › 3.3. Lightweight Dual-Domain Fusion ↔ biolamr.py, lines 49 to 118 · score 0.76 · channel attention learns, lightweight dual domain, frequency domain features, concatenation, tensor, learnable · block
oscr:b:PXV29RJAK5173-S· Report a mismatch - [4] § 4. Experiments › 4.1. Experimental Setup › 4.1.3. Implementation Details ↔ biolamr.py, lines 153 to 239 · score 0.71 · classification head, lightweight dual domain, GPU, compress, hidden, dropout · block
oscr:b:X0CMRCJ5S349J-C· Report a mismatch - [5] § 3. Proposed Method › 3.1. Overall Architecture ↔ biolamr.py, lines 153 to 239 · score 0.64 · classification head, signal embedding, frequency domain, backbone, BioLAMR, global · block
oscr:b:X0CMRCJ5S349J-C· Report a mismatch - [6] § 3. Proposed Method › 3.3. Lightweight Dual-Domain Fusion ↔ biolamr.py, lines 49 to 118 · score 0.62 · concatenated feature, channel attention, sigmoid, LDDF, adaptive, lightweight · block
oscr:b:PXV29RJAK5173-S· Report a mismatch - [7] § 3. Proposed Method › 3.1. Overall Architecture ↔ train_radioml2016b.py, lines 122 to 228 · score 0.61 · signal embedding layer, classification head, trainable, BioLAMR, dual domain, sequence · block
oscr:b:9BPWJJ53R4CYH-C· Report a mismatch - [8] § 4. Experiments › 4.3. Ablation Studies › 4.3.3. Hierarchical Parameter Fine-Tuning Strategy and Pretraining Efficacy ↔ train_radioml2016b.py, lines 122 to 228 · score 0.60 · LayerNorm, parameter fine tuning, MLP, BioLAMR, unfreezes, pretrained · block
oscr:b:9BPWJJ53R4CYH-C· Report a mismatch - [9] § 4. Experiments › 4.3. Ablation Studies › 4.3.3. Hierarchical Parameter Fine-Tuning Strategy and Pretraining Efficacy ↔ train_radioml2016a.py, lines 22 to 89 · score 0.57 · LayerNorm, parameter fine tuning, MLP, BioLAMR, unfreezes, layers · block
oscr:b:CQPHFV5A0EPDF-5· 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 · 359 lines · 13 KB · no license · 4 matches
- #!/usr/bin/env python3
- """
- BioLAMR: GPT-2 based radio modulation recognition model
- """
- import numpy as np
- import torch
- import torch.nn as nn
- import torch.nn.functional as F
- from transformers import GPT2Model
- class ChannelAttention(nn.Module):
- """Channel attention mechanism"""
- def __init__(self, in_planes, ratio=4):
- super(ChannelAttention, self).__init__()
- self.avg_pool = nn.AdaptiveAvgPool1d(1) # 1D pooling for signal data
- self.max_pool = nn.AdaptiveMaxPool1d(1)
- self.fc1 = nn.Conv1d(in_planes, in_planes // ratio, 1, bias=False)
- self.relu1 = nn.ReLU()
- self.fc2 = nn.Conv1d(in_planes // ratio, in_planes, 1, bias=False)
- self.sigmoid = nn.Sigmoid()
- def forward(self, x):
- avg_out = self.fc2(self.relu1(self.fc1(self.avg_pool(x))))
- max_out = self.fc2(self.relu1(self.fc1(self.max_pool(x))))
- out = avg_out + max_out
- return self.sigmoid(out)
- class ResidualBlock1D(nn.Module):
- """1D residual block with channel attention for signal processing"""
- def __init__(self, in_planes):
- super(ResidualBlock1D, self).__init__()
- self.conv1 = nn.Conv1d(in_planes, in_planes, 3, 1, 1)
- self.conv2 = nn.Conv1d(in_planes, in_planes, 3, 1, 1)
- self.ca = ChannelAttention(in_planes=in_planes, ratio=1)
- self.relu = nn.ReLU(inplace=True)
- def forward(self, x):
- rs1 = self.relu(self.conv1(x))
- rs1 = self.conv2(rs1)
- channel_attn = self.ca(rs1)
- output = channel_attn * rs1
- rs = torch.add(x, output)
- return rs
- class LDDF(nn.Module):
- """
- Lightweight Dual-Domain Fusion (LDDF) module
- Design highlights:
- 1. Output dimension matches input [B, 2, 128], fully compatible with GPT-2
- 2. Lightweight design (~1000 params), does not interfere with GPT-2 pretrained knowledge
- 3. Channel attention + spatial attention for adaptive time-frequency feature fusion
- 4. Residual connection preserves original time-domain information
- """
- def __init__(self, channels=2, seq_len=128, reduction=2):
- super().__init__()
- self.channels = channels
- self.seq_len = seq_len
- # Channel attention - learns channel importance of time-frequency features
- self.channel_attention = nn.Sequential(
- nn.AdaptiveAvgPool1d(1), # [B, 4, 128] -> [B, 4, 1]
- nn.Conv1d(channels * 2, channels * 2 // reduction, kernel_size=1, bias=False),
- nn.ReLU(inplace=True),
- nn.Conv1d(channels * 2 // reduction, channels * 2, kernel_size=1, bias=False),
- nn.Sigmoid()
- )
- # Spatial attention - learns spatial importance of time-frequency features
- self.spatial_attention = nn.Sequential(
- nn.Conv1d(2, 1, kernel_size=7, padding=3, bias=False),
- nn.Sigmoid()
- )
- # Fusion convolution - fuses concatenated features back to original dimension
- self.fusion_conv = nn.Sequential(
- nn.Conv1d(channels * 2, channels, kernel_size=1, bias=False),
- nn.BatchNorm1d(channels),
- nn.ReLU(inplace=True)
- )
- # Learnable residual weight
- self.residual_weight = nn.Parameter(torch.tensor(0.1))
- def forward(self, time_features, freq_features):
- """
- Args:
- time_features: [batch, 2, 128] - Time-domain features
- freq_features: [batch, 2, 128] - Frequency-domain features
- Returns:
- fused: [batch, 2, 128] - Fused features (dimension unchanged, compatible with GPT-2)
- """
- # Concatenate time-frequency features
- concat = torch.cat([time_features, freq_features], dim=1) # [B, 4, 128]
- # Channel attention
- ca_weights = self.channel_attention(concat) # [B, 4, 1]
- concat_ca = concat * ca_weights # [B, 4, 128]
- # Spatial attention
- # Compute channel-wise mean and max
- avg_out = torch.mean(concat_ca, dim=1, keepdim=True) # [B, 1, 128]
- max_out, _ = torch.max(concat_ca, dim=1, keepdim=True) # [B, 1, 128]
- spatial_input = torch.cat([avg_out, max_out], dim=1) # [B, 2, 128]
- sa_weights = self.spatial_attention(spatial_input) # [B, 1, 128]
- concat_sa = concat_ca * sa_weights # [B, 4, 128]
- # Fuse to original dimension
- fused = self.fusion_conv(concat_sa) # [B, 4, 128] -> [B, 2, 128]
- # Residual connection (preserve original time-domain information)
- fused = fused + self.residual_weight * time_features # [B, 2, 128]
- return fused # [B, 2, 128] - dimension preserved
- class SignalEmbedding(nn.Module):
- """Signal embedding module for I/Q signal processing"""
- def __init__(self, input_dim, d_model, seq_len=1024):
- super(SignalEmbedding, self).__init__()
- self.input_dim = input_dim
- self.d_model = d_model
- self.seq_len = seq_len
- # Value embedding - maps I/Q signals to high-dimensional space
- self.value_embedding = nn.Conv1d(input_dim, d_model, kernel_size=3, padding=1, bias=False)
- # Position embedding - learns temporal position information
- self.position_embedding = nn.Parameter(torch.randn(1, seq_len, d_model) * 0.02)
- # Dropout
- self.dropout = nn.Dropout(0.1)
- def forward(self, x):
- # x: [batch_size, 2, seq_len] -> [batch_size, d_model, seq_len]
- x = self.value_embedding(x).transpose(1, 2) # [B, seq_len, d_model]
- # Add position embedding
- seq_len = x.size(1)
- pos_emb = self.position_embedding[:, :seq_len, :]
- x = x + pos_emb
- return self.dropout(x)
- class BioLAMR(nn.Module):
- """BioLAMR: GPT-2 based modulation recognition model"""
- def __init__(self,
- gpt_type='gpt2',
- d_model=768,
- gpt_layers=6,
- seq_len=1024,
- input_channels=2,
- num_classes=24,
- res_layers=4,
- res_dim=64,
- patch_size=16,
- use_dual_domain=True,
- dropout=0.1,
- gpu_id=0):
- super(BioLAMR, self).__init__()
- self.device = torch.device(f'cuda:{gpu_id}' if torch.cuda.is_available() else 'cpu')
- self.d_model = d_model
- self.seq_len = seq_len
- self.input_channels = input_channels
- self.num_classes = num_classes
- self.patch_size = patch_size
- self.use_dual_domain = use_dual_domain
- self.res_dim = res_dim
- self.res_layers = res_layers
- # Signal embedding module
- self.signal_embedding = SignalEmbedding(input_channels, d_model, seq_len)
- # GPT-2 backbone
- if gpt_type == 'gpt2-medium':
- self.gpt2 = GPT2Model.from_pretrained('gpt2-medium', output_attentions=True, output_hidden_states=True)
- self.gpt2.h = self.gpt2.h[:gpt_layers]
- self.gpt_dim = 1024
- elif gpt_type == 'gpt2-large':
- self.gpt2 = GPT2Model.from_pretrained('gpt2-large', output_attentions=True, output_hidden_states=True)
- self.gpt2.h = self.gpt2.h[:gpt_layers]
- self.gpt_dim = 1280
- else:
- self.gpt2 = GPT2Model.from_pretrained('gpt2', output_attentions=True, output_hidden_states=True)
- self.gpt2.h = self.gpt2.h[:gpt_layers]
- self.gpt_dim = 768
- # Freeze GPT-2 parameters, only train selected layers
- for i, (name, param) in enumerate(self.gpt2.named_parameters()):
- if 'ln' in name or 'wpe' in name: # LayerNorm and position encoding
- param.requires_grad = True
- else:
- param.requires_grad = False
- # Dual-domain processing module (optional)
- if use_dual_domain:
- # Time-domain branch
- self.time_branch = nn.Sequential(nn.Conv1d(input_channels, self.res_dim, 3, 1, 1))
- # Frequency-domain branch
- self.freq_branch = nn.Sequential(nn.Conv1d(input_channels, self.res_dim, 3, 1, 1))
- # Residual blocks
- for i in range(self.res_layers):
- self.time_branch.append(ResidualBlock1D(self.res_dim))
- self.freq_branch.append(ResidualBlock1D(self.res_dim))
- self.time_branch.append(nn.Conv1d(self.res_dim, input_channels, 3, 1, 1))
- self.freq_branch.append(nn.Conv1d(self.res_dim, input_channels, 3, 1, 1))
- # Lightweight Dual-Domain Fusion (LDDF) module
- self.lddf = LDDF(
- channels=input_channels,
- seq_len=seq_len,
- reduction=2
- )
- # Dimension alignment layer
- self.dim_align = nn.Linear(d_model, self.gpt_dim) if d_model != self.gpt_dim else nn.Identity()
- # Classification head
- self.classifier = nn.Sequential(
- nn.Linear(self.gpt_dim, 512),
- nn.ReLU(inplace=True),
- nn.Dropout(dropout),
- nn.Linear(512, 256),
- nn.ReLU(inplace=True),
- nn.Dropout(dropout),
- nn.Linear(256, num_classes)
- )
- # Global average pooling for sequence compression
- self.global_pool = nn.AdaptiveAvgPool1d(1)
- def dual_domain_processing(self, x):
- """
- Dual-domain parallel processing with lightweight attention fusion
- Args:
- x: [batch_size, 2, seq_len] - Input I/Q signal
- Returns:
- fused_features: [batch_size, 2, seq_len] - Fused features
- """
- if not self.use_dual_domain:
- return x
- # Time-domain processing
- time_features = self.time_branch(x) # [B, 2, seq_len]
- # Frequency-domain processing
- # Convert I/Q signal to complex for FFT
- x_complex = torch.complex(x[:, 0, :], x[:, 1, :]) # [B, seq_len]
- x_fft = torch.fft.fft(x_complex, dim=1) # FFT transform
- # Separate real and imaginary parts
- x_freq = torch.stack([torch.real(x_fft), torch.imag(x_fft)], dim=1) # [B, 2, seq_len]
- freq_features = self.freq_branch(x_freq) # [B, 2, seq_len]
- # Lightweight attention fusion (replaces simple addition)
- fused_features = self.lddf(time_features, freq_features) # [B, 2, seq_len]
- return fused_features
- def forward(self, x):
- """
- Forward pass
- Args:
- x: [batch_size, 2, seq_len] - I/Q signal data
- Returns:
- logits: [batch_size, num_classes] - Classification logits
- """
- batch_size, channels, seq_len = x.shape
- # Per-sample normalization
- mean = torch.mean(x, dim=[1, 2], keepdim=True)
- std = torch.std(x, dim=[1, 2], keepdim=True) + 1e-8
- x = (x - mean) / std
- # Dual-domain processing (optional)
- if self.use_dual_domain:
- x = self.dual_domain_processing(x)
- # Signal embedding
- embedded = self.signal_embedding(x) # [B, seq_len, d_model]
- # Dimension alignment to GPT-2
- gpt_input = self.dim_align(embedded) # [B, seq_len, gpt_dim]
- # Sequence modeling via GPT-2
- gpt_output = self.gpt2(inputs_embeds=gpt_input).last_hidden_state # [B, seq_len, gpt_dim]
- # Sequence compression: global average pooling
- pooled = gpt_output.mean(dim=1) # [B, gpt_dim]
- # Classification
- logits = self.classifier(pooled) # [B, num_classes]
- return logits
- class BioLAMRLoss(nn.Module):
- """BioLAMR loss function with label smoothing"""
- def __init__(self, num_classes=24, label_smoothing=0.1):
- super(BioLAMRLoss, self).__init__()
- self.ce_loss = nn.CrossEntropyLoss(label_smoothing=label_smoothing)
- self.num_classes = num_classes
- def forward(self, logits, targets):
- """
- Args:
- logits: [batch_size, num_classes]
- targets: [batch_size] - Class labels
- """
- return self.ce_loss(logits, targets)
- def create_biolamr_model(num_classes=24, gpt_type='gpt2', **kwargs):
- """Factory function to create a BioLAMR model"""
- model = BioLAMR(
- gpt_type=gpt_type,
- num_classes=num_classes,
- **kwargs
- )
- return model
- if __name__ == "__main__":
- # Test model
- device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
- # Create model
- model = create_biolamr_model(num_classes=24, gpt_type='gpt2').to(device)
- # Test input (simulating RML2018 data format)
- batch_size = 4
- seq_len = 1024
- test_input = torch.randn(batch_size, 2, seq_len).to(device) # [B, 2, 1024]
- # Forward pass test
- with torch.no_grad():
- output = model(test_input)
- print(f"Output shape: {output.shape}") # Expected: [4, 24]
- print(f"Output sample: {output[0, :5]}") # First sample's top-5 class logits
- # Model parameter statistics
- total_params = sum(p.numel() for p in model.parameters())
- trainable_params = sum(p.numel() for p in model.parameters() if p.requires_grad)
- print(f"\nModel statistics:")
- print(f"Total parameters: {total_params:,}")
- print(f"Trainable parameters: {trainable_params:,}")
- print(f"Frozen ratio: {(total_params-trainable_params)/total_params*100:.1f}%")
biolamr.py at commit 710a152, no license · at the source
Overview
- China Academy of Information and Communication Technology, Beijing 100191, China; (Y.M.); (W.X.)
- School of Engineering and Design, Technical University of Munich, 80333 Munich, Germany
- University of Chinese Academy of Sciences, Beijing 100049, China
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/
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
710a152e65e1a0b5c669b9ccd1e2a695cbb3847b, 15 April 2026Availability: 1 check, the latest on 29 September 2026: the link answers
- 29 September 2026: the link answers
4 files
- biolamr.py, Python, 359 lines, 4 matches
- train_radioml2016a.py, Python, 409 lines, 2 matches
- train_radioml2016b.py, Python, 437 lines, 3 matches
- README.md, Text, 101 lines
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://
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://
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/
url = {https://
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/
VL - 11
IS - 4
SP - 288
SN - 2313-7673
PB - Multidisciplinary Digital Publishing Institute (MDPI)
DO - 10.3390/
UR - https://
LA - en
ER -
CSL-JSON
{
"id": "10.3390/
"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":
"volume": "11",
"issue": "4",
"page": "288",
"DOI": "10.3390/
"PMID": "42041518",
"PMCID": "PMC13114044",
"ISSN": "2313-7673",
"publisher": "Multidisciplinary Digital Publishing Institute (MDPI)",
"URL": "https://
"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.1371/journal.pbio.3002366 [code]
- Many but not all deep neural network audio models capture brain responses and exhibit correspondence between model stages and brain regions.Journal: PLoS biologyIn common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, 1 reference
- [2] 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 biologyIn common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, 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 oneIn 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: NatureIn 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 communicationsIn 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 oneIn common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, methods / tools
- [8] doi:10.1038/s41597-026-06760-z [code]
- Cluster Haptic Texture Dataset: Haptic Texture Dataset with Varied Velocity-Direction Sliding Contacts.Journal: Scientific dataIn common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, methods / tools
- [9] doi:10.1038/s41597-026-07065-x [code]
- "Dense Amygdala": Extensive Complex-valued Functional MRI of the Ventral and Medial Temporal Lobe during Passive Movie Watching in Three Individuals.Journal: Scientific dataIn common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, methods / tools
- [10] 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 researchIn common: Hugging Face Transformers, PyTorch, scikit-learn, 2 other tools, methods / 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.
Claim this paper
Correct its record
Say what each link of this record is, remove the ones that are not the paper's, add the ones that are missing. The correction becomes a new version of the record, in its Versions section.
Validate its tracing map
You validate the map as this page shows it: 1 repository of the authors' code, each at its verified commit and with its license, 3 scripts, and 9 matches between paragraphs and code (see the Code and Map sections). It then receives a DOI on Zenodo, with you (your ORCID iD) and OSCR as its creators; the code itself is not deposited.
The map's fingerprint: sha256:537e60c9c2db83fc…
Add the badge to the code's README
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 -->
[](https://openscicode.org/badge/doi/10.3390/biomimetics11040288)
<!-- oscr-badge:end -->reStructuredText
.. oscr-badge:start
.. image:: https://openscicode.org/badge/doi/10.3390/biomimetics11040288.svg
:target: https://openscicode.org/badge/doi/10.3390/biomimetics11040288
:alt: OSCR
.. oscr-badge:endHTML
<!-- oscr-badge:start -->
<a href="https://openscicode.org/badge/doi/10.3390/biomimetics11040288"><img src="https://openscicode.org/badge/doi/10.3390/biomimetics11040288.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.
