卷积神经网络（CNN）深度学习实战：原理拆解与代码实现全流程

import torch.nn as nn

# 定义一个卷积层：输入3通道，输出16通道，3x3卷积核，步幅1，填充1
conv_layer = nn.Conv2d(in_channels=3, out_channels=16, kernel_size=3, stride=1, padding=1)

# 2x2池化核，步幅2（刚好不重叠）
pool_layer = nn.MaxPool2d(kernel_size=2, stride=2)

import torchvision.transforms as transforms
from torch.utils.data import DataLoader

# 预处理 pipeline
transform = transforms.Compose([
    transforms.RandomHorizontalFlip(),  # 随机水平翻转（数据增强）
    transforms.ToTensor(),  # 转换成张量（shape: [C, H, W]）
    transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))  # 归一化到[-1,1]
])

# 加载训练集和测试集
train_set = torchvision.datasets.CIFAR10(root="./data", train=True, download=True, transform=transform)
test_set = torchvision.datasets.CIFAR10(root="./data", train=False, download=True, transform=transform)

# 数据加载器（batch_size=64，打乱训练集）
train_loader = DataLoader(train_set, batch_size=64, shuffle=True, num_workers=2)
test_loader = DataLoader(test_set, batch_size=64, shuffle=False, num_workers=2)

# 类别标签（CIFAR-10的10类）
classes = ('plane', 'car', 'bird', 'cat', 'deer', 'dog', 'frog', 'horse', 'ship', 'truck')

class SimpleCNN(nn.Module):
    def __init__(self, num_classes=10):
        super(SimpleCNN, self).__init__()
        # 卷积块1：Conv -> ReLU -> MaxPool
        self.conv1 = nn.Conv2d(3, 16, 3, padding=1)  # 3→16通道，3x3卷积
        self.relu = nn.ReLU()  # 激活函数（解决梯度消失）
        self.pool = nn.MaxPool2d(2, 2)  # 2x2池化

        # 卷积块2：Conv -> ReLU -> MaxPool
        self.conv2 = nn.Conv2d(16, 32, 3, padding=1)  # 16→32通道

        # 全连接层：Flatten -> Dense -> Dropout -> Dense
        self.fc1 = nn.Linear(32 * 8 * 8, 128)  # 32通道×8x8特征图 → 128维
        self.dropout = nn.Dropout(0.5)  # 随机丢弃50%神经元，防止过拟合
        self.fc2 = nn.Linear(128, num_classes)  # 128→10类

    def forward(self, x):
        # 前向传播流程
        x = self.pool(self.relu(self.conv1(x)))  # 卷积→激活→池化
        x = self.pool(self.relu(self.conv2(x)))  # 第二次卷积→激活→池化
        x = torch.flatten(x, 1)  # 展平：[batch, 32, 8, 8] → [batch, 32*8*8]
        x = self.relu(self.fc1(x))  # 全连接→激活
        x = self.dropout(x)  # Dropout正则化
        x = self.fc2(x)  # 输出层（不激活，因为损失函数会处理）
        return x

import torch.optim as optim

# 设备配置（优先用GPU，没有则用CPU）
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"Using device: {device}")

# 初始化模型、损失函数、优化器
model = SimpleCNN(num_classes=10).to(device)
criterion = nn.CrossEntropyLoss()  # 交叉熵损失
optimizer = optim.Adam(model.parameters(), lr=0.001)  # Adam优化器，学习率0.001

# 训练循环（10个epoch）
num_epochs = 10
for epoch in range(num_epochs):
    running_loss = 0.0
    model.train()  # 切换到训练模式（开启Dropout）

    for i, (images, labels) in enumerate(train_loader):
        # 把数据移到GPU（如果有的话）
        images, labels = images.to(device), labels.to(device)

        # 1. 梯度清零（避免梯度累加）
        optimizer.zero_grad()

        # 2. 前向传播
        outputs = model(images)

        # 3. 计算损失
        loss = criterion(outputs, labels)

        # 4. 反向传播（计算梯度）
        loss.backward()

        # 5. 更新参数
        optimizer.step()

        # 统计损失
        running_loss += loss.item()
        if i % 100 == 99:  # 每100个batch打印一次
            print(f"Epoch [{epoch+1}/{num_epochs}], Batch [{i+1}/{len(train_loader)}], Loss: {running_loss/100:.4f}")
            running_loss = 0.0

print("训练完成！")

model.eval()  # 切换到评估模式（关闭Dropout）
correct = 0
total = 0

with torch.no_grad():  # 关闭梯度计算，节省内存
    for images, labels in test_loader:
        images, labels = images.to(device), labels.to(device)
        outputs = model(images)
        _, predicted = torch.max(outputs.data, 1)  # 获取概率最大的类别

        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"模型在测试集上的准确率：{100 * correct / total:.2f}%")

import tensorflow as tf
from tensorflow.keras import layers, models

# 定义模型
def build_cnn_tf(num_classes=10):
    model = models.Sequential([
        layers.Conv2D(16, (3,3), padding='same', activation='relu', input_shape=(32,32,3)),
        layers.MaxPooling2D((2,2)),
        layers.Conv2D(32, (3,3), padding='same', activation='relu'),
        layers.MaxPooling2D((2,2)),
        layers.Flatten(),
        layers.Dense(128, activation='relu'),
        layers.Dropout(0.5),
        layers.Dense(num_classes, activation='softmax')
    ])
    return model

# 编译模型
model_tf = build_cnn_tf()
model_tf.compile(optimizer='adam',
                loss=tf.keras.losses.SparseCategoricalCrossentropy(),
                metrics=['accuracy'])

# 加载数据（TensorFlow版）
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.cifar10.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0  # 归一化到[0,1]

# 训练模型
history = model_tf.fit(x_train, y_train, epochs=10, batch_size=64, validation_data=(x_test, y_test))