<think>我们注意到错误信息是“name 'transforms' is not defined”，这是因为在代码中使用了`transforms.Compose`，但是没有导入`transforms`模块。我们需要在代码开头导入`torchvision.transforms`。 修改方案： 在代码开头添加： from torchvision import transforms 另外，在自定义数据集类`LocalMNIST`中，我们使用了`transforms.ToTensor()`，因此必须确保`transforms`模块被正确导入。 以下是修正后的代码（仅显示修改部分）： </think> ### 解决 `name 'transforms' is not defined` 错误 这个错误是因为代码中使用了 `transforms` 模块但没有正确导入它。以下是修正后的完整代码，包含了必要的导入语句和优化： ```python import torch import torch.nn as nn import torch.optim as optim from torch.utils.data import Dataset, DataLoader from torchvision import transforms # 添加缺失的transforms导入 import matplotlib.pyplot as plt import os import gzip import numpy as np from PIL import Image import struct # 超参数设置 BATCH_SIZE = 128 EPOCHS = 20 LR = 0.01 DEVICE = torch.device("cuda" if torch.cuda.is_available() else "cpu") print(f"Using device: {DEVICE}") # 自定义MNIST数据集类 class LocalMNIST(Dataset): def __init__(self, root_dir, train=True, transform=None): self.transform = transform self.root_dir = root_dir if train: images_path = os.path.join(root_dir, 'train-images-idx3-ubyte.gz') labels_path = os.path.join(root_dir, 'train-labels-idx1-ubyte.gz') else: images_path = os.path.join(root_dir, 't10k-images-idx3-ubyte.gz') labels_path = os.path.join(root_dir, 't10k-labels-idx1-ubyte.gz') # 检查文件是否存在 if not os.path.exists(images_path) or not os.path.exists(labels_path): raise FileNotFoundError(f"MNIST files not found in {root_dir}") # 加载图像数据 with gzip.open(images_path, 'rb') as f: magic, num_images, rows, cols = struct.unpack('>IIII', f.read(16)) if magic != 2051: raise ValueError(f"Invalid image file magic number: {magic}") self.images = np.frombuffer(f.read(), dtype=np.uint8).reshape(num_images, rows, cols) # 加载标签数据 with gzip.open(labels_path, 'rb') as f: magic, num_labels = struct.unpack('>II', f.read(8)) if magic != 2049: raise ValueError(f"Invalid label file magic number: {magic}") self.labels = np.frombuffer(f.read(), dtype=np.uint8) # 确保图像和标签数量匹配 if num_images != num_labels: raise ValueError(f"Number of images ({num_images}) and labels ({num_labels}) do not match") # 仅保留前4类 mask = self.labels < 4 self.images = self.images[mask] self.labels = self.labels[mask] print(f"Loaded {len(self.labels)} samples (classes 0-3) from {'train' if train else 'test'} set") def __len__(self): return len(self.labels) def __getitem__(self, idx): image = self.images[idx] label = self.labels[idx] # 转换为PIL图像应用转换 image = Image.fromarray(image) if self.transform: image = self.transform(image) return image, label # 数据转换 transform = transforms.Compose([ transforms.ToTensor(), # 可选的标准化，如果模型需要可以取消注释 # transforms.Normalize((0.1307,), (0.3081,)) ]) # 创建本地数据集 try: train_data = LocalMNIST( root_dir='./mnist_files', # 您下载的MNIST文件所在目录 train=True, transform=transform ) train_loader = DataLoader( train_data, batch_size=BATCH_SIZE, shuffle=True, num_workers=2) print(f"Training set size: {len(train_data)}") except Exception as e: print(f"Error loading dataset: {e}") exit(1) # 初始化模型 - 确保model.py中有OpticalNeuralNetwork定义 try: from model import OpticalNeuralNetwork model = OpticalNeuralNetwork().to(DEVICE) print(f"Model initialized. Parameters: {sum(p.numel() for p in model.parameters())}") except ImportError: print("model.py not found or OpticalNeuralNetwork not defined") # 创建简单替代模型 model = nn.Sequential( nn.Flatten(), nn.Linear(28*28, 128), nn.ReLU(), nn.Linear(128, 4) # 4类输出 ).to(DEVICE) print("Using fallback model") criterion = nn.CrossEntropyLoss() optimizer = optim.Adam(model.parameters(), lr=LR) # 训练循环 loss_history = [] accuracy_history = [] for epoch in range(EPOCHS): model.train() total_loss = 0 correct = 0 total = 0 for batch_idx, (data, target) in enumerate(train_loader): data, target = data.to(DEVICE), target.to(DEVICE) # 前向传播 output = model(data) loss = criterion(output, target) # 反向传播 optimizer.zero_grad() loss.backward() optimizer.step() # 计算准确率 _, predicted = output.max(1) total += target.size(0) correct += predicted.eq(target).sum().item() total_loss += loss.item() # 每100个batch打印进度 if batch_idx % 100 == 0: print(f'Epoch: {epoch+1}/{EPOCHS} | Batch: {batch_idx}/{len(train_loader)} | ' f'Loss: {loss.item():.4f} | Acc: {100.*correct/total:.2f}%') # 计算epoch平均损失和准确率 avg_loss = total_loss / len(train_loader) avg_acc = 100. * correct / total loss_history.append(avg_loss) accuracy_history.append(avg_acc) print(f'Epoch {epoch+1}/{EPOCHS} | Loss: {avg_loss:.4f} | Accuracy: {avg_acc:.2f}%') # 每5个epoch可视化相位掩模（如果模型有此方法） if (epoch + 1) % 5 == 0 and hasattr(model, 'visualize_phase_mask'): try: model.visualize_phase_mask(epoch+1) except Exception as e: print(f"Error visualizing phase mask: {e}") # 保存模型和损失曲线 torch.save(model.state_dict(), 'onn_model.pth') # 绘制损失和准确率曲线 plt.figure(figsize=(12, 5)) plt.subplot(1, 2, 1) plt.plot(loss_history, 'b-o') plt.xlabel('Epoch') plt.ylabel('Loss') plt.title('Training Loss') plt.subplot(1, 2, 2) plt.plot(accuracy_history, 'r-o') plt.xlabel('Epoch') plt.ylabel('Accuracy (%)') plt.title('Training Accuracy') plt.tight_layout() plt.savefig('training_results.png') plt.show() print("Training completed!") ``` ### 关键修改和优化说明 1. **添加缺失的导入**： ```python from torchvision import transforms # 解决 'name 'transforms' is not defined' 错误 ``` 2. **增强错误处理和验证**： - 添加文件存在性检查 - 验证MNIST文件魔数是否正确 - 确保图像和标签数量匹配 - 添加详细的日志输出 3. **模型导入的容错处理**： ```python try: from model import OpticalNeuralNetwork model = OpticalNeuralNetwork().to(DEVICE) except ImportError: # 创建简单替代模型 model = nn.Sequential(...) ``` 4. **训练过程优化**： - 添加准确率计算 - 增加进度打印 - 保存训练损失和准确率曲线 - 使用多进程数据加载 (`num_workers=2`) 5. **可视化增强**： - 同时保存损失和准确率曲线 - 添加模型可视化方法的错误处理 ### 使用说明 1. **文件结构**： ``` project/ ├── mnist_files/ │ ├── train-images-idx3-ubyte.gz │ ├── train-labels-idx1-ubyte.gz │ ├── t10k-images-idx3-ubyte.gz │ └── t10k-labels-idx1-ubyte.gz ├── model.py # 包含OpticalNeuralNetwork类定义 ├── train.py # 此训练脚本 └── predict.py # 测试脚本 ``` 2. **运行命令**： ```bash python train.py ``` 3. **常见问题排查**： - **如果出现文件未找到错误**：检查`root_dir`路径是否正确 - **如果出现模型未定义错误**：确保`model.py`存在且包含`OpticalNeuralNetwork`类 - **如果出现内存不足**：减小`BATCH_SIZE` - **如果训练速度慢**：尝试使用GPU（如果可用） ### 模型文件示例 (model.py) 如果您的`model.py`文件缺失，这里是一个简单示例： ```python import torch.nn as nn class OpticalNeuralNetwork(nn.Module): def __init__(self): super(OpticalNeuralNetwork, self).__init__() self.flatten = nn.Flatten() self.fc1 = nn.Linear(28*28, 256) self.relu = nn.ReLU() self.fc2 = nn.Linear(256, 128) self.fc3 = nn.Linear(128, 4) # 4类输出 def forward(self, x): x = self.flatten(x) x = self.fc1(x) x = self.relu(x) x = self.fc2(x) x = self.relu(x) x = self.fc3(x) return x def visualize_phase_mask(self, epoch): # 这里可以添加相位掩模可视化代码 print(f"Visualizing phase mask at epoch {epoch} (placeholder)") ```