OSCR

An in-sensor communication electronic textile for imperceptible and ultrarobust silent speech.

Code ↔ Paper

3 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 3 matches
  1. [1] § Results › Interactive feedback and assistant during silent speech decoding ↔ Ablation.py, lines 202–264 · score 0.74 · cross entropy loss, Weight decay, training accuracy, training loss, Ablation, epoch
  2. [2] § Results › Interactive feedback and assistant during silent speech decoding ↔ Different-loss-function.py, lines 247–294 · score 0.67 · cross entropy loss, Weight decay, loss function, configuration, Batch, smoothing
  3. [3] § Results › Interactive feedback and assistant during silent speech decoding ↔ Visualize.py, lines 17–25 · score 0.51 · help dress, Shake hand, grab, model

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 · 573 lines · 19 KB · GPL-3.0 · 1 match

  1. import os
  2. import time
  3. import numpy as np
  4. import torch
  5. import torch.nn as nn
  6. import torch.optim as optim
  7. from torch.utils.data import Dataset, DataLoader, random_split
  8. from sklearn.preprocessing import StandardScaler
  9. from sklearn.model_selection import train_test_split
  10. from sklearn.metrics import confusion_matrix, classification_report
  11. import pandas as pd
  12. import matplotlib.pyplot as plt
  13. import seaborn as sns
  14. import csv
  15. from torch.optim.lr_scheduler import CosineAnnealingLR
  16. import json
  17. from datetime import datetime
  18. import warnings
  20. warnings.filterwarnings('ignore')
  23. # ===== 1. 可配置的模型架构 =====
  24. class ConfigurableCNN(nn.Module):
  25. """可配置的一维卷积分类器，支持消融实验"""
  27. def __init__(self, input_size=3, num_classes=5,
  28. conv_layers=3,
  29. feature_sizes=None,
  30. use_batchnorm=True,
  31. dropout_rate=0.5):
  32. """
  33. input_size: 输入特征数
  34. num_classes: 分类数
  35. conv_layers: 卷积层数量
  36. feature_sizes: 各层特征数列表
  37. use_batchnorm: 是否使用BatchNorm
  38. dropout_rate: Dropout率
  39. """
  40. super().__init__()
  42. if feature_sizes is None:
  43. # 默认特征数配置
  44. feature_sizes = [64, 128, 256, 512][:conv_layers]
  46. # 确保特征数列表长度与卷积层数匹配
  47. if len(feature_sizes) < conv_layers:
  48. # 扩展特征数列表
  49. last_size = feature_sizes[-1] if feature_sizes else 64
  50. feature_sizes.extend([last_size * 2] * (conv_layers - len(feature_sizes)))
  52. self.conv_layers = conv_layers
  53. self.use_batchnorm = use_batchnorm
  54. self.feature_sizes = feature_sizes
  56. # 构建卷积层
  57. conv_blocks = []
  58. in_channels = input_size
  60. for i in range(conv_layers):
  61. out_channels = feature_sizes[i]
  63. # 卷积层
  64. conv_layer = nn.Conv1d(in_channels, out_channels,
  65. kernel_size=5 if i < 2 else 3,
  66. padding=2 if i < 2 else 1)
  67. conv_blocks.append(conv_layer)
  69. # BatchNorm层
  70. if use_batchnorm:
  71. conv_blocks.append(nn.BatchNorm1d(out_channels))
  73. # ReLU激活函数
  74. conv_blocks.append(nn.ReLU())
  76. # 池化层（最后一层使用自适应池化）
  77. if i < conv_layers - 1:
  78. conv_blocks.append(nn.MaxPool1d(kernel_size=2))
  79. else:
  80. conv_blocks.append(nn.AdaptiveMaxPool1d(1))
  82. in_channels = out_channels
  84. self.conv_sequential = nn.Sequential(*conv_blocks)
  86. # 全连接层
  87. self.dropout = nn.Dropout(dropout_rate)
  88. self.fc = nn.Linear(in_channels, num_classes)
  90. def forward(self, x):
  91. # 输入 shape: (batch, seq_len, input_size)
  92. x = x.permute(0, 2, 1) # -> (batch, input_size, seq_len)
  94. x = self.conv_sequential(x)
  95. x = x.squeeze(-1) # (batch, features)
  96. x = self.dropout(x)
  97. out = self.fc(x)
  99. return out
  102. # ===== 2. 数据集类（保持不变） =====
  103. def enhance_features(arr):
  104. """增加差分和移动平均特征"""
  105. diff = np.diff(arr, prepend=arr[0])
  106. moving_avg = np.convolve(arr, np.ones(5) / 5, mode='same')
  107. return np.stack([arr, diff, moving_avg], axis=-1)
  110. class GestureDataset(Dataset):
  111. def __init__(self, data_dir):
  112. self.data = []
  113. self.labels = []
  114. self.label_map = {'byebye': 0, 'grab on something': 1, 'shake hand': 2, 'help dress': 3, 'pass something': 4}
  115. self.label_names = list(self.label_map.keys())
  117. for label_name, label_idx in self.label_map.items():
  118. label_dir = os.path.join(data_dir, label_name)
  119. for file in os.listdir(label_dir):
  120. if file.endswith('.npy'):
  121. file_path = os.path.join(label_dir, file)
  122. arr = np.load(file_path)
  123. if arr.ndim > 1 and arr.shape[1] > 1:
  124. arr = arr[:, 1]
  125. arr = enhance_features(arr)
  126. self.data.append(arr)
  127. self.labels.append(label_idx)
  129. max_len = max(len(x) for x in self.data)
  130. self.data = [
  131. np.pad(x, ((0, int(max_len - len(x))), (0, 0)), mode='constant')
  132. if len(x) < max_len
  133. else x[:int(max_len)]
  134. for x in self.data
  135. ]
  137. self.data = np.stack(self.data)
  138. self.scaler = StandardScaler()
  139. orig_shape = self.data.shape
  140. self.data = self.scaler.fit_transform(
  141. self.data.reshape(-1, self.data.shape[-1])
  142. ).reshape(orig_shape)
  144. print(f"数据形状: {self.data.shape}")
  146. def __len__(self):
  147. return len(self.data)
  149. def __getitem__(self, idx):
  150. sample = self.data[idx].copy()
  151. noise = np.random.normal(0, 0.01, sample.shape)
  152. sample += noise
  153. mask = np.random.choice([0, 1], size=sample.shape[0], p=[0.05, 0.95])
  154. sample[mask == 0] = 0
  155. return torch.tensor(sample, dtype=torch.float32), self.labels[idx]
  158. # ===== 3. 消融实验训练函数 =====
  159. def ablation_train_model(data_dir, experiment_config, experiment_name):
  160. """
  161. 执行消融实验的训练函数
  163. Parameters:
  164. - data_dir: 数据目录
  165. - experiment_config: 实验配置字典
  166. - experiment_name: 实验名称（用于保存结果）
  167. """
  169. # 创建实验专属目录
  170. exp_dir = f"experiments/{experiment_name}"
  171. os.makedirs(exp_dir, exist_ok=True)
  173. # 保存实验配置
  174. with open(f"{exp_dir}/config.json", 'w') as f:
  175. json.dump(experiment_config, f, indent=2)
  177. # 记录训练开始时间
  178. start_time = time.perf_counter()
  180. # 准备数据集
  181. dataset = GestureDataset(data_dir)
  182. train_data, test_data = train_test_split(dataset, test_size=0.2, random_state=50)
  184. # 使用配置中的批次大小
  185. batch_size = experiment_config.get('batch_size', 32)
  186. train_loader = DataLoader(train_data, batch_size=batch_size, shuffle=True)
  187. test_loader = DataLoader(test_data, batch_size=batch_size)
  189. # 初始化模型和设备
  190. device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
  192. # 创建可配置模型
  193. model = ConfigurableCNN(
  194. input_size=3,
  195. num_classes=5,
  196. conv_layers=experiment_config.get('conv_layers', 3),
  197. feature_sizes=experiment_config.get('feature_sizes', [64, 128, 256]),
  198. use_batchnorm=experiment_config.get('use_batchnorm', True),
  199. dropout_rate=experiment_config.get('dropout_rate', 0.5)
  200. ).to(device)
  202. # 损失函数
  203. criterion = nn.CrossEntropyLoss(label_smoothing=0.1)
  205. # 优化器（使用配置中的权重衰减）
  206. weight_decay = experiment_config.get('weight_decay', 0.001)
  207. no_decay = ["bias", "LayerNorm.weight"]
  208. optimizer_grouped_parameters = [
  209. {"params": [p for n, p in model.named_parameters()
  210. if not any(nd in n for nd in no_decay)], "weight_decay": weight_decay},
  211. {"params": [p for n, p in model.named_parameters()
  212. if any(nd in n for nd in no_decay)], "weight_decay": 0.0}
  213. ]
  214. optimizer = optim.AdamW(optimizer_grouped_parameters, lr=0.001)
  216. # 学习率调度
  217. scheduler = CosineAnnealingLR(optimizer, T_max=50, eta_min=1e-5)
  219. # 训练参数
  220. epochs = experiment_config.get('epochs', 100)
  221. train_losses, train_accs, val_accs = [], [], []
  222. best_val_acc = 0.0
  224. # 创建实验专属日志文件
  225. log_file = f"{exp_dir}/training_log.csv"
  226. with open(log_file, 'w', newline='') as f:
  227. writer = csv.writer(f)
  228. writer.writerow(['epoch', 'train_loss', 'train_acc', 'val_acc', 'epoch_time', 'lr'])
  230. print(f"\n=== 开始实验: {experiment_name} ===")
  231. print(f"配置: {experiment_config}")
  233. # 训练循环
  234. for epoch in range(epochs):
  235. epoch_start = time.perf_counter()
  237. model.train()
  238. running_loss = 0.0
  239. correct = 0
  240. total = 0
  242. for inputs, labels in train_loader:
  243. inputs, labels = inputs.to(device), labels.to(device)
  245. optimizer.zero_grad()
  246. outputs = model(inputs)
  247. loss = criterion(outputs, labels)
  248. loss.backward()
  250. torch.nn.utils.clip_grad_norm_(model.parameters(), 1.0)
  251. optimizer.step()
  253. running_loss += loss.item()
  254. _, predicted = torch.max(outputs.data, 1)
  255. total += labels.size(0)
  256. correct += (predicted == labels).sum().item()
  258. scheduler.step()
  259. current_lr = scheduler.get_last_lr()[0]
  261. epoch_loss = running_loss / len(train_loader)
  262. train_acc = 100 * correct / total
  263. train_losses.append(epoch_loss)
  264. train_accs.append(train_acc)
  266. # 验证阶段
  267. model.eval()
  268. val_correct = 0
  269. val_total = 0
  270. all_preds = []
  271. all_labels = []
  273. with torch.no_grad():
  274. for inputs, labels in test_loader:
  275. inputs, labels = inputs.to(device), labels.to(device)
  276. outputs = model(inputs)
  277. _, predicted = torch.max(outputs.data, 1)
  278. val_total += labels.size(0)
  279. val_correct += (predicted == labels).sum().item()
  280. all_preds.extend(predicted.cpu().numpy())
  281. all_labels.extend(labels.cpu().numpy())
  283. val_acc = 100 * val_correct / val_total
  284. val_accs.append(val_acc)
  286. # 保存最佳模型
  287. if val_acc > best_val_acc:
  288. best_val_acc = val_acc
  289. torch.save(model.state_dict(), f"{exp_dir}/best_model.pth")
  291. epoch_time = time.perf_counter() - epoch_start
  293. # 记录日志
  294. with open(log_file, 'a', newline='') as f:
  295. writer = csv.writer(f)
  296. writer.writerow([epoch + 1, epoch_loss, train_acc, val_acc, epoch_time, current_lr])
  298. if (epoch + 1) % 20 == 0:
  299. print(f'Epoch {epoch + 1}/{epochs}, Loss: {epoch_loss:.4f}, '
  300. f'Train Acc: {train_acc:.2f}%, Val Acc: {val_acc:.2f}%')
  302. # 计算总训练时间
  303. total_time = time.perf_counter() - start_time
  304. print(f'实验完成: {experiment_name}')
  305. print(f'总训练时间: {total_time:.2f}秒')
  306. print(f'最佳验证准确率: {best_val_acc:.2f}%')
  308. # 保存训练时间
  309. with open(f'{exp_dir}/training_time.txt', 'w') as f:
  310. f.write(f"实验名称: {experiment_name}\n")
  311. f.write(f"总训练时间: {total_time:.2f}秒\n")
  312. f.write(f"最佳验证准确率: {best_val_acc:.2f}%\n")
  313. f.write(f"配置参数: {experiment_config}\n")
  315. # 保存最终模型
  316. torch.save(model.state_dict(), f"{exp_dir}/final_model.pth")
  318. # 生成混淆矩阵和分类报告
  319. cm = confusion_matrix(all_labels, all_preds)
  321. plt.figure(figsize=(10, 8))
  322. sns.heatmap(cm, annot=True, fmt='d', cmap='Blues',
  323. xticklabels=dataset.label_names,
  324. yticklabels=dataset.label_names)
  325. plt.title(f'混淆矩阵 - {experiment_name}')
  326. plt.xlabel('预测标签')
  327. plt.ylabel('真实标签')
  328. plt.savefig(f'{exp_dir}/confusion_matrix.png')
  329. plt.close()
  331. cm_df = pd.DataFrame(cm, index=dataset.label_names, columns=dataset.label_names)
  332. cm_df.to_csv(f'{exp_dir}/confusion_matrix.csv')
  334. report = classification_report(all_labels, all_preds, target_names=dataset.label_names)
  335. with open(f'{exp_dir}/classification_report.txt', 'w') as f:
  336. f.write(report)
  338. # 训练曲线可视化
  339. plt.figure(figsize=(12, 4))
  340. plt.subplot(1, 2, 1)
  341. plt.plot(train_losses)
  342. plt.title('训练损失')
  343. plt.xlabel('训练轮次')
  345. plt.subplot(1, 2, 2)
  346. plt.plot(train_accs, label='训练准确率')
  347. plt.plot(val_accs, label='验证准确率')
  348. plt.title('准确率曲线')
  349. plt.xlabel('训练轮次')
  350. plt.legend()
  351. plt.tight_layout()
  352. plt.savefig(f'{exp_dir}/training_curve.png')
  353. plt.close()
  355. # 保存训练曲线数据
  356. curve_df = pd.DataFrame({
  357. 'epoch': range(1, epochs + 1),
  358. 'train_loss': train_losses,
  359. 'train_acc': train_accs,
  360. 'val_acc': val_accs
  361. })
  362. curve_df.to_csv(f'{exp_dir}/training_curve_data.csv', index=False)
  364. return {
  365. 'experiment_name': experiment_name,
  366. 'config': experiment_config,
  367. 'best_val_acc': best_val_acc,
  368. 'total_time': total_time,
  369. 'final_val_acc': val_accs[-1] if val_accs else 0
  370. }
  373. # ===== 4. 消融实验主函数 =====
  374. def run_ablation_experiments(data_dir):
  375. """运行完整的消融实验系列"""
  377. # 定义消融实验配置
  378. ablation_configs = [
  379. # 基线配置
  380. {
  381. 'name': 'baseline',
  382. 'conv_layers': 3,
  383. 'feature_sizes': [64, 128, 256],
  384. 'use_batchnorm': True,
  385. 'weight_decay': 0.001,
  386. 'batch_size': 64,
  387. 'epochs': 140
  388. },
  390. # 卷积层数量消融
  391. {
  392. 'name': 'conv_layers_2',
  393. 'conv_layers': 2,
  394. 'feature_sizes': [64, 128],
  395. 'use_batchnorm': True,
  396. 'weight_decay': 0.001,
  397. 'batch_size': 64,
  398. 'epochs': 120
  399. },
  400. {
  401. 'name': 'conv_layers_4',
  402. 'conv_layers': 4,
  403. 'feature_sizes': [64, 128, 256, 512],
  404. 'use_batchnorm': True,
  405. 'weight_decay': 0.001,
  406. 'batch_size': 64,
  407. 'epochs': 140
  408. },
  410. # 特征数消融
  411. {
  412. 'name': 'features_small',
  413. 'conv_layers': 3,
  414. 'feature_sizes': [32, 64, 128],
  415. 'use_batchnorm': True,
  416. 'weight_decay': 0.001,
  417. 'batch_size': 64,
  418. 'epochs': 140
  419. },
  420. {
  421. 'name': 'features_large',
  422. 'conv_layers': 3,
  423. 'feature_sizes': [128, 256, 512],
  424. 'use_batchnorm': True,
  425. 'weight_decay': 0.001,
  426. 'batch_size': 64,
  427. 'epochs': 140
  428. },
  430. # BatchNorm消融
  431. {
  432. 'name': 'no_batchnorm',
  433. 'conv_layers': 3,
  434. 'feature_sizes': [64, 128, 256],
  435. 'use_batchnorm': False,
  436. 'weight_decay': 0.001,
  437. 'batch_size': 64,
  438. 'epochs': 140
  439. },
  441. # 正则化率消融
  442. {
  443. 'name': 'weight_decay_high',
  444. 'conv_layers': 3,
  445. 'feature_sizes': [64, 128, 256],
  446. 'use_batchnorm': True,
  447. 'weight_decay': 0.01,
  448. 'batch_size': 64,
  449. 'epochs': 140
  450. },
  451. {
  452. 'name': 'weight_decay_low',
  453. 'conv_layers': 3,
  454. 'feature_sizes': [64, 128, 256],
  455. 'use_batchnorm': True,
  456. 'weight_decay': 0.0001,
  457. 'batch_size': 64,
  458. 'epochs': 140
  459. },
  461. # 批次大小消融
  462. {
  463. 'name': 'batch_size_16',
  464. 'conv_layers': 3,
  465. 'feature_sizes': [64, 128, 256],
  466. 'use_batchnorm': True,
  467. 'weight_decay': 0.001,
  468. 'batch_size': 16,
  469. 'epochs': 140
  470. },
  471. {
  472. 'name': 'batch_size_64',
  473. 'conv_layers': 3,
  474. 'feature_sizes': [64, 128, 256],
  475. 'use_batchnorm': True,
  476. 'weight_decay': 0.001,
  477. 'batch_size': 64,
  478. 'epochs': 140
  479. }
  480. ]
  482. # 运行所有实验
  483. results = []
  484. timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
  486. for config in ablation_configs:
  487. experiment_name = f"{timestamp}_{config['name']}"
  488. result = ablation_train_model(data_dir, config, experiment_name)
  489. results.append(result)
  491. # 短暂暂停，避免文件写入冲突
  492. time.sleep(1)
  494. # 生成消融实验总结报告
  495. generate_ablation_summary(results, timestamp)
  497. return results
  500. def generate_ablation_summary(results, timestamp):
  501. """生成消融实验总结报告"""
  503. summary_dir = f"experiments/summary_{timestamp}"
  504. os.makedirs(summary_dir, exist_ok=True)
  506. # 创建结果汇总表格
  507. summary_data = []
  508. for result in results:
  509. summary_data.append({
  510. '实验名称': result['experiment_name'],
  511. '卷积层数': result['config'].get('conv_layers', 3),
  512. '特征数': str(result['config'].get('feature_sizes', [64, 128, 256])),
  513. '使用BatchNorm': result['config'].get('use_batchnorm', True),
  514. '权重衰减': result['config'].get('weight_decay', 0.001),
  515. '批次大小': result['config'].get('batch_size', 32),
  516. '最佳验证准确率': f"{result['best_val_acc']:.2f}%",
  517. '最终验证准确率': f"{result['final_val_acc']:.2f}%",
  518. '总训练时间': f"{result['total_time']:.2f}秒"
  519. })
  521. summary_df = pd.DataFrame(summary_data)
  522. summary_df.to_csv(f"{summary_dir}/ablation_summary.csv", index=False, encoding='utf-8-sig')
  524. # 创建可视化比较图
  525. plt.figure(figsize=(15, 10))
  527. # 准确率比较
  528. plt.subplot(2, 2, 1)
  529. names = [r['experiment_name'].split('_')[-1] for r in results]
  530. accuracies = [r['best_val_acc'] for r in results]
  531. plt.bar(names, accuracies)
  532. plt.title('各实验最佳验证准确率比较')
  533. plt.xticks(rotation=45)
  534. plt.ylabel('准确率 (%)')
  536. # 训练时间比较
  537. plt.subplot(2, 2, 2)
  538. times = [r['total_time'] for r in results]
  539. plt.bar(names, times)
  540. plt.title('各实验总训练时间比较')
  541. plt.xticks(rotation=45)
  542. plt.ylabel('时间 (秒)')
  544. # 准确率-时间散点图
  545. plt.subplot(2, 2, 3)
  546. plt.scatter(times, accuracies)
  547. for i, name in enumerate(names):
  548. plt.annotate(name, (times[i], accuracies[i]))
  549. plt.xlabel('训练时间 (秒)')
  550. plt.ylabel('准确率 (%)')
  551. plt.title('准确率 vs 训练时间')
  553. plt.tight_layout()
  554. plt.savefig(f"{summary_dir}/ablation_comparison.png", dpi=300, bbox_inches='tight')
  555. plt.close()
  557. print(f"\n=== 消融实验总结已保存至: {summary_dir} ===")
  558. print(summary_df.to_string(index=False))
  561. # ===== 5. 主程序 =====
  562. if __name__ == '__main__':
  563. data_dir = '.' # 当前目录下的子文件夹
  565. print("开始运行消融实验...")
  566. print("实验配置: 卷积层数量, 特征数, BatchNorm, 正则化率, 批次大小")
  568. # 运行消融实验
  569. results = run_ablation_experiments(data_dir)
  571. print("\n=== 所有实验完成 ===")
  572. print("各实验结果已分别保存到 experiments/ 目录下")
  573. print("总结报告已生成，包含准确率和训练时间的比较")

Ablation.py, under GPL-3.0 · at the source

Overview

Authors: Yuchen Lin1, Shifan Yu1, Lei Liu1, Huasen Wang1, Yuhui Wang1, Mengting Jiang1, Gantang Su1, Yue Yu1, Hongyu Chen1, Yanhao Luo1, Zijian Huang1, Chenwei Li1, Junzhi Yu1, Ziquan Guo1, Yuhan Su1, Zhong Chen1, Lichao Yang2, Zhenyu Zhao3, Qingliang Liao4,5, Yuanjin Zheng6, Xinqin Liao1
ORCID iDs: Yuchen Lin, Zhong Chen, Zhenyu Zhao, Xinqin Liao
  1. Department of Electronic Science, Xiamen University,Xiamen, China
  2. School of Medicine, Xiamen University,Xiamen, China
  3. Department of Electrical and Computer Engineering, National University of Singapore,Singapore, Singapore
  4. Academy for Advanced Interdisciplinary Science and Technology, Key Laboratory of Advanced Materials and Devices for Post-Moore Chips Ministry of Education, University of Science and Technology Beijing,Beijing, China
  5. Beijing Key Laboratory for Advanced Energy Materials and Technologies, School of Materials Science and Engineering, University of Science and Technology Beijing,Beijing, China
  6. School of Electrical and Electronic Engineering, Nanyang Technological University,Singapore, Singapore
Institutions: Xiamen University (China); National University of Singapore (Singapore); University of Science and Technology Beijing (China); Nanyang Technological University (Singapore)
Journal: Nature communications, volume 17, issue 1, article 7182
Dates: received 27 January 2026; accepted 22 May 2026; published online 4 June 2026
Type: Research article · Language: English
License: CC BY-NC-ND
Identifiers: DOI 10.1038/s41467-026-74035-7 · PMID 42243139 · PMCID PMC13396449 · OpenAlex W7163538680
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: human (organism), cognitive (subfield)
Methods: Spectral & time-frequency, Machine learning, Smoothing, state filtering, decompositions, Physiology & signal measures
Keywords: Electrical and electronic engineering, Sensors and biosensors, Electronics, photonics and device physics
MeSH: Speech*, Textiles*, Humans (* major topic)
Topic: Advanced Sensor and Energy Harvesting Materials (Biomedical Engineering, Engineering), according to OpenAlex
Citations: cited by 1 paper (Europe PMC); 52 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 3 matches between paragraphs and lines of code.

Zenodo 20222608

License: GPL-3.0
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Size: 1 file
Software Heritage: not checked
Found in: “Code availability”
Not found: README, license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: NumPy (6 files), PyTorch (5 files), Matplotlib (4 files), pandas (4 files), scikit-learn (4 files), seaborn (4 files), SciPy (2 files)
Availability: 1 check, the latest on 27 September 2026: the link answers (HTTP 200)
  • 27 September 2026: the link answers (HTTP 200)
6 files
At the source: zenodo.org/records/20222608

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/s41467-026-74035-7.

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

  • no repository, dataset or request procedure was recognized in it

Read it in the paper: doi.org/10.1038/s41467-026-74035-7.

Versions

The history of this record: each version stored by the harvester or made by a correction of its authors or of the maintainers of its code, and what changed in its facts. The texts of the paper (its abstract, its availability statements) are not part of it; versions that changed only those are not listed.

Version 1, 27 September 2026: the first record

Recorded: type, language, journal, volume, issue, pages, dates, 21 authors, 3 keywords, 3 MeSH terms, 48 references.

Cite

This paper

Lin, Y., Yu, S., Liu, L., Wang, H., Wang, Y., Jiang, M., Su, G., Yu, Y., Chen, H., Luo, Y., Huang, Z., Li, C., Yu, J., Guo, Z., Su, Y., Chen, Z., Yang, L., Zhao, Z., Liao, Q., . . . Liao, X. (2026). An in-sensor communication electronic textile for imperceptible and ultrarobust silent speech. Nature communications, 17(1), 7182. https://doi.org/10.1038/s41467-026-74035-7

BibTeX

@article{lin2026sensor,
author = {Lin, Yuchen and Yu, Shifan and Liu, Lei and Wang, Huasen and Wang, Yuhui and Jiang, Mengting and Su, Gantang and Yu, Yue and Chen, Hongyu and Luo, Yanhao and Huang, Zijian and Li, Chenwei and Yu, Junzhi and Guo, Ziquan and Su, Yuhan and Chen, Zhong and Yang, Lichao and Zhao, Zhenyu and Liao, Qingliang and Zheng, Yuanjin and Liao, Xinqin},
title = {{An in-sensor communication electronic textile for imperceptible and ultrarobust silent speech}},
journal = {Nature communications},
year = {2026},
month = jun,
volume = {17},
number = {1},
pages = {7182},
publisher = {Nature Publishing Group},
issn = {2041-1723},
doi = {10.1038/s41467-026-74035-7},
url = {https://doi.org/10.1038/s41467-026-74035-7},
pmid = {42243139},
pmcid = {PMC13396449}
}

RIS

TY - JOUR
AU - Lin, Yuchen
AU - Yu, Shifan
AU - Liu, Lei
AU - Wang, Huasen
AU - Wang, Yuhui
AU - Jiang, Mengting
AU - Su, Gantang
AU - Yu, Yue
AU - Chen, Hongyu
AU - Luo, Yanhao
AU - Huang, Zijian
AU - Li, Chenwei
AU - Yu, Junzhi
AU - Guo, Ziquan
AU - Su, Yuhan
AU - Chen, Zhong
AU - Yang, Lichao
AU - Zhao, Zhenyu
AU - Liao, Qingliang
AU - Zheng, Yuanjin
AU - Liao, Xinqin
TI - An in-sensor communication electronic textile for imperceptible and ultrarobust silent speech
T2 - Nature communications
J2 - Nat Commun
PY - 2026
DA - 2026/06/04
VL - 17
IS - 1
SP - 7182
SN - 2041-1723
PB - Nature Publishing Group
DO - 10.1038/s41467-026-74035-7
UR - https://doi.org/10.1038/s41467-026-74035-7
LA - en
ER -

CSL-JSON

{
"id": "10.1038/s41467-026-74035-7",
"type": "article-journal",
"title": "An in-sensor communication electronic textile for imperceptible and ultrarobust silent speech",
"container-title": "Nature communications",
"author": [
{
"family": "Lin",
"given": "Yuchen"
},
{
"family": "Yu",
"given": "Shifan"
},
{
"family": "Liu",
"given": "Lei"
},
{
"family": "Wang",
"given": "Huasen"
},
{
"family": "Wang",
"given": "Yuhui"
},
{
"family": "Jiang",
"given": "Mengting"
},
{
"family": "Su",
"given": "Gantang"
},
{
"family": "Yu",
"given": "Yue"
},
{
"family": "Chen",
"given": "Hongyu"
},
{
"family": "Luo",
"given": "Yanhao"
},
{
"family": "Huang",
"given": "Zijian"
},
{
"family": "Li",
"given": "Chenwei"
},
{
"family": "Yu",
"given": "Junzhi"
},
{
"family": "Guo",
"given": "Ziquan"
},
{
"family": "Su",
"given": "Yuhan"
},
{
"family": "Chen",
"given": "Zhong"
},
{
"family": "Yang",
"given": "Lichao"
},
{
"family": "Zhao",
"given": "Zhenyu"
},
{
"family": "Liao",
"given": "Qingliang"
},
{
"family": "Zheng",
"given": "Yuanjin"
},
{
"family": "Liao",
"given": "Xinqin"
}
],
"container-title-short": "Nat Commun",
"volume": "17",
"issue": "1",
"page": "7182",
"DOI": "10.1038/s41467-026-74035-7",
"PMID": "42243139",
"PMCID": "PMC13396449",
"ISSN": "2041-1723",
"publisher": "Nature Publishing Group",
"URL": "https://doi.org/10.1038/s41467-026-74035-7",
"language": "en",
"issued": {
"date-parts": [
[
2026,
6,
4
]
]
}
}

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.3390/brainsci16030300 [code]
Source-Free Active Domain Adaptation for Brain Tumor Segmentation via Mamba and Region-Level Uncertainty.
Journal: Brain sciences
In common: author Zhong Chen
[2] doi:10.1038/s41467-026-76168-1 [code]
An intelligent electronic-textile system with adaptive sweat-regulation for continuous exercise-induced fatigue monitoring.
Journal: Nature communications
In common: 1 reference
[3] doi:10.1038/s41467-026-70093-z
Conformal and adhesive gel for stable electrophysiology on hairy animals without shaving.
Journal: Nature communications
In common: 1 reference
[4] doi:10.1186/s12974-026-03844-w
SGK1 inhibition supports neuroprotection in spinal cord injury by suppressing oxidative stress and AIM2 activation via FoxO1 mediated mitophagy.
Journal: Journal of neuroinflammation
In common: 1 reference

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.