输入数据 → 你写的规则（if-else / 公式） → 输出结果

def is_apple(color, shape, size):
    if color == "red" and shape == "round" and size == "medium":
        return True
    else:
        return False

# 你试试看怎么写？
def recognize_digit(image):
    # 如果像素第3行第5列是黑色...如果...如果...
    # 写到天荒地老也写不完
    pass

输入数据 + 对应的答案 → 计算机自己学习 → 学出一套规则 → 用这套规则预测新数据

输入：[0, 0, 0, ..., 180, 200, 255, ...]  # 784个数字
                   ↓
         一个复杂的函数 f
                   ↓
输出：5  # 模型认为这张图画的是"5"

[ 1,  0, -1]
[ 2,  0, -2]
[ 1,  0, -1]

[ 1,  2,  1]
[ 0,  0,  0]
[-1, -2, -1]

[1, 3]     [4]
[4, 2]  →  保留最大值 4

输入图片(28×28×1)
    ↕ 卷积 + ReLU
特征图(28×28×32)
    ↕ 池化(2×2)
特征图(14×14×32)
    ↕ 卷积 + ReLU
特征图(14×14×64)
    ↕ 池化(2×2)
特征图(7×7×64)
    ↕ 展平(Flatten)
一维向量(7×7×64 = 3136)
    ↕ 全连接层
128维向量
    ↕ 全连接层
10 维向量（对应 0 到 9）
    ↕ Softmax
概率分布

输入层 → 隐藏层 → 输出层

输入 → 加权求和 → 加偏置 → 激活函数 → 传给下一层 → ... → 输出

 
前向传播：   输入 → 第一层 → 第二层 → ... → 输出层 → 损失
                                                    ↓
反向传播：   输入 ← 第一层 ← 第二层 ← ... ← 输出层 ← 损失
             ↑                              ↑
         计算第一层参数的梯度            计算输出层参数的梯度

1. 初始化网络参数（随机）
2. 重复执行以下步骤，直到损失不再下降：
   a. 取一批训练数据
   b. 前向传播：计算预测结果
   c. 计算损失（预测 vs 真实）
   d. 反向传播：计算每个参数的梯度
   e. 用优化器更新参数
3. 训练完成，参数固定下来

输入 x → [乘以 W] → [加 b] → [ReLU] → 输出 a
         ↑           ↑
       参数 W      参数 b

pip install torch torchvision matplotlib numpy

import torch                     # PyTorch 主库
import torch.nn as nn            # 神经网络模块（层、损失函数等）
import torch.nn.functional as F  # 函数式 API（激活函数等）
import torch.optim as optim      # 优化器
import torchvision               # 视觉工具（数据集、图像处理）
import torchvision.transforms as transforms  # 图像预处理
from torch.utils.data import DataLoader      # 批量数据加载器
import matplotlib.pyplot as plt  # 画图工具
import numpy as np               # 数值计算

# 定义数据预处理流程
# Compose 把多个预处理操作组合在一起
transform = transforms.Compose([
    transforms.ToTensor(),  # 把 PIL 图像或 NumPy 数组转换成 PyTorch 张量（Tensor）
                            # 同时把像素值从[0,255]缩放到[0.0, 1.0]
    transforms.Normalize(   # 标准化：让数据符合标准正态分布
        (0.1307,),          # MNIST数据集的平均灰度值
        (0.3081,)           # MNIST数据集的标准差
    )
])
 
# 下载训练集
trainset = torchvision.datasets.MNIST(
    root='./mnist_data',    # 下载路径
    train=True,             # 加载训练集（共60000张图片）
    download=True,          # 如果本地没有则自动下载
    transform=transform     # 应用上面定义的预处理
)
 
# 下载测试集
testset = torchvision.datasets.MNIST(
    root='./mnist_data',
    train=False,            # 加载测试集（共10000张图片）
    download=True,
    transform=transform
)

# DataLoader 把数据集包装成可迭代的批数据
# 就好比：一大堆数据 → DataLoader → 每次拿出一个小批次给模型
train_loader = DataLoader(
    trainset,
    batch_size=64,      # 每次随机取64张图片
    shuffle=True        # 打乱顺序（每轮训练都重新打乱，防止模型学到顺序信息）
)
 
test_loader = DataLoader(
    testset,
    batch_size=1000,    # 测试时可以大一点（不需要反向传播，不占太多显存）
    shuffle=False       # 测试不需要打乱
)

class MNISTCNN(nn.Module):
    """
    MNIST 手写数字识别的卷积神经网络模型
 
    架构：
    Conv2d(1→32) → ReLU → MaxPool(2×2) → Conv2d(32→64) → ReLU → MaxPool(2×2)
    → Flatten → FullyConnected(64*7*7→128) → ReLU → FullyConnected(128→10) → Softmax
    """
 
    def __init__(self):                      # 构造函数：定义网络的结构
        super(MNISTCNN, self).__init__()
 
        # 第一个卷积层
        # 输入通道数=1（灰度图只有1个通道，彩色图是3）
        # 输出通道数=32（使用32个不同的卷积核，得到32张特征图）
        # 卷积核大小=3×3
        # padding=1（在图像周围补一圈0，让输出尺寸和输入相同）
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
 
        # 第二个卷积层
        # 输入是上一层的32个特征图 → 输出64个特征图
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
 
        # 第一个全连接层
        # 输入：64 * 7 * 7（经过两次2×2池化后，28×28 → 14×14 → 7×7）
        # 输出：128 个神经元
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
 
        # 第二个全连接层（输出层）
        # 输入：128 → 输出：10（对应0 到 9十个数字）
        self.fc2 = nn.Linear(128, 10)
 
    def forward(self, x):                    # 前向传播：定义数据怎么流过网络
        # x的初始形状：[batch_size, 1, 28, 28]
        # batch_size=64时，形状是[64, 1, 28, 28]
 
        # 第一层：卷积 → ReLU → 池化
        x = F.relu(self.conv1(x))            # 卷积后形状：[64, 32, 28, 28]
        x = F.max_pool2d(x, 2)               # 池化后形状：[64, 32, 14, 14]
 
        # 第二层：卷积 → ReLU → 池化
        x = F.relu(self.conv2(x))            # 卷积后形状：[64, 64, 14, 14]
        x = F.max_pool2d(x, 2)               # 池化后形状：[64, 64, 7, 7]
 
        # 展平：把二维的特征图变成一维向量（才能输入到全连接层）
        x = x.view(-1, 64 * 7 * 7)           # 展平后形状：[64, 3136]
 
        # 全连接层
        x = F.relu(self.fc1(x))              # 形状：[64, 128]
        x = self.fc2(x)                      # 形状：[64, 10]（注意：这里没有Softmax）
 
        # 为什么不在这里加Softmax？
        # 因为PyTorch的交叉熵损失函数 nn.CrossEntropyLoss 内部自带Softmax
        # 如果在输出层加了Softmax，再传给CrossEntropyLoss，就等于做了两次Softmax
        return x
 
    def predict(self, x):
        """推理方法：输入一张图片，输出预测的数字"""
        self.eval()                          # 切换到评估模式（关闭 Dropout 等训练特有操作）
        with torch.no_grad():                # 关闭梯度计算（推理不需要反向传播，节省显存和速度）
            logits = self.forward(x)         # 前向传播得到原始输出（logits）
            probabilities = F.softmax(logits, dim=1)  # 用Softmax转成概率
            predicted = torch.argmax(probabilities, dim=1)  # 取概率最大的类别
        return predicted, probabilities

def train(model, device, train_loader, optimizer, epoch):
    """
    训练一个 epoch（一个 epoch = 把所有训练数据完整过一遍）
 
    参数说明：
    - model: 要训练的模型
    - device: 在 CPU 还是 GPU 上训练
    - train_loader: 训练数据的DataLoader
    - optimizer: 优化器（控制如何更新参数）
    - epoch: 当前是第几个 epoch（仅用来显示进度）
    """
    model.train()  # 切换到训练模式（打开 Dropout、BatchNorm 等训练特有操作）
 
    for batch_idx, (data, target) in enumerate(train_loader):
        # data:  一批图片，形状为 [64, 1, 28, 28]
        # target:这批图片对应的标签，形状为 [64]（每个数字0 到 9）
 
        # 把数据搬到指定设备（CPU 或 GPU）
        data, target = data.to(device), target.to(device)
 
        # 非常重要：把梯度清零
        # 因为PyTorch默认会累加梯度，不清零的话每次反向传播都会把新梯度和旧梯度相加
        optimizer.zero_grad()
 
        # 前向传播：把数据喂给模型，得到输出
        output = model(data)                 # output形状：[64, 10]
 
        # 计算损失
        # CrossEntropyLoss = LogSoftmax + NLLLoss
        # 先对output做Softmax转成概率，再计算交叉熵
        loss = F.cross_entropy(output, target)
 
        # 反向传播：计算每个参数的梯度
        loss.backward()
 
        # 更新参数：optimizer 根据梯度调整参数
        optimizer.step()
 
        # 每100批打印一次训练进度
        if batch_idx % 100 == 0:
            print(f'Epoch {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} '
                  f'({100. * batch_idx / len(train_loader):.0f}%)] Loss: {loss.item():.6f}')
 
 
def test(model, device, test_loader):
    """在测试集上评估模型性能"""
    model.eval()    # 切换到评估模式
 
    test_loss = 0
    correct = 0
 
    # with torch.no_grad(): 这个上下文管理器告诉PyTorch不要记录梯度
    # 在测试/推理时使用，可以显著减少内存占用并加快速度
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
 
            # 前向传播
            output = model(data)
 
            # 累加损失
            test_loss += F.cross_entropy(output, target, reduction='sum').item()
 
            # 获取预测结果（预测概率最大的那个类别）
            pred = output.argmax(dim=1, keepdim=True)
 
            # 统计正确预测的数量
            correct += pred.eq(target.view_as(pred)).sum().item()
 
    test_loss /= len(test_loader.dataset)
    accuracy = 100. * correct / len(test_loader.dataset)
 
    print(f'Test set: Average loss: {test_loss:.4f}, '
          f'Accuracy: {correct}/{len(test_loader.dataset)} ({accuracy:.2f}%)')
 
    return accuracy

def main():
    """主函数：组装所有组件并开始训练"""
 
    # 检测是否有可用的 GPU
    # CUDA是NVIDIA的并行计算平台，有了 GPU 训练速度可以快几十倍
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"Using device: {device}")
 
    # 超参数设置
    batch_size = 64      # 每批64张图片
    epochs = 10          # 训练10轮（反复学习10遍整个数据集）
    learning_rate = 0.001  # 学习率（Adam优化器通常用0.001）
 
    # 1. 加载数据
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])
 
    trainset = torchvision.datasets.MNIST(
        root='./mnist_data', train=True, download=True, transform=transform)
    testset = torchvision.datasets.MNIST(
        root='./mnist_data', train=False, download=True, transform=transform)
 
    train_loader = DataLoader(trainset, batch_size=batch_size, shuffle=True)
    test_loader = DataLoader(testset, batch_size=1000, shuffle=False)
 
    # 2. 创建模型并移动到设备（CPU / GPU）
    model = MNISTCNN().to(device)
 
    # 3. 定义优化器
    # Adam是一种自适应学习率的优化器，
    # 它会为每个参数单独维护学习率，通常比SGD更容易使用
    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
 
    # 4. 训练循环
    print("Starting training...")
    for epoch in range(1, epochs + 1):
        train(model, device, train_loader, optimizer, epoch)
        accuracy = test(model, device, test_loader)
 
    print("Training complete!")
 
    # 5. 保存训练好的模型
    torch.save(model.state_dict(), "mnist_cnn.pth")
    print("Model saved as mnist_cnn.pth")
 
 
if __name__ == '__main__':
    main()

Using device: cpu
Starting training...
Epoch 1 [0/60000 (0%)] Loss: 2.301221
Epoch 1 [6400/60000 (11%)] Loss: 0.264532
Epoch 1 [12800/60000 (21%)] Loss: 0.127508
...
Test set: Average loss: 0.0456, Accuracy: 9856/10000 (98.56%)
Epoch 2 ...
Test set: Average loss: 0.0321, Accuracy: 9898/10000 (98.98%)
...
Epoch 10 ...
Test set: Average loss: 0.0234, Accuracy: 9935/10000 (99.35%)

def predict_single_image(model, image_tensor):
    """
    预测单张图片中的数字
 
    参数：
    - model: 训练好的模型
    - image_tensor: 一张图片的Tensor，应为 [1, 28, 28] 或 [1, 1, 28, 28] 形状
 
    返回：
    - predicted_digit: 预测的数字 (int)
    - probabilities: 每个数字的概率 (numpy array, 长度10)
    """
    device = next(model.parameters()).device  # 获取模型所在的设备
 
    # 确保输入是4D张量 [batch_size, channels, height, width]
    if image_tensor.dim() == 3:  # [1, 28, 28]
        image_tensor = image_tensor.unsqueeze(0)  # 变成 [1, 1, 28, 28]
 
    # 移动到正确的设备
    image_tensor = image_tensor.to(device)
 
    # 推理
    model.eval()
    with torch.no_grad():
        logits = model(image_tensor)
        probabilities = F.softmax(logits, dim=1)
        predicted_digit = torch.argmax(probabilities, dim=1).item()
 
    return predicted_digit, probabilities.cpu().numpy().flatten()
 
 
def visualize_prediction(image, predicted_digit, probabilities):
    """可视化预测结果"""
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))
 
    # 显示图片
    if isinstance(image, torch.Tensor):
        image = image.numpy().squeeze()
    ax1.imshow(image, cmap='gray')
    ax1.set_title(f'Predicted: {predicted_digit}', fontsize=14)
    ax1.axis('off')
 
    # 显示概率柱状图
    digits = list(range(10))
    colors = ['steelblue'] * 10
    colors[predicted_digit] = 'coral'
    ax2.bar(digits, probabilities * 100, color=colors)
    ax2.set_xlabel('Digit')
    ax2.set_ylabel('Confidence (%)')
    ax2.set_title('Prediction Probability Distribution')
    ax2.set_xticks(digits)
 
    for i, prob in enumerate(probabilities):
        ax2.text(i, prob * 100 + 0.5, f'{prob*100:.1f}%', ha='center', fontsize=8)
 
    plt.tight_layout()
    plt.show()
 
 
# 使用示例：从测试集中取一张图片试试
if __name__ == '__main__':
    # 1. 重新加载模型（假设已经训练好并保存了 mnist_cnn.pth）
    model = MNISTCNN()
    model.load_state_dict(torch.load("mnist_cnn.pth", map_location='cpu'))
 
    # 2. 加载测试集
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])
    testset = torchvision.datasets.MNIST(
        root='./mnist_data', train=False, download=True, transform=transform)
 
    # 3. 取第一张图片试试
    image, true_label = testset[0]
    predicted_digit, probabilities = predict_single_image(model, image)
 
    print(f"True digit: {true_label}")
    print(f"Predicted: {predicted_digit}")
    print(f"Confidence: {probabilities[predicted_digit]*100:.2f}%")
    print("All class probabilities:")
    for i, prob in enumerate(probabilities):
        print(f"  Digit {i}: {prob*100:.1f}%")
 
    # 4. 可视化结果
    visualize_prediction(image, predicted_digit, probabilities)

"""
MNIST 手写数字识别 - 完整可运行代码
PyTorch + CNN
"""
import torch
import torch.nn as nn
import torch.nn.functional as F
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import numpy as np
 
 
# ═══════════════════════════════════════════════════════
# 1. 定义CNN模型
# ═══════════════════════════════════════════════════════
class MNISTCNN(nn.Module):
    def __init__(self):
        super(MNISTCNN, self).__init__()
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, padding=1)
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, padding=1)
        self.fc1 = nn.Linear(64 * 7 * 7, 128)
        self.fc2 = nn.Linear(128, 10)
 
    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = F.max_pool2d(x, 2)
        x = F.relu(self.conv2(x))
        x = F.max_pool2d(x, 2)
        x = x.view(-1, 64 * 7 * 7)
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x
 
    def predict(self, x):
        self.eval()
        with torch.no_grad():
            logits = self.forward(x)
            probabilities = F.softmax(logits, dim=1)
            predicted = torch.argmax(probabilities, dim=1)
        return predicted, probabilities
 
 
# ═══════════════════════════════════════════════════════
# 2. 训练函数
# ═══════════════════════════════════════════════════════
def train(model, device, train_loader, optimizer, epoch):
    model.train()
    for batch_idx, (data, target) in enumerate(train_loader):
        data, target = data.to(device), target.to(device)
        optimizer.zero_grad()
        output = model(data)
        loss = F.cross_entropy(output, target)
        loss.backward()
        optimizer.step()
        if batch_idx % 100 == 0:
            print(f'Epoch {epoch} [{batch_idx * len(data)}/{len(train_loader.dataset)} '
                  f'({100. * batch_idx / len(train_loader):.0f}%)] Loss: {loss.item():.6f}')
 
 
def test(model, device, test_loader):
    model.eval()
    test_loss = 0
    correct = 0
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            test_loss += F.cross_entropy(output, target, reduction='sum').item()
            pred = output.argmax(dim=1, keepdim=True)
            correct += pred.eq(target.view_as(pred)).sum().item()
    test_loss /= len(test_loader.dataset)
    accuracy = 100. * correct / len(test_loader.dataset)
    print(f'Test set: Average loss: {test_loss:.4f}, '
          f'Accuracy: {correct}/{len(test_loader.dataset)} ({accuracy:.2f}%)')
    return accuracy
 
 
# ═══════════════════════════════════════════════════════
# 3. 推理函数
# ═══════════════════════════════════════════════════════
def predict_single_image(model, image_tensor):
    device = next(model.parameters()).device
    if image_tensor.dim() == 3:
        image_tensor = image_tensor.unsqueeze(0)
    image_tensor = image_tensor.to(device)
    model.eval()
    with torch.no_grad():
        logits = model(image_tensor)
        probabilities = F.softmax(logits, dim=1)
        predicted_digit = torch.argmax(probabilities, dim=1).item()
    return predicted_digit, probabilities.cpu().numpy().flatten()
 
 
def visualize_prediction(image, predicted_digit, probabilities):
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(10, 4))
    if isinstance(image, torch.Tensor):
        image = image.numpy().squeeze()
    ax1.imshow(image, cmap='gray')
    ax1.set_title(f'Predicted: {predicted_digit}', fontsize=14)
    ax1.axis('off')
    digits = list(range(10))
    colors = ['steelblue'] * 10
    colors[predicted_digit] = 'coral'
    ax2.bar(digits, probabilities * 100, color=colors)
    ax2.set_xlabel('Digit')
    ax2.set_ylabel('Confidence (%)')
    ax2.set_title('Prediction Probability Distribution')
    ax2.set_xticks(digits)
    for i, prob in enumerate(probabilities):
        ax2.text(i, prob * 100 + 0.5, f'{prob*100:.1f}%', ha='center', fontsize=8)
    plt.tight_layout()
    plt.show()
 
 
# ═══════════════════════════════════════════════════════
# 4. 主函数
# ═══════════════════════════════════════════════════════
def main():
    device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
    print(f"Using device: {device}")
 
    # 超参数
    batch_size = 64
    epochs = 10
    learning_rate = 0.001
 
    # 数据预处理
    transform = transforms.Compose([
        transforms.ToTensor(),
        transforms.Normalize((0.1307,), (0.3081,))
    ])
 
    # 加载数据
    trainset = torchvision.datasets.MNIST(
        root='./mnist_data', train=True, download=True, transform=transform)
    testset = torchvision.datasets.MNIST(
        root='./mnist_data', train=False, download=True, transform=transform)
    train_loader = DataLoader(trainset, batch_size=batch_size, shuffle=True)
    test_loader = DataLoader(testset, batch_size=1000, shuffle=False)
 
    # 创建模型
    model = MNISTCNN().to(device)
 
    # 定义优化器
    optimizer = optim.Adam(model.parameters(), lr=learning_rate)
 
    # 训练
    print("Starting training...")
    for epoch in range(1, epochs + 1):
        train(model, device, train_loader, optimizer, epoch)
        accuracy = test(model, device, test_loader)
    print("Training complete!")
 
    # 保存模型
    torch.save(model.state_dict(), "mnist_cnn.pth")
    print("Model saved as mnist_cnn.pth")
 
    # 推理演示
    print("\nInference demo on test set...")
    image, true_label = testset[0]
    predicted, probs = predict_single_image(model, image)
    print(f"True digit: {true_label}, Predicted: {predicted}, "
          f"Confidence: {probs[predicted]*100:.2f}%")
 
    # 选出模型最确定和最不确定的样本
    print("\nAnalyzing predictions...")
    model.eval()
    confident_samples = []
    uncertain_samples = []
    with torch.no_grad():
        for data, target in test_loader:
            data, target = data.to(device), target.to(device)
            output = model(data)
            probs_all = F.softmax(output, dim=1)
            max_probs, preds = torch.max(probs_all, dim=1)
            for i in range(len(data)):
                if preds[i] == target[i]:
                    confident_samples.append((max_probs[i].item(), data[i], target[i].item()))
                else:
                    uncertain_samples.append((max_probs[i].item(), data[i], target[i].item(), preds[i].item()))
 
    # 排序并展示
    confident_samples.sort(reverse=True)
    uncertain_samples.sort()
 
    if uncertain_samples:
        print(f"\nMost uncertain prediction (failed case):")
        prob, img, true_lbl, pred_lbl = uncertain_samples[0]
        print(f"  True: {true_lbl}, Predicted: {pred_lbl}, Confidence: {prob*100:.2f}%")
 
    print(f"\nBest prediction:")
    prob, img, true_lbl = confident_samples[0]
    print(f"  True: {true_lbl}, Confidence: {prob*100:.2f}%")
 
 
if __name__ == '__main__':
    main()

from PIL import Image
 
# 用户上传的图片可能是彩色的、尺寸可能不同
user_image = Image.open("user_uploaded_digit.png")
 
# 预处理：
# 1. 转灰度图（因为我们训练时用的是灰度图）
user_image = user_image.convert("L")
 
# 2. 缩放至28×28（因为模型只认识28×28的尺寸）
user_image = user_image.resize((28, 28))
 
# 3. 转Tensor并标准化
transform = transforms.Compose([
    transforms.ToTensor(),
    transforms.Normalize((0.1307,), (0.3081,))
])
tensor = transform(user_image)  # 形状：[1, 28, 28]
 
# 4. 增加batch维度
tensor = tensor.unsqueeze(0)    # 形状：[1, 1, 28, 28]

model = MNISTCNN()
model.load_state_dict(torch.load("mnist_cnn.pth"))
model.eval()
 
with torch.no_grad():
    logits = model(tensor)  # 形状：[1, 10]

probabilities = F.softmax(logits, dim=1)

predicted = torch.argmax(probabilities, dim=1).item()  # 输出：3

result = {
    "digit": predicted,            # 3
    "confidence": float(probabilities[0][predicted])  # 0.836
}