1
def save(self, path="mnist_model.npz"):
2
    """
3
    保存模型参数
4
    参数:
5
        path: 保存路径
6
    """
7
    np.savez(
8
        path,
9
        W1=self.W1, b1=self.b1,
10
        W2=self.W2, b2=self.b2
11
    )
12
    print(f"Model saved to {path}")

1
def load(self, path="mnist_model.npz"):
2
    """
3
    加载模型参数
4
    参数:
5
        path: 模型文件路径
6
    """
7
    data = np.load(path)
8
    self.W1 = data["W1"]
9
    self.b1 = data["b1"]
10
    self.W2 = data["W2"]
11
    self.b2 = data["b2"]
12
    print(f"Model loaded from {path}")

1
def predict(self, X):
2
    """
3
    推理（预测）
4
    参数:
5
        X: 输入图像，形状 (batch_size, 28, 28, 1)
6
    返回:
7
        预测类别，形状 (batch_size,)
8
    """
9
    y_pred = self.forward(X)
10
    return np.argmax(y_pred, axis=1)

1
import matplotlib.pyplot as plt
2
import random
3

4
# 加载模型
5
model.load("mnist_model.npz")
6

7
# 随机挑 10 张图像
8
indices = random.sample(range(len(X_test)), 10)
9

10
plt.figure(figsize=(15, 3))
11
for i, idx in enumerate(indices):
12
    # 推理
13
    img = X_test[idx:idx+1]
14
    pred_class = model.predict(img)[0]
15
    true_class = np.argmax(y_test[idx])
16

17
    # 可视化
18
    plt.subplot(2, 5, i+1)
19
    plt.imshow(img.squeeze(), cmap="gray")
20

21
    # 标题：绿色表示正确，红色表示错误
22
    color = "green" if pred_class == true_class else "red"
23
    plt.title(f"Pred: {pred_class}\nTrue: {true_class}", color=color)
24
    plt.axis("off")
25

26
plt.tight_layout()
27
plt.show()

1
import numpy as np
2

3
# 查看模型文件
4
data = np.load("mnist_model.npz")
5

6
print("模型包含的参数:")
7
for key in data.files:
8
    print(f"  {key}: shape={data[key].shape}, dtype={data[key].dtype}")
9

10
# 计算总参数量
11
total_params = sum(data[key].size for key in data.files)
12
print(f"\n总参数量: {total_params:,}")

1
模型包含的参数:
2
  W1: shape=(784, 128), dtype=float64
3
  b1: shape=(1, 128), dtype=float64
4
  W2: shape=(128, 10), dtype=float64
5
  b2: shape=(1, 10), dtype=float64
6

7
总参数量: 101,514

1
class MinimalClassifier:
2
    def __init__(self, input_dim, hidden_dim, output_dim, lr=0.01):
3
        self.lr = lr
4
        self.W1 = np.random.randn(input_dim, hidden_dim) * 0.01
5
        self.b1 = np.zeros((1, hidden_dim))
6
        self.W2 = np.random.randn(hidden_dim, output_dim) * 0.01
7
        self.b2 = np.zeros((1, output_dim))
8

9
    def forward(self, X):
10
        self.X = flatten(X)
11
        self.z1 = self.X @ self.W1 + self.b1
12
        self.a1 = relu(self.z1)
13
        self.z2 = self.a1 @ self.W2 + self.b2
14
        self.y_pred = softmax(self.z2)
15
        return self.y_pred
16

17
    def backward(self, y_true):
18
        dL_dz2 = softmax_cross_entropy_grad(self.y_pred, y_true)
19
        self.dW2 = self.a1.T @ dL_dz2
20
        self.db2 = np.sum(dL_dz2, axis=0, keepdims=True)
21
        dL_da1 = dL_dz2 @ self.W2.T
22
        dL_dz1 = dL_da1 * relu_grad(self.z1)
23
        self.dW1 = self.X.T @ dL_dz1
24
        self.db1 = np.sum(dL_dz1, axis=0, keepdims=True)
25

26
    def step(self):
27
        self.W2 -= self.lr * self.dW2
28
        self.b2 -= self.lr * self.db2
29
        self.W1 -= self.lr * self.dW1
30
        self.b1 -= self.lr * self.db1
31

32
    # ========== 推理 ==========
33
    def predict(self, X):
34
        """推理（预测类别）"""
35
        y_pred = self.forward(X)
36
        return np.argmax(y_pred, axis=1)
37

38
    # ========== 保存 ==========
39
    def save(self, path="mnist_model.npz"):
40
        """保存模型参数"""
41
        np.savez(
42
            path,
43
            W1=self.W1, b1=self.b1,
44
            W2=self.W2, b2=self.b2
45
        )
46
        print(f"Model saved to {path}")
47

48
    # ========== 加载 ==========
49
    def load(self, path="mnist_model.npz"):
50
        """加载模型参数"""
51
        data = np.load(path)
52
        self.W1 = data["W1"]
53
        self.b1 = data["b1"]
54
        self.W2 = data["W2"]
55
        self.b2 = data["b2"]
56
        print(f"Model loaded from {path}")