import torch
import torch.nn as nn# 定义卷积层：输入通道1，输出通道16，3x3卷积核
conv_layer = nn.Conv2d(in_channels=1, out_channels=16, kernel_size=3, stride=1, padding=1)# 模拟输入数据：batch_size=4，1通道，28x28图像
input_data = torch.randn(4, 1, 28, 28)# 前向传播
output = conv_layer(input_data)
print(f"输入尺寸: {input_data.shape}")
print(f"输出尺寸: {output.shape}")  # [4, 16, 28, 28]

# 最大池化：2x2窗口，步长2
max_pool = nn.MaxPool2d(kernel_size=2, stride=2)# 对卷积层输出进行池化
pooled_output = max_pool(output)
print(f"池化后尺寸: {pooled_output.shape}")  # [4, 16, 14, 14]

relu = nn.ReLU()
activated_output = relu(pooled_output)

from torchvision import datasets, transforms
from torch.utils.data import DataLoader# 数据增强和归一化
transform_train = transforms.Compose([transforms.RandomHorizontalFlip(),transforms.RandomRotation(10),transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])transform_test = transforms.Compose([transforms.ToTensor(),transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])# 加载数据集
train_dataset = datasets.CIFAR10(root='./data', train=True, download=True, transform=transform_train)
test_dataset = datasets.CIFAR10(root='./data', train=False, download=True, transform=transform_test)# 创建数据加载器
train_loader = DataLoader(train_dataset, batch_size=128, shuffle=True, num_workers=2)
test_loader = DataLoader(test_dataset, batch_size=100, shuffle=False, num_workers=2)# 类别名称
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

class AdvancedCNN(nn.Module):def __init__(self):super(AdvancedCNN, self).__init__()self.conv_block1 = nn.Sequential(nn.Conv2d(3, 32, 3, padding=1),nn.BatchNorm2d(32),nn.ReLU(),nn.Conv2d(32, 32, 3, padding=1),nn.ReLU(),nn.MaxPool2d(2))self.conv_block2 = nn.Sequential(nn.Conv2d(32, 64, 3, padding=1),nn.BatchNorm2d(64),nn.ReLU(),nn.Conv2d(64, 64, 3, padding=1),nn.ReLU(),nn.MaxPool2d(2))self.fc_block = nn.Sequential(nn.Linear(64 * 8 * 8, 512),nn.ReLU(),nn.Dropout(0.5),nn.Linear(512, 10))def forward(self, x):x = self.conv_block1(x)x = self.conv_block2(x)x = x.view(x.size(0), -1)  # 展平x = self.fc_block(x)return xmodel = AdvancedCNN().to('cuda' if torch.cuda.is_available() else 'cpu')
print(model)

import torch.optim as optim
from torch.optim.lr_scheduler import StepLRcriterion = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=0.001)
scheduler = StepLR(optimizer, step_size=5, gamma=0.5)  # 每5个epoch学习率减半def train(epoch):model.train()running_loss = 0.0correct = 0total = 0for batch_idx, (inputs, targets) in enumerate(train_loader):inputs, targets = inputs.to(device), targets.to(device)optimizer.zero_grad()outputs = model(inputs)loss = criterion(outputs, targets)loss.backward()optimizer.step()running_loss += loss.item()_, predicted = outputs.max(1)total += targets.size(0)correct += predicted.eq(targets).sum().item()if batch_idx % 100 == 0:print(f'Epoch: {epoch} | Batch: {batch_idx}/{len(train_loader)} | Loss: {loss.item():.3f}')train_loss = running_loss / len(train_loader)train_acc = 100. * correct / totalprint(f'Train Epoch: {epoch} | Loss: {train_loss:.3f} | Accuracy: {train_acc:.2f}%')return train_loss, train_accdef test():model.eval（)test_loss = 0correct = 0total = 0with torch.no_grad():for batch_idx, (inputs, targets) in enumerate(test_loader):inputs, targets = inputs.to(device), targets.to(device)outputs = model(inputs)loss = criterion(outputs, targets)test_loss += loss.item()_, predicted = outputs.max(1)total += targets.size(0)correct += predicted.eq(targets).sum().item()test_loss /= len(test_loader)test_acc = 100. * correct / totalprint(f'Test Results: Loss: {test_loss:.3f} | Accuracy: {test_acc:.2f}%\n')return test_loss, test_acc# 训练20个epoch
for epoch in range(1, 21):train_loss, train_acc = train(epoch)test_loss, test_acc = test()scheduler.step()# 保存最佳模型if epoch == 1 or test_acc > best_acc:best_acc = test_acctorch.save(model.state_dict(), 'best_model.pth')

import matplotlib.pyplot as plt
import numpy as np# 可视化卷积核
def visualize_filters(layer, n_filters=16):filters = layer.weight.data.cpu().numpy()plt.figure(figsize=(10, 5))for i in range(n_filters):plt.subplot(2, 8, i+1)plt.imshow(filters[i][0], cmap='gray')plt.axis('off')plt.show()visualize_filters(model.conv_block1[0])# 显示错误分类样本
def show_errors():model.eval（)errors = []with torch.no_grad():for images, labels in test_loader:images, labels = images.to(device), labels.to(device)outputs = model(images)_, preds = torch.max(outputs, 1)wrong = (preds != labels).nonzero().squeeze()for i in wrong[:5]:  # 显示前5个错误errors.append((images[i], preds[i], labels[i]))if len(errors) >= 5:breakif len(errors) >= 5:breakplt.figure(figsize=(12, 5))for idx, (img, pred, true) in enumerate(errors):img = img.cpu().numpy().transpose((1, 2, 0))img = np.clip((img * 0.5 + 0.5), 0, 1)  # 反归一化plt.subplot(1, 5, idx+1)plt.imshow(img)plt.title(f'Pred: {classes[pred]}\nTrue: {classes[true]}')plt.axis('off')plt.show()show_errors()

nn.BatchNorm2d(num_features)

class ResidualBlock(nn.Module):def __init__(self, in_channels, out_channels, stride=1):super().__init__()self.conv1 = nn.Conv2d(in_channels, out_channels, 3, stride, 1)self.bn1 = nn.BatchNorm2d(out_channels)self.conv2 = nn.Conv2d(out_channels, out_channels, 3, 1, 1)self.bn2 = nn.BatchNorm2d(out_channels)self.shortcut = nn.Sequential()if stride != 1 or in_channels != out_channels:self.shortcut = nn.Sequential(nn.Conv2d(in_channels, out_channels, 1, stride),nn.BatchNorm2d(out_channels))def forward(self, x):out = F.relu(self.bn1(self.conv1(x)))out = self.bn2(self.conv2(out))out += self.shortcut(x)return F.relu(out)

transform = transforms.Compose([transforms.RandomHorizontalFlip(),transforms.RandomVerticalFlip(),transforms.RandomRotation(15),transforms.ColorJitter(brightness=0.2, contrast=0.2, saturation=0.2),transforms.RandomAffine(degrees=0, translate=(0.1, 0.1)),transforms.ToTensor(),transforms.Normalize(...)
])

dummy_input = torch.randn(1, 3, 32, 32).to(device)
torch.onnx.export(model, dummy_input, "cifar_model.onnx", input_names=["input"], output_names=["output"],dynamic_axes={"input": {0: "batch_size"}, "output": {0: "batch_size"}})