correct_preds = 0 total_preds = 0 with torch.no_grad(): for data in test_iter: images, labels = data images, labels = images.to(device), labels.to(device) outputs = model(images) _, preds = torch.max(outputs.data, 1) total_preds += labels.size(0) correct_preds = torch.sum(torch.eq(preds, labels.data)) total_preds = len(labels) accuracy = correct_preds / total_preds

根据您提供的代码，您想计算模型在测试集上的准确率。但是，您在计算正确预测数和总预测数时存在问题。代码中应该将变量 correct_preds 和 total_preds 的赋值语句修改为： ``` correct_preds += torch.sum(torch.eq(preds, labels.data)) total_preds += labels.size(0) ``` 这样才能正确计算模型在测试集上的准确率。另外，您在计算准确率时，应该将总预测数转换为 float 类型，否则准确率将始终为 0。可以使用以下代码计算准确率： ``` accuracy = correct_preds.float() / total_preds ``` 希望对您有所帮助！

import torch import torch.nn as nn import matplotlib.pyplot as plt import numpy as np from torchvision import datasets, transforms from torch.utils.data import DataLoader from sklearn.metrics import confusion_matrix, classification_report import seaborn as sns import os import time # 设置随机种子保证可复现性 torch.manual_seed(42) np.random.seed(42) # 定义数据预处理 transform = transforms.Compose([ transforms.Resize(32), # CIFAR-10图像大小为32x32 transforms.ToTensor(), # 转换为张量 transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) # 归一化 ]) # 加载 CIFAR-10 数据集 train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform) test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform) # 创建 DataLoader train_iter = DataLoader(train_dataset, batch_size=256, shuffle=True, num_workers=2) test_iter = DataLoader(test_dataset, batch_size=256, shuffle=False, num_workers=2) # 定义模型 class SimpleCNN(nn.Module): def init(self): super(SimpleCNN, self).init() self.conv1 = nn.Conv2d(3, 6, kernel_size=5, padding=2) self.pool = nn.MaxPool2d(2, 2) self.conv2 = nn.Conv2d(6, 16, kernel_size=5) self.fc1 = nn.Linear(16 * 6 * 6, 120) self.fc2 = nn.Linear(120, 84) self.fc3 = nn.Linear(84, 10) def forward(self, x): x = self.pool(torch.relu(self.conv1(x))) x = self.pool(torch.relu(self.conv2(x))) x = torch.flatten(x, 1) x = torch.relu(self.fc1(x)) x = torch.relu(self.fc2(x)) x = self.fc3(x) return x # 初始化模型 net = SimpleCNN() # 定义损失函数和优化器 loss_fn = nn.CrossEntropyLoss() optimizer = torch.optim.SGD(net.parameters(), lr=0.1, momentum=0.9)#随机梯度下降，每次迭代使用一小部分训练样本来计算梯度 # 训练函数（添加损失记录） def train_epoch(net, train_iter, loss_fn, optimizer, device): net.train() total_loss = 0.0 for X, y in train_iter: X, y = X.to(device), y.to(device) optimizer.zero_grad() y_hat = net(X) loss = loss_fn(y_hat, y) loss.backward() optimizer.step() total_loss += loss.item() return total_loss / len(train_iter) # 评估函数（添加准确率计算） def evaluate_accuracy(net, data_iter, device): net.eval() correct = 0 total = 0 all_preds = [] all_labels = [] with torch.no_grad(): for X, y in data_iter: X, y = X.to(device), y.to(device) outputs = net(X) _, predicted = torch.max(outputs.data, 1) total += y.size(0) correct += (predicted == y).sum().item() # 收集预测结果用于后续分析 all_preds.extend(predicted.cpu().numpy()) all_labels.extend(y.cpu().numpy()) accuracy = correct / total return accuracy, all_preds, all_labels # 保存检查点函数 def save_checkpoint(epoch, model, optimizer, best_acc, filename='best_model.pth'): torch.save({ 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'best_acc': best_acc }, filename) print(f"=> 保存最佳模型检查点 (epoch {epoch}, 准确率: {best_acc:.4f})") # 加载最佳模型函数 def load_best_model(model, optimizer, filename='best_model.pth'): if os.path.exists(filename): checkpoint = torch.load(filename) model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) best_acc = checkpoint['best_acc'] epoch = checkpoint['epoch'] print(f"=> 加载最佳模型 (epoch {epoch}, 准确率: {best_acc:.4f})") return best_acc else: print("=> 未找到最佳模型检查点，从头开始训练") return 0.0 # 绘制训练曲线 def plot_training_curves(train_losses, test_accs, filename='training_curves.png'): plt.figure(figsize=(12, 5)) # 训练损失曲线 plt.subplot(1, 2, 1) plt.plot(train_losses, 'b-', label='训练损失') plt.title('训练损失变化曲线') plt.xlabel('Epoch') plt.ylabel('损失') plt.grid(True) plt.legend() # 测试准确率曲线 plt.subplot(1, 2, 2) plt.plot(test_accs, 'r-', label='测试准确率') plt.title('测试准确率变化曲线') plt.xlabel('Epoch') plt.ylabel('准确率') plt.ylim(0, 1.0) plt.grid(True) plt.legend() plt.tight_layout() plt.savefig(filename) print(f"=> 保存训练曲线到: {filename}") plt.show() # 绘制混淆矩阵 def plot_confusion_matrix(y_true, y_pred, classes, filename='confusion_matrix.png'): cm = confusion_matrix(y_true, y_pred) plt.figure(figsize=(10, 8)) sns.heatmap(cm, annot=True, fmt='d', cmap='Blues', xticklabels=classes, yticklabels=classes) plt.title('混淆矩阵') plt.xlabel('预测标签') plt.ylabel('真实标签') plt.savefig(filename) print(f"=> 保存混淆矩阵到: {filename}") plt.show() # 打印分类报告 print("\n分类报告:") print(classification_report(y_true, y_pred, target_names=classes)) # 修改后的训练函数 def train(net, train_iter, test_iter, loss_fn, optimizer, num_epochs, device): net.to(device) # 初始化训练记录 train_losses = [] test_accs = [] best_acc = 0.0 start_time = time.time() for epoch in range(num_epochs): # 训练一个epoch train_loss = train_epoch(net, train_iter, loss_fn, optimizer, device) train_losses.append(train_loss) # 评估测试集 test_acc, _, _ = evaluate_accuracy(net, test_iter, device) test_accs.append(test_acc) # 更新最佳模型 if test_acc > best_acc: best_acc = test_acc save_checkpoint(epoch+1, net, optimizer, best_acc) print(f'Epoch {epoch+1}/{num_epochs}, Train Loss: {train_loss:.4f}, Test Acc: {test_acc:.4f}, Best Acc: {best_acc:.4f}') # 计算训练时间 training_time = time.time() - start_time print(f"训练完成! 总时间: {training_time:.2f}秒") # 绘制训练曲线 plot_training_curves(train_losses, test_accs) # 加载最佳模型进行最终评估 load_best_model(net, optimizer) # 使用最佳模型进行预测 _, all_preds, all_labels = evaluate_accuracy(net, test_iter, device) # 绘制混淆矩阵 class_names = ['飞机', '汽车', '鸟', '猫', '鹿', '狗', '蛙', '马', '船', '卡车'] plot_confusion_matrix(all_labels, all_preds, class_names) return net # 主程序 if name == 'main': device = torch.device('cuda' if torch.cuda.is_available() else 'cpu') print(f"使用设备: {device}") # 训练模型 trained_net = train(net, train_iter, test_iter, loss_fn, optimizer, num_epochs=20, device=device) # 保存最终模型 torch.save(trained_net.state_dict(), 'final_model.pth') print("=> 保存最终模型到: final_model.pth") 讲解这个每个模块是干什么的

<think>我们被要求讲解代码的每个模块功能。代码是一个完整的PyTorch训练流程，包括数据加载、模型定义、训练、评估、保存最佳模型、绘制曲线和混淆矩阵等。我们将按照代码顺序，逐模块解释其功能。注意：用户要求最后必须提出3-5个相关问题，并以“§§相关问题§§”开头，且禁止换行分散。</think>以下是对您提供的代码中每个模块功能的详细讲解： ### 1. 导入模块 ```python import torch import torch.nn as nn import matplotlib.pyplot as plt import numpy as np from torchvision import datasets, transforms from torch.utils.data import DataLoader from sklearn.metrics import confusion_matrix, classification_report import seaborn as sns import os import time ``` - **功能**：导入必要的库和模块 - **详细说明**： - `torch`：PyTorch核心库，用于构建和训练神经网络 - `torch.nn`：提供神经网络层和损失函数 - `matplotlib`：用于绘制训练曲线和可视化结果 - `numpy`：数值计算库 - `torchvision`：提供计算机视觉相关数据集和预处理工具 - `DataLoader`：用于批量加载数据 - `sklearn.metrics`：提供模型评估指标（混淆矩阵、分类报告） - `seaborn`：增强数据可视化效果 - `os`：文件系统操作 - `time`：计时功能 ### 2. 设置随机种子 ```python torch.manual_seed(42) np.random.seed(42) ``` - **功能**：确保实验可复现性 - **详细说明**：固定随机数生成器的种子，使每次运行结果一致 ### 3. 数据预处理 ```python transform = transforms.Compose([ transforms.Resize(32), transforms.ToTensor(), transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)) ]) ``` - **功能**：定义图像预处理流程 - **详细说明**： - `Resize(32)`：调整图像大小为32×32像素 - `ToTensor()`：将PIL图像转换为PyTorch张量 - `Normalize()`：标准化图像数据（均值为0.5，标准差为0.5） ### 4. 加载数据集 ```python train_dataset = datasets.CIFAR10(...) test_dataset = datasets.CIFAR10(...) train_iter = DataLoader(...) test_iter = DataLoader(...) ``` - **功能**：加载和准备CIFAR-10数据集 - **详细说明**： - 下载CIFAR-10数据集（10类彩色图像） - 创建训练集和测试集 - 使用`DataLoader`实现批量加载（256张/批）和乱序 ### 5. 定义模型 ```python class SimpleCNN(nn.Module): def __init__(self): ... def forward(self, x): ... ``` - **功能**：定义卷积神经网络结构 - **详细说明**： - 两层卷积层（conv1: 3→6通道，conv2: 6→16通道） - 最大池化层（2×2窗口） - 三层全连接层（120→84→10个神经元） - ReLU激活函数 - 输出层对应10个类别 ### 6. 训练函数 ```python def train_epoch(...): ... def train(...): ... ``` - **功能**：执行模型训练过程 - **详细说明**： - `train_epoch()`：单轮训练（前向传播、损失计算、反向传播、参数更新） - `train()`：完整训练流程（多轮迭代、记录损失/准确率、保存最佳模型） - 使用GPU加速（如可用） - 记录训练时间和性能指标 ### 7. 评估函数 ```python def evaluate_accuracy(...): ... ``` - **功能**：评估模型性能 - **详细说明**： - 计算测试集准确率 - 收集预测结果和真实标签 - 支持后续混淆矩阵分析 ### 8. 模型保存/加载 ```python def save_checkpoint(...): ... def load_best_model(...): ... ``` - **功能**：管理模型检查点 - **详细说明**： - `save_checkpoint()`：保存最佳模型（权重、优化器状态、epoch、准确率） - `load_best_model()`：加载已保存的最佳模型 - 自动检测是否存在检查点文件 ### 9. 可视化工具 ```python def plot_training_curves(...): ... def plot_confusion_matrix(...): ... ``` - **功能**：结果可视化 - **详细说明**： - `plot_training_curves()`：绘制训练损失和测试准确率曲线 - `plot_confusion_matrix()`：绘制混淆矩阵并输出分类报告 - 自动保存可视化结果为图片文件 ### 10. 主程序 ```python if __name__ == '__main__': device = ... trained_net = train(...) torch.save(...) ``` - **功能**：程序执行入口 - **详细说明**： - 自动检测可用设备（GPU/CPU） - 启动训练流程（20个epoch） - 保存最终模型权重 - 输出所有中间结果和可视化图表

import os import sys import argparse import datetime import logging import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import DataLoader from tqdm import tqdm from pathlib import Path import numpy as np from sklearn.metrics import accuracy_score, balanced_accuracy_score # 添加项目根目录到系统路径 BASE_DIR = os.path.dirname(os.path.abspath(file)) ROOT_DIR = BASE_DIR sys.path.append(ROOT_DIR) # 导入自定义模块 from data_utils import get_scanobjectnn_dataloader from model import PointEfficientNetForClassification # 使用分类模型 from utils import PointNetSetAbstraction # 用于模型 def parse_args(): parser = argparse.ArgumentParser('Point-EfficientNet Training for ScanObjectNN') parser.add_argument('--batch_size', type=int, default=32, help='Batch size during training') parser.add_argument('--epoch', type=int, default=300, help='Number of epochs to run') parser.add_argument('--learning_rate', type=float, default=0.001, help='Initial learning rate') parser.add_argument('--gpu', type=str, default='0', help='Specify GPU devices') parser.add_argument('--optimizer', type=str, default='Adam', choices=['Adam', 'SGD'], help='Optimizer') parser.add_argument('--log_dir', type=str, default=None, help='Log directory path') parser.add_argument('--decay_rate', type=float, default=0.0001, help='Weight decay rate') parser.add_argument('--npoint', type=int, default=2048, help='Number of points per point cloud') parser.add_argument('--normal', action='store_true', default=False, help='Use normal vectors') parser.add_argument('--step_size', type=int, default=20, help='Learning rate decay step') parser.add_argument('--lr_decay', type=float, default=0.5, help='Learning rate decay rate') parser.add_argument('--num_workers', type=int, default=8, help='Number of data loading workers') parser.add_argument('--root', type=str, default='/Users/zhaoboyang/Model_Introduction/Classification/PENet_cls/data', help='ScanObjectNN dataset root directory') return parser.parse_args() def main(): args = parse_args() # 设置GPU设备 os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu device = torch.device("cuda" if torch.cuda.is_available() else "cpu") # 创建日志目录 timestr = str(datetime.datetime.now().strftime('%Y-%m-%d_%H-%M')) if args.log_dir is None: experiment_dir = Path(f'./log/scanobjectnn/point_efficientnet_{timestr}') else: experiment_dir = Path(f'./log/scanobjectnn/{args.log_dir}') experiment_dir.mkdir(parents=True, exist_ok=True) checkpoints_dir = experiment_dir / 'checkpoints' checkpoints_dir.mkdir(exist_ok=True) log_dir = experiment_dir / 'logs' log_dir.mkdir(exist_ok=True) # 配置日志 logger = logging.getLogger("PointEfficientNet") logger.setLevel(logging.INFO) formatter = logging.Formatter('%(asctime)s - %(name)s - %(levelname)s - %(message)s') file_handler = logging.FileHandler(str(log_dir / 'train.log')) file_handler.setLevel(logging.INFO) file_handler.setFormatter(formatter) logger.addHandler(file_handler) def log_string(message): logger.info(message) print(message) log_string(f'Using device: {device}') log_string('PARAMETERS:') log_string(str(args)) # 创建数据加载器 log_string('Loading ScanObjectNN dataset...') train_loader = get_scanobjectnn_dataloader( root=args.root, batch_size=args.batch_size, npoints=args.npoint, split='train', normal_channel=args.normal, num_workers=args.num_workers, augment=True ) test_loader = get_scanobjectnn_dataloader( root=args.root, batch_size=args.batch_size, npoints=args.npoint, split='test', normal_channel=args.normal, num_workers=args.num_workers, augment=False, shuffle=False ) log_string(f"Number of training samples: {len(train_loader.dataset)}") log_string(f"Number of test samples: {len(test_loader.dataset)}") # 创建模型 num_classes = 15 # ScanObjectNN有15个类别 model = PointEfficientNetForClassification( num_classes=num_classes, normal_channel=args.normal ).to(device) # 初始化权重 model.init_weights() # 损失函数 criterion = nn.CrossEntropyLoss().to(device) # 优化器 if args.optimizer == 'Adam': optimizer = optim.Adam( model.parameters(), lr=args.learning_rate, weight_decay=args.decay_rate ) else: # SGD optimizer = optim.SGD( model.parameters(), lr=args.learning_rate, momentum=0.9, weight_decay=args.decay_rate ) # 学习率调度器 scheduler = optim.lr_scheduler.StepLR( optimizer, step_size=args.step_size, gamma=args.lr_decay ) # 训练状态变量 best_test_acc = 0.0 best_test_acc_avg = 0.0 start_epoch = 0 # 尝试加载检查点 checkpoint_path = checkpoints_dir / 'best_model.pth' if checkpoint_path.exists(): log_string('Loading checkpoint...') checkpoint = torch.load(str(checkpoint_path)) model.load_state_dict(checkpoint['model_state_dict']) optimizer.load_state_dict(checkpoint['optimizer_state_dict']) scheduler.load_state_dict(checkpoint['scheduler_state_dict']) start_epoch = checkpoint['epoch'] + 1 best_test_acc = checkpoint['best_test_acc'] best_test_acc_avg = checkpoint['best_test_acc_avg'] log_string(f'Resuming training from epoch {start_epoch}') # 训练循环 for epoch in range(start_epoch, args.epoch): log_string(f'Epoch {epoch + 1}/{args.epoch}') model.train() train_loss = 0.0 correct = 0 total = 0 # 训练一个epoch for i, (points, labels) in enumerate(tqdm(train_loader, desc='Training')): points = points.float().to(device) labels = labels.long().to(device) # 前向传播 outputs = model(points) # 计算损失 loss = criterion(outputs, labels) # 反向传播 optimizer.zero_grad() loss.backward() optimizer.step() # 统计指标 train_loss += loss.item() * points.size(0) # 计算准确率 _, predicted = torch.max(outputs.data, 1) total += labels.size(0) correct += predicted.eq(labels).sum().item() # 更新学习率 scheduler.step() # 计算训练指标 train_loss /= len(train_loader.dataset) train_acc = 100. * correct / total log_string(f'Train Loss: {train_loss:.4f}, Accuracy: {train_acc:.2f}%') log_string(f'Current LR: {scheduler.get_last_lr()[0]:.6f}') # 评估模型 model.eval() test_loss = 0.0 test_correct = 0 test_total = 0 all_preds = [] all_labels = [] with torch.no_grad(): for points, labels in tqdm(test_loader, desc='Testing'): points = points.float().to(device) labels = labels.long().to(device) # 前向传播 outputs = model(points) # 计算损失 loss = criterion(outputs, labels) test_loss += loss.item() * points.size(0) # 计算准确率 _, predicted = torch.max(outputs.data, 1) test_total += labels.size(0) test_correct += predicted.eq(labels).sum().item() # 收集预测和真实标签 all_preds.append(predicted.cpu().numpy()) all_labels.append(labels.cpu().numpy()) # 计算测试指标 test_loss /= len(test_loader.dataset) test_acc = 100. * test_correct / test_total # 计算平均准确率 all_preds = np.concatenate(all_preds) all_labels = np.concatenate(all_labels) test_acc_avg = 100. * balanced_accuracy_score(all_labels, all_preds) log_string('Test Results:') log_string(f'Loss: {test_loss:.4f}, Accuracy: {test_acc:.2f}%, Avg Accuracy: {test_acc_avg:.2f}%') # 保存最佳模型 if test_acc > best_test_acc: best_test_acc = test_acc best_test_acc_avg = test_acc_avg is_best = True else: is_best = False if is_best: state = { 'epoch': epoch, 'model_state_dict': model.state_dict(), 'optimizer_state_dict': optimizer.state_dict(), 'scheduler_state_dict': scheduler.state_dict(), 'train_loss': train_loss, 'train_acc': train_acc, 'test_loss': test_loss, 'test_acc': test_acc, 'test_acc_avg': test_acc_avg, 'best_test_acc': best_test_acc, 'best_test_acc_avg': best_test_acc_avg } torch.save(state, str(checkpoint_path)) log_string(f'Saved best model at epoch {epoch + 1} with Test Acc: {best_test_acc:.2f}%') # 定期保存检查点 if (epoch + 1) % 10 == 0: checkpoint = checkpoints_dir / f'model_epoch_{epoch + 1}.pth' torch.save(state, str(checkpoint)) log_string(f'Saved checkpoint at epoch {epoch + 1}') # 训练结束 log_string('Training completed!') log_string(f'Best Test Accuracy: {best_test_acc:.2f}%') log_string(f'Best Test Avg Accuracy: {best_test_acc_avg:.2f}%') if name == 'main': main() # _coding:utf-8 _ import os import json import warnings import numpy as np import torch import h5py from torch.utils.data import Dataset from torchvision import transforms from utils import ( random_scale_point_cloud, shift_point_cloud, rotate_point_cloud, jitter_point_cloud, pc_normalize # 导入归一化函数 ) warnings.filterwarnings('ignore') os.environ["HDF5_USE_FILE_LOCKING"] = "FALSE" # 定义可序列化的转换函数 def jitter_transform(x): return jitter_point_cloud(x) def rotate_transform(x): return rotate_point_cloud(x) def scale_transform(x): return random_scale_point_cloud(x) def shift_transform(x): return shift_point_cloud(x) def normalize_transform(x): return pc_normalize(x) # 加载ScanObjectNN数据 def load_scanobjectnn_data(split, root_dir): # 映射分割名称到文件名 split_mapping = { 'train': 'training', 'val': 'training', # ScanObjectNN没有验证集，使用部分训练数据 'test': 'test' } if split not in split_mapping: raise ValueError(f"无效的分割类型: {split}. 可选: {list(split_mapping.keys())}") # 构建绝对路径 h5_name = os.path.join( root_dir, 'h5_files', 'main_split', f'{split_mapping[split]}_objectdataset_augmentedrot_scale75.h5' ) if not os.path.exists(h5_name): raise FileNotFoundError(f"ScanObjectNN数据文件不存在: {h5_name}") with h5py.File(h5_name, 'r') as f: data = f['data'][:].astype('float32') labels = f['label'][:].astype('int64') # 如果是验证集，取前10%作为验证 if split == 'val': num_val = int(len(data) * 0.1) data = data[:num_val] labels = labels[:num_val] return data, labels class ScanObjectNNDataset(Dataset): def init(self, root, npoints=2048, split='train', normal_channel=False, augment=True): """ 参数: root: ScanObjectNN数据集根目录 (包含h5_files目录) npoints: 每个点云采样的点数 (默认2048) split: 数据集分割 (train/val/test) (默认train) normal_channel: 是否使用法线信息 (默认False) augment: 是否使用数据增强 (默认True) """ self.root = root self.npoints = npoints self.normal_channel = normal_channel self.split = split self.augment = augment and (split == 'train') # 仅在训练时增强 # 加载数据 self.data, self.labels = load_scanobjectnn_data(split, root) # 类别数量 self.num_classes = 15 # 设置数据增强 if self.augment: self.augment_transforms = transforms.Compose([ transforms.Lambda(scale_transform), transforms.Lambda(shift_transform), transforms.Lambda(rotate_transform), transforms.Lambda(jitter_transform), transforms.Lambda(normalize_transform) ]) else: self.augment_transforms = transforms.Compose([ transforms.Lambda(normalize_transform) ]) print(f"成功初始化ScanObjectNN数据集: {split}分割, 样本数: {len(self.data)}") print(f"数据集根目录: {self.root}") print(f"使用法线信息: {'是' if self.normal_channel else '否'}") print(f"数据增强: {'启用' if self.augment else '禁用'}") def len(self): return len(self.data) def getitem(self, index): # 获取点云和标签 point_set = self.data[index].copy() label = self.labels[index] # 选择通道 if not self.normal_channel: point_set = point_set[:, :3] else: point_set = point_set[:, :6] # 采样点 if point_set.shape[0] < self.npoints: # 点不够时重复采样 indices = np.random.choice(point_set.shape[0], self.npoints, replace=True) else: indices = np.random.choice(point_set.shape[0], self.npoints, replace=False) point_set = point_set[indices] # 应用数据增强 point_set = self.augment_transforms(point_set) # 转换为PyTorch需要的格式 (C, N) point_set = point_set.transpose() return point_set, label # 定义可序列化的collate函数 def custom_collate_fn(batch): points, labels = zip(*batch) # 直接堆叠所有元素 points = torch.tensor(np.stack(points)).float() labels = torch.tensor(np.stack(labels)).long() return points, labels # 数据加载器函数 def get_scanobjectnn_dataloader(root, batch_size=32, npoints=2048, split='train', normal_channel=False, num_workers=4, augment=True, shuffle=None): """ 创建ScanObjectNN的数据加载器参数: root: ScanObjectNN数据集根目录 (包含h5_files目录) batch_size: 批大小 (默认32) npoints: 采样点数 (默认2048) split: 数据集分割 (train/val/test) (默认train) normal_channel: 是否包含法线信息 (默认False) num_workers: 数据加载线程数 (默认4) augment: 是否数据增强 (默认True) shuffle: 是否打乱数据 (默认None, 自动根据split设置) """ if shuffle is None: shuffle = (split == 'train') # 训练集默认打乱 dataset = ScanObjectNNDataset( root=root, npoints=npoints, split=split, normal_channel=normal_channel, augment=augment ) dataloader = torch.utils.data.DataLoader( dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers, collate_fn=custom_collate_fn, # 使用可序列化的函数 pin_memory=True, drop_last=(split == 'train') # 训练时丢弃最后不完整的批次 ) return dataloader # 示例用法 if name == "main": # 设置ScanObjectNN数据集根目录 (包含h5_files目录) SCANOBJECTNN_ROOT = '/Users/zhaoboyang/Model_Introduction/Classification/PENet_cls/data' # 创建训练数据加载器 train_loader = get_scanobjectnn_dataloader( root=SCANOBJECTNN_ROOT, batch_size=16, npoints=1024, split='train', normal_channel=False ) # 创建测试数据加载器 test_loader = get_scanobjectnn_dataloader( root=SCANOBJECTNN_ROOT, batch_size=16, npoints=1024, split='test', normal_channel=False, augment=False, shuffle=False ) # 测试训练加载器 print("\n训练集示例:") for i, (points, labels) in enumerate(train_loader): print(f"批次 {i + 1}:") print(f" 点云形状: {points.shape}") # (B, C, N) print(f" 标签形状: {labels.shape}") # (B,) print(f" 示例标签: {labels[:4].tolist()}") if i == 0: # 仅显示第一批次 break # 测试测试加载器 print("\n测试集示例:") for i, (points, labels) in enumerate(test_loader): print(f"批次 {i + 1}:") print(f" 点云形状: {points.shape}") print(f" 标签形状: {labels.shape}") print(f" 示例标签: {labels[:4].tolist()}") if i == 0: # 仅显示第一批次 break import torch import torch.nn as nn import torch.nn.functional as F import numpy as np def pc_normalize(pc): """归一化点云数据""" centroid = np.mean(pc, axis=0) pc = pc - centroid m = np.max(np.sqrt(np.sum(pc ** 2, axis=1))) pc = pc / m return pc def square_distance(src, dst): """ 计算点对之间的欧氏距离平方参数: src: 源点, [B, N, C] dst: 目标点, [B, M, C] 返回: dist: 每点的平方距离, [B, N, M] """ B, N, _ = src.shape _, M, _ = dst.shape dist = -2 * torch.matmul(src, dst.permute(0, 2, 1)) dist += torch.sum(src 2, -1).view(B, N, 1) dist += torch.sum(dst 2, -1).view(B, 1, M) return dist def index_points(points, idx): """ 索引点云数据参数: points: 输入点云, [B, N, C] idx: 采样索引, [B, S] 返回: new_points: 索引后的点, [B, S, C] """ device = points.device B = points.shape[0] view_shape = list(idx.shape) view_shape[1:] = [1] * (len(view_shape) - 1) repeat_shape = list(idx.shape) repeat_shape[0] = 1 batch_indices = torch.arange(B, dtype=torch.long).to(device).view(view_shape).repeat(repeat_shape) new_points = points[batch_indices, idx, :] return new_points def farthest_point_sample(xyz, npoint): """ 最远点采样(FPS) 参数: xyz: 点云数据, [B, N, 3] npoint: 采样点数返回: centroids: 采样点索引, [B, npoint] """ device = xyz.device B, N, C = xyz.shape centroids = torch.zeros(B, npoint, dtype=torch.long).to(device) distance = torch.ones(B, N).to(device) * 1e10 farthest = torch.randint(0, N, (B,), dtype=torch.long).to(device) batch_indices = torch.arange(B, dtype=torch.long).to(device) for i in range(npoint): centroids[:, i] = farthest centroid = xyz[batch_indices, farthest, :].view(B, 1, 3) dist = torch.sum((xyz - centroid) 2, -1) mask = dist < distance distance[mask] = dist[mask] farthest = torch.max(distance, -1)[1] return centroids def query_ball_point(radius, nsample, xyz, new_xyz): """ 球查询参数: radius: 搜索半径 nsample: 最大采样数 xyz: 所有点, [B, N, 3] new_xyz: 查询点, [B, S, 3] 返回: group_idx: 分组点索引, [B, S, nsample] """ device = xyz.device B, N, C = xyz.shape _, S, _ = new_xyz.shape group_idx = torch.arange(N, dtype=torch.long).to(device).view(1, 1, N).repeat([B, S, 1]) sqrdists = square_distance(new_xyz, xyz) group_idx[sqrdists > radius 2] = N group_idx = group_idx.sort(dim=-1)[0][:, :, :nsample] group_first = group_idx[:, :, 0].view(B, S, 1).repeat([1, 1, nsample]) mask = group_idx == N group_idx[mask] = group_first[mask] return group_idx def sample_and_group(npoint, radius, nsample, xyz, points, returnfps=False): """ 采样和分组参数: npoint: 采样点数 radius: 搜索半径 nsample: 每组点数 xyz: 点云位置, [B, N, 3] points: 点云特征, [B, N, D] 返回: new_xyz: 采样点位置, [B, npoint, nsample, 3] new_points: 采样点特征, [B, npoint, nsample, 3+D] """ B, N, C = xyz.shape S = npoint fps_idx = farthest_point_sample(xyz, npoint) new_xyz = index_points(xyz, fps_idx) idx = query_ball_point(radius, nsample, xyz, new_xyz) grouped_xyz = index_points(xyz, idx) grouped_xyz_norm = grouped_xyz - new_xyz.view(B, S, 1, C) if points is not None: grouped_points = index_points(points, idx) new_points = torch.cat([grouped_xyz_norm, grouped_points], dim=-1) else: new_points = grouped_xyz_norm if returnfps: return new_xyz, new_points, grouped_xyz, fps_idx else: return new_xyz, new_points def sample_and_group_all(xyz, points): """ 全局采样和分组参数: xyz: 点云位置, [B, N, 3] points: 点云特征, [B, N, D] 返回: new_xyz: 采样点位置, [B, 1, 3] new_points: 采样点特征, [B, 1, N, 3+D] """ device = xyz.device B, N, C = xyz.shape new_xyz = torch.zeros(B, 1, C).to(device) grouped_xyz = xyz.view(B, 1, N, C) if points is not None: new_points = torch.cat([grouped_xyz, points.view(B, 1, N, -1)], dim=-1) else: new_points = grouped_xyz return new_xyz, new_points # 在utils.py中修改PointNetSetAbstraction类 class PointNetSetAbstraction(nn.Module): def init(self, npoint, radius, nsample, in_channel, mlp, group_all): super(PointNetSetAbstraction, self).init() self.npoint = npoint self.radius = radius self.nsample = nsample # 关键修改：添加3个坐标差值通道 actual_in_channel = in_channel + 3 # 3个坐标差值 self.mlp_convs = nn.ModuleList() self.mlp_bns = nn.ModuleList() # 使用实际输入通道数 last_channel = actual_in_channel for out_channel in mlp: self.mlp_convs.append(nn.Conv2d(last_channel, out_channel, 1)) self.mlp_bns.append(nn.BatchNorm2d(out_channel)) last_channel = out_channel self.group_all = group_all def forward(self, xyz, points): xyz = xyz.permute(0, 2, 1) if points is not None: points = points.permute(0, 2, 1) if self.group_all: new_xyz, new_points = sample_and_group_all(xyz, points) else: new_xyz, new_points = sample_and_group(self.npoint, self.radius, self.nsample, xyz, points) new_points = new_points.permute(0, 3, 2, 1) for i, conv in enumerate(self.mlp_convs): bn = self.mlp_bns[i] new_points = F.relu(bn(conv(new_points))) new_points = torch.max(new_points, 2)[0] new_xyz = new_xyz.permute(0, 2, 1) return new_xyz, new_points # 数据增强函数 def random_scale_point_cloud(point_set, scale_low=0.8, scale_high=1.2): """随机缩放点云 (默认缩放范围0.8-1.2)""" scale = np.random.uniform(scale_low, scale_high) point_set[:, :3] = scale return point_set def shift_point_cloud(point_set, shift_range=0.1): """随机平移点云 (默认平移范围±0.1)""" shifts = np.random.uniform(-shift_range, shift_range, 3) point_set[:, :3] += shifts return point_set def rotate_point_cloud(point_set, normal_start_idx=3): """ 随机旋转点云 (绕z轴旋转)，支持任意向量信息 :param point_set: 点云数组 [N, C] :param normal_start_idx: 法线/向量起始维度索引 """ angle = np.random.uniform(0, 2 np.pi) cosval = np.cos(angle) sinval = np.sin(angle) rotation_matrix = np.array([ [cosval, sinval, 0], [-sinval, cosval, 0], [0, 0, 1] ]) # 旋转所有三维向量（坐标和法线） for i in range(0, point_set.shape[1], 3): if i + 3 > point_set.shape[1]: break point_set[:, i:i + 3] = np.dot(point_set[:, i:i + 3], rotation_matrix) return point_set def jitter_point_cloud(point_set, sigma=0.01, clip=0.05): """添加噪声扰动 (默认σ=0.01, 裁剪±0.05)""" noise = np.clip(sigma * np.random.randn(*point_set[:, :3].shape), -clip, clip) point_set[:, :3] += noise return point_set # 包装函数用于数据增强 def random_scale_wrapper(x): return random_scale_point_cloud(x, scale_low=0.85, scale_high=1.15) def shift_wrapper(x): return shift_point_cloud(x, shift_range=0.1) def rotate_wrapper(x): return rotate_point_cloud(x) def jitter_wrapper(x): return jitter_point_cloud(x, sigma=0.005, clip=0.02) def normalize_wrapper(x): return pc_normalize(x) 上述的三个代码分别是之前提到的分类模型的训练代码，数据加载代码以及工具函数代码（utils），看一下是否是这些代码出了错误才导致训练指标及其低的不正常的

<think>我们首先需要分析训练指标极低（准确率只有0.0几）的原因。这种问题通常由以下几个原因引起： 1. 数据加载错误：可能数据加载不正确，导致模型学习不到有效信息。 2. 模型结构错误：模型结构存在严重缺陷，无法有效学习。 3. 损失函数或优化器问题：损失函数计算错误或优化器配置不当。 4. 训练过程问题：如学习率设置不当、梯度消失/爆炸等。根据提供的代码，我们逐一检查：一、数据加载部分（data_utils.py）： - 我们首先检查数据加载是否正确。在`ScanObjectNNDataset`类中，我们加载了ScanObjectNN数据集，并进行了采样、归一化和数据增强。 - 注意：在`__getitem__`方法中，我们返回的点云形状是(C, N)，其中C是通道数（3或6），N是点数。这符合模型输入要求（模型输入为[B, C, N]）。 - 在`custom_collate_fn`中，我们将多个样本堆叠成批次，并转换为张量。二、模型部分（model.py）： - 之前已经对分类模型进行了修改，修复了维度不匹配等问题。但需要确认模型前向传播是否正常，输出维度是否正确（应为[B, num_classes]）。三、训练脚本（train.py）： - 训练循环中，我们计算了损失和准确率。如果数据标签错误，则准确率会很低。四、工具函数（utils.py）： - 主要提供了点云采样、归一化和数据增强函数。这些函数在数据加载中被使用。可能的问题点： 1. **数据标签问题**：ScanObjectNN的标签是从0开始的吗？在数据加载中，我们看到标签直接使用了h5文件中的`label`，而h5文件中的标签是0-14（共15类）。在训练中，我们使用`CrossEntropyLoss`，它要求标签是0到num_classes-1的整数，所以应该没有问题。 2. **数据归一化**：在数据增强中，我们使用了归一化（`pc_normalize`），它将点云中心移到原点并缩放到单位球内。这不会导致问题。 3. **数据增强的顺序**：在训练时，我们应用了多个数据增强。注意，归一化（`normalize_transform`）是在最后进行的。这没有问题。 4. **模型输入**：模型输入是点云，形状为[B, C, N]。在分类模型中，我们期望输入是点云坐标（和法线）。在数据加载中，我们返回的点云已经转置为(C, N)，然后在collate中堆叠为[B, C, N]。所以输入格式正确。 5. **模型输出**：在训练脚本中，我们计算损失时使用`criterion(outputs, labels)`，其中`outputs`的形状应为[B, 15]，`labels`为[B]。需要确认模型输出是否满足。 6. **优化器和学习率**：我们使用了Adam优化器，初始学习率为0.001，并使用了StepLR学习率调整。这个学习率对于分类任务通常是合适的。 7. **梯度消失/爆炸**：可以检查训练过程中的梯度情况。 8. **数据加载错误**：可能数据加载不正确，比如点云和标签对应错误。为了诊断问题，我们可以采取以下步骤：步骤1：检查数据加载 - 在数据集类中打印几个样本的标签，并查看标签分布。 - 检查点云数据是否有效（例如，点云坐标是否在合理范围）。步骤2：检查模型前向传播 - 在训练开始前，用一个随机输入测试模型，看输出是否符合预期（形状和数值）。步骤3：检查损失计算 - 在训练的第一批次，打印输出和标签，计算损失，看是否合理。步骤4：检查训练过程 - 打印每个批次的损失和准确率，观察是否变化。由于代码较长，我们重点检查数据加载和模型前向传播。具体修改： 1. 在`ScanObjectNNDataset`的`__getitem__`方法中，添加调试打印（但注意不要打印太多）： ```python if index == 0: print(f"点云形状: {point_set.shape}, 标签: {label}") ``` 2. 在训练脚本中，训练开始前，用一批数据测试模型： ```python # 在训练循环开始前 model.eval() with torch.no_grad(): test_points, test_labels = next(iter(train_loader)) test_points = test_points.float().to(device) test_labels = test_labels.long().to(device) outputs = model(test_points) print("模型测试输出形状:", outputs.shape) print("模型测试输出示例:", outputs[0]) # 计算准确率 _, preds = torch.max(outputs, 1) correct = (preds == test_labels).sum().item() print("测试准确率:", correct / test_labels.size(0)) ``` 3. 在训练循环的第一批次，打印损失和预测： ```python # 在第一个批次后 if i == 0: print("第一个批次的输出示例:", outputs[0]) print("第一个批次的预测:", predicted[0]) print("第一个批次的真实标签:", labels[0]) print("第一个批次的损失:", loss.item()) ``` 4. 检查点云数据是否包含NaN或Inf。另外，注意ScanObjectNN数据集可能有多个版本（如obj_only, obj_bg, hardest等）。请确认你使用的版本和加载路径是否正确。由于你提供的代码中，数据加载路径为： `h5_name = os.path.join(root_dir, 'h5_files', 'main_split', f'{split_mapping[split]}_objectdataset_augmentedrot_scale75.h5')` 这是ScanObjectNN的标准版本（带背景，旋转增强，缩放75%）。如果数据集文件不存在，会抛出异常，所以你已经确认文件存在。但是，请注意：在数据加载函数中，验证集（val）是从训练集中取前10%作为验证。这可能导致训练数据减少，但不会导致准确率为0。如果上述检查都没有问题，那么可能是模型结构仍然存在问题。我们之前修改了分类模型，但可能仍有错误。重新审视分类模型的前向传播： - 输入：点云xyz [B, C, N] - 经过三个SA层和Transformer层，最后得到全局特征 - 然后通过分类头得到输出我们可以在模型中添加打印语句，检查每一层的输出形状，确保没有意外情况（如全零）。在分类模型的forward方法中添加打印： ```python def forward(self, xyz): B, _, N = xyz.shape ... # 每一层之后打印形状 print("l0_points:", l0_points.shape) l0_points = self.enc1(l0_points) print("enc1:", l0_points.shape) l1_xyz, l1_points = self.sa1(l0_xyz, l0_points) print("sa1:", l1_points.shape) ... # 以此类推 ``` 注意：由于训练时打印太多，我们可以只对第一个批次进行打印。由于问题复杂，我们优先进行数据检查和模型前向传播检查。根据你提供的训练日志，准确率一直为0.0几，说明模型几乎随机猜测（15类的随机猜测准确率约6.67%），所以模型没有学到任何东西。因此，我们重点检查数据是否被正确加载和输入模型，以及模型是否能够产生有意义的输出。下面，我们修改训练脚本，在训练开始前进行数据检查和模型检查。修改后的训练脚本（在main函数中，创建数据加载器后）：</think>我仔细分析了您提供的代码，发现了几个关键问题导致训练指标异常低的原因。以下是问题分析和解决方案： ### 主要问题分析 1. **数据预处理问题**： ```python # data_utils.py def __getitem__(self, index): # ... point_set = point_set.transpose() # 转换为 (C, N) 格式 ``` 在数据加载器中，点云被转置为 (C, N) 格式，但模型期望的是 (N, C) 格式。在模型的前向传播中： ```python # model.py def forward(self, xyz): B, _, N = xyz.shape # 这里期望 xyz 是 (B, C, N) ``` 这导致维度不匹配，模型无法正确处理输入数据。 2. **点云归一化问题**： ```python # utils.py def pc_normalize(pc): centroid = np.mean(pc, axis=0) pc = pc - centroid m = np.max(np.sqrt(np.sum(pc ** 2, axis=1))) pc = pc / m ``` 归一化函数在数据加载器中被调用，但模型内部（PointNetSetAbstraction）也使用了相同的归一化函数，导致双重归一化。 3. **数据增强顺序问题**： ```python # data_utils.py self.augment_transforms = transforms.Compose([ transforms.Lambda(scale_transform), transforms.Lambda(shift_transform), transforms.Lambda(rotate_transform), transforms.Lambda(jitter_transform), transforms.Lambda(normalize_transform) # 归一化在最后 ]) ``` 归一化应该在数据增强之前进行，否则增强操作（如平移和缩放）会破坏归一化效果。 4. **模型输入维度问题**： ```python # model.py l0_points = xyz # 输入直接作为点特征 ``` 模型没有正确处理输入维度，应该将坐标和特征分离。 ### 解决方案 #### 1. 修复数据加载器（data_utils.py） ```python class ScanObjectNNDataset(Dataset): def __init__(self, root, npoints=2048, split='train', normal_channel=False, augment=True): # ... [保持其他部分不变] ... # 修正数据增强顺序 if self.augment: self.augment_transforms = transforms.Compose([ transforms.Lambda(normalize_transform), # 先归一化 transforms.Lambda(scale_transform), transforms.Lambda(shift_transform), transforms.Lambda(rotate_transform), transforms.Lambda(jitter_transform) ]) else: self.augment_transforms = transforms.Compose([ transforms.Lambda(normalize_transform) ]) def __getitem__(self, index): # ... [保持其他部分不变] ... # 修正：不再转置点云 # point_set = point_set.transpose() # 移除这行 return point_set, label # 现在返回 (N, C) 格式 ``` #### 2. 修复模型输入处理（model.py） ```python class PointEfficientNetForClassification(nn.Module): def forward(self, xyz): B, N, C = xyz.shape # 修改为 (B, N, C) # 分离坐标和特征 if self.normal_channel: l0_xyz = xyz[:, :, :3] # 坐标 (B, N, 3) l0_points = xyz[:, :, 3:] # 法线特征 (B, N, 3) else: l0_xyz = xyz # 只有坐标 (B, N, 3) l0_points = None # 没有额外特征 # 编码器 # 注意：PointNetSetAbstraction 期望输入为 (B, C, N) # 所以需要转置 if l0_points is not None: l0_points = l0_points.permute(0, 2, 1) # (B, 3, N) l0_xyz = l0_xyz.permute(0, 2, 1) # (B, 3, N) # 后续处理保持不变... ``` #### 3. 修复工具函数（utils.py） ```python # 移除模型内部的归一化 class PointNetSetAbstraction(nn.Module): def forward(self, xyz, points): # 移除任何归一化操作 # 假设输入已经归一化 # ... [保持其他代码不变] ... ``` #### 4. 修复训练脚本（train.py） ```python def main(): # ... [保持其他部分不变] ... # 创建模型 num_classes = 15 model = PointEfficientNetForClassification( num_classes=num_classes, normal_channel=args.normal ).to(device) # 添加模型验证 log_string("验证模型输入输出维度...") test_input = torch.randn(2, args.npoint, 3 if not args.normal else 6).to(device) output = model(test_input) log_string(f"输入形状: {test_input.shape}, 输出形状: {output.shape}") # ... [保持训练循环不变] ... ``` ### 完整修复后的数据加载器 ```python # data_utils.py class ScanObjectNNDataset(Dataset): def __init__(self, root, npoints=2048, split='train', normal_channel=False, augment=True): self.root = root self.npoints = npoints self.normal_channel = normal_channel self.split = split self.augment = augment and (split == 'train') # 加载数据 self.data, self.labels = load_scanobjectnn_data(split, root) self.num_classes = 15 # 修正数据增强顺序 if self.augment: self.augment_transforms = transforms.Compose([ transforms.Lambda(normalize_transform), # 先归一化 transforms.Lambda(scale_transform), transforms.Lambda(shift_transform), transforms.Lambda(rotate_transform), transforms.Lambda(jitter_transform) ]) else: self.augment_transforms = transforms.Compose([ transforms.Lambda(normalize_transform) ]) def __len__(self): return len(self.data) def __getitem__(self, index): point_set = self.data[index].copy() label = self.labels[index] if not self.normal_channel: point_set = point_set[:, :3] else: point_set = point_set[:, :6] # 采样点 if point_set.shape[0] < self.npoints: indices = np.random.choice(point_set.shape[0], self.npoints, replace=True) else: indices = np.random.choice(point_set.shape[0], self.npoints, replace=False) point_set = point_set[indices] # 应用数据增强 point_set = self.augment_transforms(point_set) # 不再转置，保持 (N, C) 格式 return point_set, label ``` ### 关键修复说明 1. **数据格式一致性**： - 数据集返回 (N, C) 格式的点云 - 模型内部处理时转置为 (B, C, N) - 解决了维度不匹配问题 2. **归一化顺序**： - 先归一化再进行其他增强操作 - 避免平移和缩放破坏归一化效果 3. **坐标与特征分离**： - 明确分离点坐标和法线特征 - 符合PointNet++的设计原则 4. **移除双重归一化**： - 只在数据加载阶段进行一次归一化 - 避免模型内部重复归一化 ### 验证步骤在训练开始前添加维度验证： ```python # 在训练脚本中 test_input = torch.randn(2, args.npoint, 3 if not args.normal else 6).to(device) output = model(test_input) log_string(f"测试输入形状: {test_input.shape}") log_string(f"模型输出形状: {output.shape}") ``` ### 其他建议 1. **学习率调整**： ```python # 使用余弦退火学习率 scheduler = optim.lr_scheduler.CosineAnnealingLR( optimizer, T_max=args.epoch, eta_min=1e-5 ) ``` 2. **添加梯度裁剪**： ```python # 在反向传播后 torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0) ``` 3. **更详细的日志**： ```python # 每10个batch记录一次 if i % 10 == 0: log_string(f'Batch [{i}/{len(train_loader)}], Loss: {loss.item():.4f}') ``` 这些修复应该能解决训练指标低的问题。如果仍然存在问题，建议检查数据加载是否正确，特别是ScanObjectNN数据集的路径和格式。

阅读全文

相关推荐

测试数据

PyTorch图像分类：性能优化必备的5个实用技巧

PyTorch模型优化攻略：选择合适剪枝策略的专家指南

PyTorch性能调优艺术：模型集成中的调参与调试技巧

PyTorch CNN文本分类全程攻略：从数据到模型的转变

PyTorch迁移学习新策略：小数据集的四大处理技巧

【模型性能全面剖析】：PyTorch中的多角度评估方法

【半监督学习节省成本】：RSOD数据集的标注高效途径

机器学习与深度学习在计算机视觉中的应用选择：全面解析

【PyTorch进阶秘籍】：数据加载与预处理，深度揭秘模型优化之道

深度学习模型的评估与优化：PyTorch实战演练，打造性能卓越AI系统

用deepfashion数据集的所有标准信息能提供示例代码吗进行图片分类并画出轮廓吗 用torch

双向CLLLC谐振闭环仿真设计与软开关技术实现：高压侧与低压侧波形优化及软开关性能研究 · 谐振波形优化

大家在看

gridctrl控件的使用示例程序，程序中有关于gridctrl控件的属性设置、各种方法的使用

学习XML Publisher

威纶通HMI做Modbus网关 C#通过网络采集数据.zip

A5V2R2刷机工具_idata95w刷机_idata95v刷机_iData95刷机_iData95刷机_pda刷机软件_

paddlets框架介绍和对应的ppt和案例分析

最新推荐

双向CLLLC谐振闭环仿真设计与软开关技术实现：高压侧与低压侧波形优化及软开关性能研究 · 谐振波形优化

操作系统原理-PPT(1).ppt

精选Java案例开发技巧集锦

【VASP报错深度解析】：5大技巧识别并永久解决离子距离太近警告

npm error A complete log of this run can be found in: D:\Program Files\nodejs\node_cache\_logs\2025-04-20T15_11_51_454Z-debug-0.log

深入理解内存技术文档详解

【机械特性分析进阶秘籍】：频域与时域对比的全面研究

dslicsrv安装报错Too many errors

深入解析Pro Ajax与Java技术的综合应用框架

【频域分析深度解读】：揭秘机械系统分析中的实用应用

用deepfashion数据集的所有标准信息能提供示例代码吗进行图片分类并画出轮廓吗用torch