终于把卷积神经网络算法搞懂了！！！

import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
from tensorflow.keras.utils import to_categorical
import matplotlib.pyplot as plt
import numpy as np

# 加载 MNIST 数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0
x_train = x_train.reshape((x_train.shape[0], 28, 28, 1))
x_test = x_test.reshape((x_test.shape[0], 28, 28, 1))
y_train = to_categorical(y_train, 10)  # 10 是类别数（0-9的数字）
y_test = to_categorical(y_test, 10)

# 构建卷积神经网络模型
model = models.Sequential()
# 卷积层 1：32 个 3x3 的卷积核，使用 ReLU 激活函数
model.add(layers.Conv2D(32, (3, 3), activatinotallow='relu', input_shape=(28, 28, 1)))
# 池化层：2x2 最大池化
model.add(layers.MaxPooling2D((2, 2)))
# 卷积层 2：64 个 3x3 的卷积核，使用 ReLU 激活函数
model.add(layers.Conv2D(64, (3, 3), activatinotallow='relu'))
# 池化层：2x2 最大池化
model.add(layers.MaxPooling2D((2, 2)))
# 卷积层 3：128 个 3x3 的卷积核，使用 ReLU 激活函数
model.add(layers.Conv2D(128, (3, 3), activatinotallow='relu'))
# 展平层：将二维数据展平为一维数据
model.add(layers.Flatten())
# 全连接层：128 个神经元，ReLU 激活函数
model.add(layers.Dense(128, activatinotallow='relu'))
# 输出层：10 个神经元，对应 10 个类别（数字 0-9），softmax 激活函数
model.add(layers.Dense(10, activatinotallow='softmax'))

model.compile(optimizer='adam',  # 使用 Adam 优化器
              loss='categorical_crossentropy',  # 多类交叉熵损失函数
              metrics=['accuracy'])  # 评估标准：准确率

# 训练模型
model.fit(x_train, y_train, epochs=5, batch_size=64, validation_data=(x_test, y_test))

# 评估模型性能
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f'测试集准确率: {test_acc:.4f}')
predictions = model.predict(x_test[:5])

# 可视化预测结果和图像
for i in range(5):
    plt.subplot(1, 5, i+1)  
    plt.imshow(x_test[i].reshape(28, 28), cmap='gray')  
    plt.title(f"预测: {predictions[i].argmax()}")  
plt.show()
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

# 数据加载与预处理
transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.5,), (0.5,))])

# 加载 MNIST 数据集
trainset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
testset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)

trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

# 定义卷积神经网络模型
class CNN(nn.Module):
    def __init__(self):
        super(CNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)  # 1通道输入，32通道输出，3x3卷积核
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)  # 32通道输入，64通道输出，3x3卷积核
        self.conv3 = nn.Conv2d(64, 128, kernel_size=3, padding=1)  # 64通道输入，128通道输出，3x3卷积核
        self.fc1 = nn.Linear(128 * 3 * 3, 128)  # 全连接层，输入维度为卷积输出的展开维度
        self.fc2 = nn.Linear(128, 10)  # 输出层，10个数字类别

    def forward(self, x):
        x = torch.relu(self.conv1(x))
        x = torch.max_pool2d(x, 2)  # 2x2最大池化
        x = torch.relu(self.conv2(x))
        x = torch.max_pool2d(x, 2)  # 2x2最大池化
        x = torch.relu(self.conv3(x))
        x = torch.max_pool2d(x, 2)  # 2x2最大池化
        x = x.view(-1, 128 * 3 * 3)  # 展平
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 初始化模型、损失函数和优化器
model = CNN()
criterion = nn.CrossEntropyLoss()  # 使用交叉熵损失
optimizer = optim.Adam(model.parameters(), lr=0.001)  # 使用Adam优化器

# 训练模型
num_epochs = 5
for epoch in range(num_epochs):
    model.train()  # 设置模型为训练模式
    running_loss = 0.0
    for i, (inputs, labels) in enumerate(trainloader, 0):
        optimizer.zero_grad()  # 清零梯度
        outputs = model(inputs)  # 计算模型输出
        loss = criterion(outputs, labels)  # 计算损失
        loss.backward()  # 反向传播
        optimizer.step()  # 更新参数
        running_loss += loss.item()

    print(f"Epoch {epoch+1}, Loss: {running_loss/len(trainloader)}")

print("Finished Training")

# 测试模型
model.eval()  # 设置模型为评估模式
correct = 0
total = 0
with torch.no_grad():  # 在测试时不计算梯度，减少内存消耗
    for inputs, labels in testloader:
        outputs = model(inputs)
        _, predicted = torch.max(outputs, 1)
        total += labels.size(0)
        correct += (predicted == labels).sum().item()

print(f"Test Accuracy: {100 * correct / total:.2f}%")

# 获取前 5 张图片及其预测结果
dataiter = iter(testloader)
images, labels = dataiter.next()

# 获取模型预测结果
model.eval()  # 设置模型为评估模式
outputs = model(images)
_, predicted = torch.max(outputs, 1)

# 显示图像和预测结果
fig, axes = plt.subplots(1, 5, figsize=(12, 3))
for i in range(5):
    ax = axes[i]
    ax.imshow(images[i].numpy().squeeze(), cmap='gray')  # 显示图像
    ax.set_title(f"Pred: {predicted[i].item()}\nTrue: {labels[i].item()}")
    ax.axis('off')

plt.show()
1.
2.
3.
4.
5.
6.
7.
8.
9.
10.
11.
12.
13.
14.
15.
16.
17.
18.
19.
20.
21.
22.
23.
24.
25.
26.
27.
28.
29.
30.
31.
32.
33.
34.
35.
36.
37.
38.
39.
40.
41.
42.
43.
44.
45.
46.
47.
48.
49.
50.
51.
52.
53.
54.
55.
56.
57.
58.
59.
60.
61.
62.
63.
64.
65.
66.
67.
68.
69.
70.
71.
72.
73.
74.
75.
76.
77.
78.
79.
80.
81.
82.
83.
84.
85.
86.
87.
88.
89.
90.
91.
92.
93.