OSCR

Self-Supervised Stacked Masked Denoising Autoencoder (S<sup>2</sup>MDAE) for Brain MRI Denoising and Feature Learning.

Code ↔ Paper

5 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 5 matches
  1. [1] § 2. Methods › 2.1. StackedMDAE Network Architecture › 2.1.4. Classifier Head ↔ new.py, lines 243–294 · score 0.65 · AdaptiveAvgPool2d, ReLU, MDAE blocks, Flatten, Dropout, Linear
  2. [2] § 2. Methods › 2.1. StackedMDAE Network Architecture › 2.1.3. MDAE Block Design ↔ new.py, lines 243–294 · score 0.62 · ReLU, MDAE block, S2MDAE, latent, encoding, dropout
  3. [3] § 2. Methods › 2.1. StackedMDAE Network Architecture › 2.1.4. Classifier Head ↔ new_one.py, lines 147–178 · score 0.57 · AdaptiveAvgPool2d, ReLU, Flatten, Dropout, Linear, MDAE
  4. [4] § 2. Methods › 2.2. Two-Phase Training Strategy › 2.2.1. Pre-Training Phase ↔ new.py, lines 316–369 · score 0.54 · ReduceLROnPlateau, training loss, scheduler, optimizer, reconstruction, blocks
  5. [5] § 3. Experiment › 3.1. Experimental Setup › 3.1.3. Implementation Details ↔ SimCLR.py, lines 52–64 · score 0.52 · random horizontal flipping, grayscale, resized, trained

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 · 734 lines · 25 KB · no license · 3 matches

  1. import torch
  2. import torch.nn as nn
  3. import torch.nn.functional as F
  4. import torch.optim as optim
  5. from torch.utils.data import DataLoader, Dataset
  6. from torchvision import transforms, models
  7. from torchvision.utils import save_image
  9. import os
  10. import numpy as np
  11. from PIL import Image
  12. import matplotlib.pyplot as plt
  13. from sklearn.model_selection import train_test_split
  14. from sklearn.metrics import classification_report, confusion_matrix
  15. import time
  16. import copy
  17. import random
  19. # 设置设备
  20. device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
  21. print(f"使用设备: {device}")
  24. # 超参数配置
  25. class Config:
  26. # 数据参数
  27. data_path = r"E:\数据集\脑部影像\飞桨\Brain Tumor MRI Dataset_baiban" # 替换为实际路径
  28. batch_size = 16 # 减小批次大小以适应不同尺寸
  29. patch_size = 16
  30. num_workers = 2
  32. # 模型参数
  33. latent_dim = 128
  34. hidden_dims = [64, 128, 256] # 每层的隐藏维度
  35. dropout_rate = 0.1
  37. # 训练参数
  38. num_epochs_pretrain = 30
  39. num_epochs_finetune = 50
  40. learning_rate_pretrain = 1e-5
  41. learning_rate_finetune = 5e-6
  42. weight_decay = 1e-5
  44. # 噪声和掩码参数
  45. mask_ratio = 0.75 # 掩码比例
  46. noise_std = 0.1 # 高斯噪声标准差
  48. # 图像处理参数
  49. target_size = 224 # 统一调整到的尺寸
  51. # 保存路径
  52. save_dir = r"E:\数据集\脑部影像\飞桨\Brain Tumor MRI Dataset_baiban_new"
  53. model_dir = "./models"
  56. config = Config()
  58. # 创建保存目录
  59. os.makedirs(config.save_dir, exist_ok=True)
  60. os.makedirs(config.model_dir, exist_ok=True)
  63. # 自定义数据集类
  64. class BrainMRIDataset(Dataset):
  65. def __init__(self, root_dir, transform=None, is_train=True, add_noise=True):
  66. self.root_dir = root_dir
  67. self.transform = transform
  68. self.add_noise = add_noise
  69. self.classes = ['glioma', 'meningioma', 'notumor', 'pituitary']
  70. self.class_to_idx = {cls_name: i for i, cls_name in enumerate(self.classes)}
  72. self.image_paths = []
  73. self.labels = []
  75. # 遍历目录收集图像路径和标签
  76. for cls_name in self.classes:
  77. cls_dir = os.path.join(root_dir, cls_name)
  78. if os.path.exists(cls_dir):
  79. for img_name in os.listdir(cls_dir):
  80. if img_name.endswith(('.png', '.jpg', '.jpeg')):
  81. self.image_paths.append(os.path.join(cls_dir, img_name))
  82. self.labels.append(self.class_to_idx[cls_name])
  84. print(f"在 {root_dir} 中找到 {len(self.image_paths)} 张图像")
  86. def __len__(self):
  87. return len(self.image_paths)
  89. def __getitem__(self, idx):
  90. img_path = self.image_paths[idx]
  91. image = Image.open(img_path).convert('L') # 转换为灰度图
  93. # 调整图像大小
  94. image = image.resize((config.target_size, config.target_size))
  96. # 应用转换
  97. if self.transform:
  98. image_tensor = self.transform(image)
  99. else:
  100. image_tensor = transforms.ToTensor()(image)
  102. # 添加噪声（如果启用）
  103. clean_image = image_tensor.clone()
  104. if self.add_noise:
  105. noise = torch.randn_like(clean_image) * config.noise_std
  106. noisy_image = clean_image + noise
  107. noisy_image = torch.clamp(noisy_image, 0, 1)
  108. else:
  109. noisy_image = clean_image.clone()
  111. return noisy_image, clean_image, self.labels[idx]
  114. # 数据增强和转换
  115. train_transform = transforms.Compose([
  116. transforms.RandomHorizontalFlip(),
  117. transforms.RandomRotation(10),
  118. transforms.ToTensor(),
  119. ])
  121. val_transform = transforms.Compose([
  122. transforms.ToTensor(),
  123. ])
  125. # 创建数据加载器
  126. print("正在创建数据集...")
  127. train_dataset = BrainMRIDataset(
  128. root_dir=os.path.join(config.data_path, "train"),
  129. transform=train_transform,
  130. add_noise=True
  131. )
  133. val_dataset = BrainMRIDataset(
  134. root_dir=os.path.join(config.data_path, "val"),
  135. transform=val_transform,
  136. add_noise=True
  137. )
  139. print("正在创建数据加载器...")
  140. train_loader = DataLoader(
  141. train_dataset,
  142. batch_size=config.batch_size,
  143. shuffle=True,
  144. num_workers=config.num_workers
  145. )
  147. val_loader = DataLoader(
  148. val_dataset,
  149. batch_size=config.batch_size,
  150. shuffle=False,
  151. num_workers=config.num_workers
  152. )
  155. # 编码器块
  156. class EncoderBlock(nn.Module):
  157. def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1):
  158. super(EncoderBlock, self).__init__()
  159. self.conv = nn.Conv2d(in_channels, out_channels, kernel_size, stride, padding)
  160. self.bn = nn.BatchNorm2d(out_channels)
  161. self.relu = nn.ReLU(inplace=True)
  162. self.dropout = nn.Dropout2d(config.dropout_rate)
  164. def forward(self, x):
  165. x = self.conv(x)
  166. x = self.bn(x)
  167. x = self.relu(x)
  168. x = self.dropout(x)
  169. return x
  172. # 解码器块
  173. class DecoderBlock(nn.Module):
  174. def __init__(self, in_channels, out_channels, kernel_size=3, stride=1, padding=1, output_padding=0):
  175. super(DecoderBlock, self).__init__()
  176. self.conv_transpose = nn.ConvTranspose2d(in_channels, out_channels, kernel_size, stride, padding,
  177. output_padding)
  178. self.bn = nn.BatchNorm2d(out_channels)
  179. self.relu = nn.ReLU(inplace=True)
  180. self.dropout = nn.Dropout2d(config.dropout_rate)
  182. def forward(self, x):
  183. x = self.conv_transpose(x)
  184. x = self.bn(x)
  185. x = self.relu(x)
  186. x = self.dropout(x)
  187. return x
  190. # 单个掩码去噪自编码器块
  191. class MDAE_Block(nn.Module):
  192. def __init__(self, in_channels, latent_dim):
  193. super(MDAE_Block, self).__init__()
  194. self.in_channels = in_channels
  195. self.latent_dim = latent_dim
  197. # 编码器
  198. self.encoder = nn.Sequential(
  199. EncoderBlock(in_channels, 64),
  200. EncoderBlock(64, 128),
  201. EncoderBlock(128, latent_dim),
  202. )
  204. # 可学习的掩码token
  205. self.mask_token = nn.Parameter(torch.randn(1, latent_dim, 1, 1))
  207. # 解码器
  208. self.decoder = nn.Sequential(
  209. DecoderBlock(latent_dim, 128),
  210. DecoderBlock(128, 64),
  211. nn.Conv2d(64, in_channels, kernel_size=3, stride=1, padding=1),
  212. nn.Sigmoid() # 输出在0-1之间
  213. )
  215. def forward(self, x, mask=None):
  216. batch_size, _, h, w = x.shape
  218. # 如果没有提供掩码，创建一个全1的掩码
  219. if mask is None:
  220. mask = torch.ones(batch_size, 1, h, w, device=x.device)
  222. # 应用掩码
  223. masked_x = x * mask
  225. # 编码
  226. encoded = self.encoder(masked_x)
  228. # 准备解码器输入：用mask_token填充被掩码的位置
  229. _, c, eh, ew = encoded.shape
  230. mask_token_expanded = self.mask_token.expand(batch_size, -1, eh, ew)
  232. # 调整掩码大小以匹配编码后的特征
  233. resized_mask = F.interpolate(mask, size=(eh, ew), mode='nearest')
  234. decoder_input = encoded * resized_mask + mask_token_expanded * (1 - resized_mask)
  236. # 解码
  237. reconstructed = self.decoder(decoder_input)
  238. reconstructed = F.interpolate(reconstructed, size=(h, w), mode='bilinear', align_corners=False)
  240. return reconstructed, encoded
  243. # 堆叠的S²MDAE模型
  244. class StackedMDAE(nn.Module):
  245. def __init__(self, hidden_dims, num_classes=4):
  246. super(StackedMDAE, self).__init__()
  247. self.hidden_dims = hidden_dims
  248. self.num_classes = num_classes
  250. # 创建多个MDAE块
  251. self.blocks = nn.ModuleList()
  252. in_channels = 1 # 输入是灰度图像
  254. for i, latent_dim in enumerate(hidden_dims):
  255. self.blocks.append(MDAE_Block(in_channels, latent_dim))
  256. in_channels = latent_dim # 下一层的输入是当前层的潜在维度
  258. # 分类头
  259. self.classifier = nn.Sequential(
  260. nn.AdaptiveAvgPool2d(1),
  261. nn.Flatten(),
  262. nn.Linear(hidden_dims[-1], 512),
  263. nn.ReLU(inplace=True),
  264. nn.Dropout(config.dropout_rate),
  265. nn.Linear(512, num_classes)
  266. )
  268. def forward(self, x, masks=None):
  269. if masks is None:
  270. masks = [None] * len(self.blocks)
  272. reconstructions = []
  273. features = []
  275. # 逐层前向传播
  276. for i, block in enumerate(self.blocks):
  277. recon, feat = block(x, masks[i])
  278. reconstructions.append(recon)
  279. features.append(feat)
  280. x = feat # 下一层的输入是当前层的特征
  282. # 分类
  283. cls_output = self.classifier(features[-1])
  285. return reconstructions, features, cls_output
  287. def encode(self, x):
  288. """提取特征用于下游任务"""
  289. features = []
  290. for i, block in enumerate(self.blocks):
  291. _, feat = block.encoder(x)
  292. features.append(feat)
  293. x = feat
  294. return features
  297. # 生成随机掩码
  298. def generate_mask(batch_size, height, width, mask_ratio=0.75):
  299. """生成随机二进制掩码"""
  300. num_pixels = height * width
  301. num_mask = int(num_pixels * mask_ratio)
  303. masks = []
  304. for _ in range(batch_size):
  305. # 创建全1掩码
  306. mask = torch.ones(1, height, width, device=device)
  307. # 随机选择要掩码的位置
  308. mask_indices = torch.randperm(num_pixels, device=device)[:num_mask]
  309. # 将选中的位置设置为0
  310. mask.view(-1)[mask_indices] = 0
  311. masks.append(mask)
  313. return torch.stack(masks)
  316. # 训练函数 - 预训练阶段
  317. def pretrain(model, train_loader, val_loader, optimizer, criterion, num_epochs):
  318. model.train()
  319. best_loss = float('inf')
  320. train_losses = []
  321. val_losses = []
  323. # 添加学习率调度器
  324. scheduler = torch.optim.lr_scheduler.ReduceLROnPlateau(
  325. optimizer, mode='min', factor=0.5, patience=3
  326. )
  328. for epoch in range(num_epochs):
  329. epoch_start_time = time.time()
  330. running_loss = 0.0
  332. # 训练阶段
  333. for i, (noisy_imgs, clean_imgs, _) in enumerate(train_loader):
  334. noisy_imgs = noisy_imgs.to(device)
  335. clean_imgs = clean_imgs.to(device)
  337. # 为每一层生成掩码 - 使用输入图像的大小
  338. masks = []
  339. h, w = noisy_imgs.shape[2], noisy_imgs.shape[3]
  341. for _ in range(len(model.blocks)):
  342. mask = generate_mask(noisy_imgs.size(0), h, w, config.mask_ratio)
  343. masks.append(mask)
  345. # 前向传播
  346. optimizer.zero_grad()
  347. reconstructions, features, _ = model(noisy_imgs, masks)
  349. # 计算重建损失
  350. loss = 0
  351. for j, recon in enumerate(reconstructions):
  352. mask = masks[j]
  353. resized_mask = F.interpolate(mask, size=recon.shape[2:], mode='nearest')
  355. # 确保目标与重建输出的通道数相同
  356. if j == 0:
  357. # 扩展原始图像的通道数以匹配重建输出
  358. expanded_clean_imgs = clean_imgs.expand_as(recon)
  359. target = expanded_clean_imgs
  360. else:
  361. # 后续层应与前一层的特征比较
  362. target = features[j - 1]
  363. if target.shape[1] != recon.shape[1]:
  364. # 如果通道数不匹配，使用1x1卷积调整
  365. if not hasattr(model, f'adaptor_{j}'):
  366. setattr(model, f'adaptor_{j}',
  367. nn.Conv2d(target.shape[1], recon.shape[1], 1).to(device))
  368. adaptor = getattr(model, f'adaptor_{j}')
  369. target = adaptor(target)
  371. # 调整目标大小以匹配重建输出
  372. if target.shape[2:] != recon.shape[2:]:
  373. target = F.interpolate(target, size=recon.shape[2:], mode='nearest')
  375. # 只计算被掩码区域的MSE损失
  376. mask_loss = criterion(recon * (1 - resized_mask), target * (1 - resized_mask))
  377. loss += mask_loss
  379. # 检查梯度范数
  380. loss.backward()
  382. total_norm = 0
  383. for p in model.parameters():
  384. if p.grad is not None:
  385. param_norm = p.grad.data.norm(2)
  386. total_norm += param_norm.item() ** 2
  387. total_norm = total_norm ** (1. / 2)
  389. # 如果梯度范数过大，跳过这个批次的更新
  390. if total_norm > 100:
  391. print(f'Skipping batch due to large gradient: {total_norm:.4f}')
  392. optimizer.zero_grad()
  393. continue
  395. # 梯度裁剪
  396. torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
  397. optimizer.step()
  399. running_loss += loss.item()
  401. if i % 10 == 0:
  402. print(
  403. f'Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{len(train_loader)}], Loss: {loss.item():.4f}, Grad Norm: {total_norm:.4f}')
  405. # 验证阶段
  406. val_loss = 0.0
  407. model.eval()
  408. with torch.no_grad():
  409. for noisy_imgs, clean_imgs, _ in val_loader:
  410. noisy_imgs = noisy_imgs.to(device)
  411. clean_imgs = clean_imgs.to(device)
  413. # 为每一层生成掩码 - 使用输入图像的大小
  414. masks = []
  415. h, w = noisy_imgs.shape[2], noisy_imgs.shape[3]
  417. for _ in range(len(model.blocks)):
  418. mask = generate_mask(noisy_imgs.size(0), h, w, config.mask_ratio)
  419. masks.append(mask)
  421. reconstructions, features, _ = model(noisy_imgs, masks)
  423. # 计算验证损失
  424. batch_val_loss = 0
  425. for j, recon in enumerate(reconstructions):
  426. mask = masks[j]
  427. resized_mask = F.interpolate(mask, size=recon.shape[2:], mode='nearest')
  429. if j == 0:
  430. expanded_clean_imgs = clean_imgs.expand_as(recon)
  431. target = expanded_clean_imgs
  432. else:
  433. target = features[j - 1]
  434. if target.shape[1] != recon.shape[1]:
  435. if not hasattr(model, f'adaptor_{j}'):
  436. setattr(model, f'adaptor_{j}',
  437. nn.Conv2d(target.shape[1], recon.shape[1], 1).to(device))
  438. adaptor = getattr(model, f'adaptor_{j}')
  439. target = adaptor(target)
  441. if target.shape[2:] != recon.shape[2:]:
  442. target = F.interpolate(target, size=recon.shape[2:], mode='nearest')
  444. batch_val_loss += criterion(recon * (1 - resized_mask), target * (1 - resized_mask)).item()
  446. val_loss += batch_val_loss
  448. # 计算平均损失
  449. avg_train_loss = running_loss / len(train_loader)
  450. avg_val_loss = val_loss / len(val_loader)
  451. train_losses.append(avg_train_loss)
  452. val_losses.append(avg_val_loss)
  454. # 更新学习率
  455. scheduler.step(avg_val_loss)
  457. current_lr = optimizer.param_groups[0]['lr']
  458. print(f'Current learning rate: {current_lr:.2e}')
  460. epoch_time = time.time() - epoch_start_time
  461. print(f'Epoch [{epoch + 1}/{num_epochs}] completed in {epoch_time:.2f}s')
  462. print(f'Training Loss: {avg_train_loss:.4f}, Validation Loss: {avg_val_loss:.4f}')
  464. # 保存最佳模型
  465. if avg_val_loss < best_loss:
  466. best_loss = avg_val_loss
  467. torch.save(model.state_dict(), os.path.join(config.model_dir, 'best_pretrain_model.pth'))
  468. print('Best model saved!')
  470. # 保存一些重建样本用于可视化
  471. if epoch % 5 == 0:
  472. model.eval()
  473. with torch.no_grad():
  474. noisy_imgs, clean_imgs, _ = next(iter(val_loader))
  475. noisy_imgs = noisy_imgs.to(device)
  476. clean_imgs = clean_imgs.to(device)
  478. # 为每一层生成掩码 - 使用输入图像的大小
  479. masks = []
  480. h, w = noisy_imgs.shape[2], noisy_imgs.shape[3]
  482. for _ in range(len(model.blocks)):
  483. mask = generate_mask(noisy_imgs.size(0), h, w, config.mask_ratio)
  484. masks.append(mask)
  486. reconstructions, _, _ = model(noisy_imgs, masks)
  488. # 保存输入、噪声、重建和原始图像
  489. save_image(torch.cat([
  490. noisy_imgs[:8],
  491. reconstructions[0][:8],
  492. clean_imgs[:8]
  493. ]), os.path.join(config.save_dir, f'reconstruction_epoch_{epoch + 1}.png'), nrow=8)
  495. # 绘制损失曲线
  496. plt.figure(figsize=(10, 5))
  497. plt.plot(train_losses, label='Training Loss')
  498. plt.plot(val_losses, label='Validation Loss')
  499. plt.xlabel('Epochs')
  500. plt.ylabel('Loss')
  501. plt.legend()
  502. plt.savefig(os.path.join(config.save_dir, 'pretrain_loss_curve.png'))
  503. plt.close()
  505. return train_losses, val_losses
  508. # 训练函数 - 微调阶段
  509. def finetune(model, train_loader, val_loader, optimizer, criterion, num_epochs):
  510. model.train()
  511. best_acc = 0.0
  512. train_losses = []
  513. val_losses = []
  514. train_accs = []
  515. val_accs = []
  517. for epoch in range(num_epochs):
  518. epoch_start_time = time.time()
  519. running_loss = 0.0
  520. correct = 0
  521. total = 0
  523. # 训练阶段
  524. for i, (noisy_imgs, clean_imgs, labels) in enumerate(train_loader):
  525. clean_imgs = clean_imgs.to(device)
  526. labels = labels.to(device)
  528. # 前向传播
  529. optimizer.zero_grad()
  530. _, _, cls_output = model(clean_imgs)
  532. # 计算分类损失
  533. loss = criterion(cls_output, labels)
  535. # 反向传播和优化
  536. loss.backward()
  537. torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)
  538. optimizer.step()
  540. running_loss += loss.item()
  542. # 计算准确率
  543. _, predicted = torch.max(cls_output.data, 1)
  544. total += labels.size(0)
  545. correct += (predicted == labels).sum().item()
  547. if i % 10 == 0:
  548. acc = 100 * correct / total
  549. print(
  550. f'Epoch [{epoch + 1}/{num_epochs}], Step [{i + 1}/{len(train_loader)}], Loss: {loss.item():.4f}, Acc: {acc:.2f}%')
  552. # 验证阶段
  553. val_loss = 0.0
  554. val_correct = 0
  555. val_total = 0
  556. model.eval()
  557. with torch.no_grad():
  558. for _, clean_imgs, labels in val_loader:
  559. clean_imgs = clean_imgs.to(device)
  560. labels = labels.to(device)
  562. _, _, cls_output = model(clean_imgs)
  564. # 计算验证损失
  565. val_loss += criterion(cls_output, labels).item()
  567. # 计算验证准确率
  568. _, predicted = torch.max(cls_output.data, 1)
  569. val_total += labels.size(0)
  570. val_correct += (predicted == labels).sum().item()
  572. # 计算平均损失和准确率
  573. avg_train_loss = running_loss / len(train_loader)
  574. avg_val_loss = val_loss / len(val_loader)
  575. train_acc = 100 * correct / total
  576. val_acc = 100 * val_correct / val_total
  578. train_losses.append(avg_train_loss)
  579. val_losses.append(avg_val_loss)
  580. train_accs.append(train_acc)
  581. val_accs.append(val_acc)
  583. epoch_time = time.time() - epoch_start_time
  584. print(f'Epoch [{epoch + 1}/{num_epochs}] completed in {epoch_time:.2f}s')
  585. print(f'Training Loss: {avg_train_loss:.4f}, Training Acc: {train_acc:.2f}%')
  586. print(f'Validation Loss: {avg_val_loss:.4f}, Validation Acc: {val_acc:.2f}%')
  588. # 保存最佳模型
  589. if val_acc > best_acc:
  590. best_acc = val_acc
  591. torch.save(model.state_dict(), os.path.join(config.model_dir, 'best_finetune_model.pth'))
  592. print('Best model saved!')
  594. # 绘制损失和准确率曲线
  595. plt.figure(figsize=(12, 5))
  597. plt.subplot(1, 2, 1)
  598. plt.plot(train_losses, label='Training Loss')
  599. plt.plot(val_losses, label='Validation Loss')
  600. plt.xlabel('Epochs')
  601. plt.ylabel('Loss')
  602. plt.legend()
  604. plt.subplot(1, 2, 2)
  605. plt.plot(train_accs, label='Training Accuracy')
  606. plt.plot(val_accs, label='Validation Accuracy')
  607. plt.xlabel('Epochs')
  608. plt.ylabel('Accuracy (%)')
  609. plt.legend()
  611. plt.savefig(os.path.join(config.save_dir, 'finetune_curves.png'))
  612. plt.close()
  614. return train_losses, val_losses, train_accs, val_accs
  617. # 评估函数
  618. def evaluate_model(model, test_loader):
  619. model.eval()
  620. all_preds = []
  621. all_labels = []
  623. with torch.no_grad():
  624. for _, clean_imgs, labels in test_loader:
  625. clean_imgs = clean_imgs.to(device)
  626. labels = labels.to(device)
  628. _, _, cls_output = model(clean_imgs)
  630. _, preds = torch.max(cls_output, 1)
  632. all_preds.extend(preds.cpu().numpy())
  633. all_labels.extend(labels.cpu().numpy())
  635. # 计算评估指标
  636. print("Classification Report:")
  637. print(classification_report(all_labels, all_preds, target_names=train_dataset.classes,digits=5))
  639. # 绘制混淆矩阵
  640. cm = confusion_matrix(all_labels, all_preds)
  641. plt.figure(figsize=(8, 6))
  642. plt.imshow(cm, interpolation='nearest', cmap=plt.cm.Blues)
  643. plt.title('Confusion Matrix')
  644. plt.colorbar()
  645. tick_marks = np.arange(len(train_dataset.classes))
  646. plt.xticks(tick_marks, train_dataset.classes, rotation=45)
  647. plt.yticks(tick_marks, train_dataset.classes)
  649. # 在矩阵中显示数值
  650. thresh = cm.max() / 2.
  651. for i in range(cm.shape[0]):
  652. for j in range(cm.shape[1]):
  653. plt.text(j, i, format(cm[i, j], 'd'),
  654. ha="center", va="center",
  655. color="white" if cm[i, j] > thresh else "black")
  657. plt.tight_layout()
  658. plt.ylabel('True label')
  659. plt.xlabel('Predicted label')
  660. plt.savefig(os.path.join(config.save_dir, 'confusion_matrix.png'))
  661. plt.close()
  663. return all_preds, all_labels
  666. # 主函数
  667. def main():
  668. # 初始化模型
  669. model = StackedMDAE(config.hidden_dims, num_classes=4).to(device)
  670. print(f"模型参数量: {sum(p.numel() for p in model.parameters()):,}")
  672. # 在模型定义后添加权重初始化
  673. def init_weights(m):
  674. if isinstance(m, nn.Conv2d) or isinstance(m, nn.ConvTranspose2d):
  675. nn.init.xavier_uniform_(m.weight)
  676. if m.bias is not None:
  677. nn.init.constant_(m.bias, 0)
  678. elif isinstance(m, nn.BatchNorm2d):
  679. nn.init.constant_(m.weight, 1)
  680. nn.init.constant_(m.bias, 0)
  681. elif isinstance(m, nn.Linear):
  682. nn.init.xavier_uniform_(m.weight)
  683. nn.init.constant_(m.bias, 0)
  685. model.apply(init_weights)
  687. # 定义损失函数和优化器
  688. reconstruction_criterion = nn.MSELoss()
  689. classification_criterion = nn.CrossEntropyLoss()
  691. pretrain_optimizer = optim.Adam(
  692. model.parameters(),
  693. lr=config.learning_rate_pretrain,
  694. weight_decay=config.weight_decay
  695. )
  697. # 预训练阶段
  698. print("开始预训练阶段...")
  699. pretrain_losses = pretrain(
  700. model, train_loader, val_loader,
  701. pretrain_optimizer, reconstruction_criterion,
  702. config.num_epochs_pretrain
  703. )
  705. # 加载最佳预训练模型
  706. model.load_state_dict(torch.load(os.path.join(config.model_dir, 'best_pretrain_model.pth')))
  707. print("预训练完成，加载最佳模型进行微调")
  709. # 微调阶段
  710. print("开始微调阶段...")
  711. finetune_optimizer = optim.Adam(
  712. model.parameters(),
  713. lr=config.learning_rate_finetune,
  714. weight_decay=config.weight_decay
  715. )
  717. finetune_losses = finetune(
  718. model, train_loader, val_loader,
  719. finetune_optimizer, classification_criterion,
  720. config.num_epochs_finetune
  721. )
  723. # 加载最佳微调模型
  724. model.load_state_dict(torch.load(os.path.join(config.model_dir, 'best_finetune_model.pth')))
  725. print("微调完成，加载最佳模型进行评估")
  727. # 评估模型
  728. evaluate_model(model, val_loader)
  730. print("训练和评估完成!")
  733. if __name__ == "__main__":
  734. main()

new.py at commit 98c17f9, no license · at the source

Overview

Authors: Rui Li1, Puyu Zhang1, Chenglin Wen2, Guoxi Sun1
ORCID iDs: Rui Li, Puyu Zhang
  1. College of Electronic Information Engineering, Guangdong University of Petrochemical Technology, Maoming 525000, China; (R.L.); (P.Z.)
  2. Provincial Key Laboratory of Petrochemical Equipment Fault Diagnosis, Guangdong University of Petrochemical Technology, Maoming 525000, China
Institutions: Guangdong University of Petrochemical Technology (China)
Journal: Sensors (Basel, Switzerland), volume 26, issue 17, article 5388
Dates: received 25 June 2026; accepted 19 August 2026; published online 26 August 2026
Type: Research article · Language: English
License: CC BY
Identifiers: DOI 10.3390/s26175388 · PMID 42740007 · PMCID PMC13568421 · OpenAlex W7204237095
Open access: gold, a free copy (OpenAlex)
Status: code verified
Categories: structural MRI / diffusion (modality), human (organism), methods / tools (subfield)
Methods: Connectivity, Machine learning
Keywords: self-supervised learning, masked image modeling, denoising autoencoder, feature learning, brain MRI
MeSH: Brain*, Image Processing, Computer-Assisted*, Magnetic Resonance Imaging*, Algorithms, Autoencoder, Convolutional Neural Networks, Humans, Signal-To-Noise Ratio (* major topic)
Topic: Brain Tumor Detection and Classification (Neurology, Neuroscience), according to OpenAlex
Funding: National Key Research and Development Program of China (2023YFB4704000, 2023YFB4704005); Postgraduate Science and Technology Innovation Program of Guangdong University of Petrochemical Technology (2024KJCX043)
Citations: not cited yet (Europe PMC); 26 references in the paper

Abstract

Medical-image annotation is costly and limits the use of fully supervised learning. This study proposes the Self-Supervised Stacked Masked Denoising Autoencoder (S2MDAE) for four-class brain MRI classification. During pre-training, three convolutional encoder–decoder blocks perform layer-wise masked reconstruction under a 75% mask ratio and Gaussian corruption; the pretrained encoder stack is then fine-tuned for classification. On the primary dataset, S2MDAE achieved 87.207% Accuracy, while ablation studies supported the contributions of pre-training, masking, noise injection, and layer-wise reconstruction. Representation analysis further showed increased class separability in deeper blocks after fine-tuning. Without retraining, external evaluation on a duplicate-screened independent dataset achieved 67.254% Accuracy and 66.009% Macro-F1, indicating partial transfer under domain shift. These findings support the task-specific value of the proposed framework while showing that broader clinical generalization requires further validation.

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

limou66/S2MDAE

License: none: the authors keep all their rights
State: the link answers, verified on 27 September 2026
Evidence: files inventoried
Commit: 98c17f9503b02d82428e4d45c8ed8b10bfcdf6a2, 17 July 2026
Languages: Python (4)
Size: 6 files, 4 scripts
Software Heritage: not archived
Found in: “Data Availability Statement”
Holds: README
Not found: license file, CITATION.cff, environment file, tests, continuous integration, documentation
Tools: Matplotlib (4 files), NumPy (4 files), Pillow (4 files), PyTorch (4 files), scikit-learn (4 files)
Availability: 1 check, the latest on 27 September 2026: the link answers
  • 27 September 2026: the link answers
5 files
At the source: github.com/limou66/S2MDAE

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

Third-party datasets were analyzed in this study. The primary dataset, referred to in this article as the Brain Tumor MRI Dataset, was obtained from the Baidu AI Studio dataset platform. The dataset is not readily available through a dataset-specific persistent link because such a link could not be identified. The Baidu AI Studio dataset portal is available at https://aistudio.baidu.com/datasetoverview (accessed on 24 June 2026), and access to the original dataset is subject to the platform’s continued availability and access conditions. Further inquiries regarding the primary dataset should be directed to the first author (R.L.). The external evaluation dataset, Brain Tumor MRI Dataset (Glioma, Meningioma, Pituitary, No Tumor), Version 4, is openly available in Mendeley Data at https://doi.org/10.17632/zwr4ntf94j.4. No new patient data were collected or generated in this study. The source code used for model implementation and evaluation is openly available on GitHub at https://github.com/limou66/S2MDAE (accessed on 24 June 2026).

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

Recorded: type, language, journal, volume, issue, pages, dates, 4 authors, 5 keywords, 8 MeSH terms, 2 funders, 15 references.

Cite

This paper

Li, R., Zhang, P., Wen, C., & Sun, G. (2026). Self-Supervised Stacked Masked Denoising Autoencoder (S&lt;sup&gt;2&lt;/sup&gt;MDAE) for Brain MRI Denoising and Feature Learning. Sensors (Basel, Switzerland), 26(17), 5388. https://doi.org/10.3390/s26175388

BibTeX

@article{li2026self,
author = {Li, Rui and Zhang, Puyu and Wen, Chenglin and Sun, Guoxi},
title = {{Self-Supervised Stacked Masked Denoising Autoencoder (S\&lt;sup\&gt;2\&lt;/sup\&gt;MDAE) for Brain MRI Denoising and Feature Learning}},
journal = {Sensors (Basel, Switzerland)},
year = {2026},
month = aug,
volume = {26},
number = {17},
pages = {5388},
publisher = {Multidisciplinary Digital Publishing Institute (MDPI)},
issn = {1424-8220},
doi = {10.3390/s26175388},
url = {https://doi.org/10.3390/s26175388},
pmid = {42740007},
pmcid = {PMC13568421}
}

RIS

TY - JOUR
AU - Li, Rui
AU - Zhang, Puyu
AU - Wen, Chenglin
AU - Sun, Guoxi
TI - Self-Supervised Stacked Masked Denoising Autoencoder (S&lt;sup&gt;2&lt;/sup&gt;MDAE) for Brain MRI Denoising and Feature Learning
T2 - Sensors (Basel, Switzerland)
J2 - Sensors (Basel)
PY - 2026
DA - 2026/08/26
VL - 26
IS - 17
SP - 5388
SN - 1424-8220
PB - Multidisciplinary Digital Publishing Institute (MDPI)
DO - 10.3390/s26175388
UR - https://doi.org/10.3390/s26175388
LA - en
ER -

CSL-JSON

{
"id": "10.3390/s26175388",
"type": "article-journal",
"title": "Self-Supervised Stacked Masked Denoising Autoencoder (S&lt;sup&gt;2&lt;/sup&gt;MDAE) for Brain MRI Denoising and Feature Learning",
"container-title": "Sensors (Basel, Switzerland)",
"author": [
{
"family": "Li",
"given": "Rui"
},
{
"family": "Zhang",
"given": "Puyu"
},
{
"family": "Wen",
"given": "Chenglin"
},
{
"family": "Sun",
"given": "Guoxi"
}
],
"container-title-short": "Sensors (Basel)",
"volume": "26",
"issue": "17",
"page": "5388",
"DOI": "10.3390/s26175388",
"PMID": "42740007",
"PMCID": "PMC13568421",
"ISSN": "1424-8220",
"publisher": "Multidisciplinary Digital Publishing Institute (MDPI)",
"URL": "https://doi.org/10.3390/s26175388",
"language": "en",
"issued": {
"date-parts": [
[
2026,
8,
26
]
]
}
}

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/jimaging12070276 [code]
Hyperelastic Regularization for Near-Diffeomorphic Transformer-Based Brain MRI Registration.
Journal: Journal of imaging
In common: Pillow, PyTorch, scikit-learn, 2 other tools, methods / tools, structural MRI / diffusion
[2] doi:10.7554/elife.110588 [code]
Opening the black box toward a modular approach to spike sorting.
Journal: eLife
In common: Pillow, PyTorch, scikit-learn, 2 other tools, methods / tools
[3] doi:10.1038/s41598-026-61605-4 [code]
Learning precise segmentation of neurofibrillary tangles from rapid manual point annotations.
Journal: Scientific reports
In common: Pillow, PyTorch, scikit-learn, 2 other tools, methods / tools
[4] doi:10.1038/s41592-026-03194-8 [code]
Beyond benchmarking: an expert-guided consensus approach to spatially aware clustering.
Journal: Nature methods
In common: Pillow, PyTorch, scikit-learn, 2 other tools, methods / tools
[5] doi:10.1093/bioinformatics/btag540 [code]
Deciphering spatial heterogeneity by multimodal spatial transcriptomics modelling with SpatialModal.
Journal: Bioinformatics (Oxford, England)
In common: Pillow, PyTorch, scikit-learn, 2 other tools, methods / tools
[6] doi:10.1007/s12021-026-09803-3 [code]
NeuroFusion: A Unified Framework for Generalized Visual Stimulus Decoding from fMRI Across Datasets and Subjects.
Journal: Neuroinformatics
In common: Pillow, PyTorch, scikit-learn, 2 other tools, methods / tools
[7] doi:10.1186/s13059-026-04125-8 [code]
MLMarker: a machine learning framework for tissue inference and biomarker discovery.
Journal: Genome biology
In common: Pillow, PyTorch, scikit-learn, 2 other tools, methods / tools
[8] doi:10.1371/journal.pcbi.1013499 [code]
VesiclePy: A machine learning vesicle analysis toolbox for volume electron microscopy.
Journal: PLoS computational biology
In common: Pillow, PyTorch, scikit-learn, 2 other tools, methods / tools
[9] doi:10.1371/journal.pone.0347867 [code]
LiteFeatNet: A parameter-efficient and performance-centric deep learning model for multi-ocular disease identification using intermediate feature reduction from fundus images.
Journal: PloS one
In common: Pillow, PyTorch, scikit-learn, 2 other tools, methods / tools
[10] doi:10.1186/s13244-026-02365-7 [code]
Super-resolution MRI and 2.5D deep learning for intratumoral-peritumoral radiomics in preoperative prediction of rectal cancer perineural invasion.
Journal: Insights into imaging
In common: Pillow, PyTorch, scikit-learn, 2 other tools, structural MRI / diffusion

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.