3.神经网络

from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.models import Sequential

'''
这是一个最经典的"全连接前馈神经网络"入门示例： 把图像压扁 → 提取 128 维特征 → 输出 10 类概率 ，是入门深度学习的"Hello World"

加载MNIST数据集，将数据集分为训练集和测试集

MNIST 数据集来自美国国家标准与技术研究所。训练集 (training set) 由来自 250 个不同人手写的数字构成,
其中 50% 是高中学生, 50% 来自人口普查局 (the Census Bureau) 的工作人员. 测试集(test set) 也是同样比例的手写数字数据.
MNIST 数据集中所有图像都是统一的 28×28 像素灰度图。
训练集：x 是图像数据60000个28×28的灰度图数组，y 是标签数据（在数据集中就是0-9的整数，对应10个数字）。
测试集：中包括10000个样本，每个样本是一个28×28的灰度图，标签是一个0-9的整数。

x_train  →  图片（输入特征 / Feature）
y_train  →  数字标签（目标值 / Label / Target）

y就是答案，所以本案例为监督学习。
'''
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 数据预处理：将像素值归一化到 [0, 1] 范围
# - 作用 ：将像素值从 [0, 255] 范围转换为 [0, 1] 范围，方便模型训练。
# - 原因 ：每个8bit的灰度图，每个像素值是 0~255 的整数。而神经网络层通常期望输入在 [0, 1] 范围内。
# - 优点 ：加速收敛，提高模型训练效率。
x_train = x_train / 255.0
x_test = x_test / 255.0
'''
要归一化的原因
### 1. 加速训练收敛
神经网络使用梯度下降优化。如果输入值在 0~255 范围，梯度也会很大，导致：
- 学习率难调（容易爆炸或震荡）
- 收敛很慢
把数据压缩到 [0,1] 后，梯度幅度更稳定，模型更容易学习。

### 2. 避免数值不稳定
大输入值 × 权重后会得到非常大的中间结果，再经过激活函数（如 softmax、sigmoid）容易产生 数值溢出 或 梯度消失 。

### 3. 提高模型精度
归一化后，不同特征处于同一量纲，模型不会"偏袒"数值大的特征。

### 4. 配合权重初始化
现代权重初始化方法（如 He、Xavier）默认假设输入数据在 0 附近、方差较小。归一化后才能让这些初始化发挥最佳效果。

其他归一化方式
1. Min-Max。 公式：(x - min) / (max - min)     使用场景：像素、固定范围数据 
2. Z-Score 标准化。公式: (x - μ) / σ            使用场景：数据分布近似正态 
3. 均值归一化。公式: (x - mean) / 255            使用场景：让数据中心在 0 附近
像 CIFAR-10、ImageNet 等数据集，常用 Z-Score 方式按 RGB 三通道分别减均值除标准差。
'''

# 构建前馈神经网络模型
# 使用Sequential模型来顺序堆叠网络层，Sequential 表示"顺序模型"，按列表顺序把各层依次堆叠起来，数据从上到下逐层传递。
# Flatten层将输入的图像展平为一维向量，Dense层用于实现全连接层，最后一层使用softmax激活函数进行分类
model = Sequential([
    # Flatten层将28x28像素的图像展平成一维数组，以便可以作为全连接（Dense）层的输入。
    # - 作用 ：把 28×28 的二维图像矩阵"压扁"成一维向量，长度 = 28 × 28 = 784 。
    # - 原因 ：Dense（全连接）层只接受一维输入，而 MNIST 图像是二维像素矩阵。
    # - input_shape=(28,28) ：声明输入数据形状，仅首层需要写。
    Flatten(input_shape=(28, 28)),

    # 第一个Dense层有128个神经元，每个神经元都与上层 784 个输入全连接。
    # - 参数量 = 784 × 128 + 128（偏置）= 100,480 个可训练参数。
    # 并使用ReLU激活函数 ： f(x) = max(0, x)。ReLU函数将任何负值置为0，保留正值不变，有助于解决梯度消失问题。
    # - 优点：计算简单、缓解梯度消失、加速收敛，是隐藏层的常用选择。
    Dense(128, activation='relu'),

    # 第二个Dense层是输出层，有10个神经元（对应0-9的数字）。
    # 并使用softmax激活函数。softmax函数将输出转换为概率分布，使得所有输出值的和为1。
    # 例如输出 [0.01, 0.02, 0.9, 0.01, ...] ，表示模型预测该图像是数字 "2" 的概率为 90%。
    Dense(10, activation='softmax')
])
'''
思考：为什么是128个神经元？128 这个数字没有严格的理论公式，是经验值，但背后有"够用又不浪费"的考量。

# 从参数量倒推（容量控制）:每个神经元要和上一层 784 个输入全连接，所以：
参数量=784×128+128（偏置）=100,480个可训练参数

而训练样本有 60000 张 ，参数/样本比 ≈ 1.67。这个比例处于"刚好够学、不容易过拟合"的甜区：
- 神经元太少（如 8）→ 参数量 ~6280， 欠拟合 ，学不动 784 维特征的组合
- 神经元太多（如 1024）→ 参数量 ~80 万， 过拟合 ，死记硬背训练集
- 128 → 10 万参数 ，对 6 万样本来说容量适中

# 工程惯例
- 2 的幂次（64/128/256/512）方便 GPU 并行计算（GPU 按块处理，2 的幂对齐效率高）
- 128 是 Keras 官方 MNIST 教程的默认值，被无数教程沿用

# 实际情况如何选择？
实战中通常 先试一个中间值，再根据效果调整 ：
# 经验调参流程
Dense(64)   → 准确率 97%  → 容量可能不够，加大
Dense(128)  → 准确率 98%  → 合适，定下来
Dense(256)  → 准确率 98.1% 但训练慢一倍 → 收益递减，回到 128


# 神经元怎么工作的?
128 个神经元 是同一层内的 128 个"并行计算单元"。 

单个神经元的工作就是 加权求和 + 激活 ：
        x1 ─┐ w1
        x2 ─┤ w2        ┌──→ Σ(w·x + b) ──→ ReLU ──→ 输出 a
        ... ┤ ...
       x784 ┘ w784
       
数学公式：
z = w1·x1 + w2·x2 + ... + w784·x784 + b
a = ReLU(z) = max(0, z)    
每个神经元有自己独立的一组权重 w 和偏置 b 。也就是每个神经元都有自己的"学习能力"，可以学习到不同的特征。
每个神经元都是需要计算全部的60000个训练样本的。

# 128 个神经元如何并行工作？
它们 共享同一份输入 （784 维向量），但各自有独立的权重，各自算各自的，也就是128个并发执行：
                    ┌── 神经元1: w1·x + b1 → ReLU → a1 ────────┐
                    ├── 神经元2: w2·x + b2 → ReLU → a2 ────────┤
输入 x (784维) ──────┤  ...                                    ├──→ 输出 a (128维)
                    └── 神经元128: w128·x + b128 → ReLU → a128 ┘

128 个神经元 同时 接收 同一个 784 维输入，每个神经元计算自己的 z 值，然后通过 ReLU 激活函数得到 a 值。
经过隐藏层128个神经元计算获得一个 128维(128长度的一维数组)向量传向下一层。

# 矩阵计算
实际代码里不会写 128 次循环，而是用 一次矩阵乘法 完成全部计算：
W = 形状 [784, 128] 的权重矩阵   # 每一列是一个神经元的权重
b = 形状 [128] 的偏置向量

z = x @ W + b        # [1, 784] @ [784, 128] + [128] = [1, 128]  ← 128 个神经元一次算完
a = relu(z)          # 逐元素 ReLU
这就是为什么 GPU 跑神经网络特别快—— 矩阵乘法天然并行 ，128 个神经元的计算可以同时进行。

# 完整向前传播流程
输入图像 (28×28=784 维)
    │
    │  W1: [784, 128],  b1: [128]
    ↓
矩阵乘法: x @ W1 + b1  →  z1 (128 维)     ← 128 个神经元并行加权求和
    │
    ↓
ReLU(z1)               →  a1 (128 维)     ← 逐元素激活，负数变 0
    │
    │  W2: [128, 10],  b2: [10]
    ↓
矩阵乘法: a1 @ W2 + b2  →  z2 (10 维)     ← 10 个输出神经元并行计算
    │
    ↓
softmax(z2)             →  概率分布 (10 维) ← 转成概率，和为 1
    │
    ↓
输出: [0.01, 0.02, 0.90, ...]  → 预测为数字 "2"
'''

print(model.summary())
print("编译模型开始")
'''
编译模型：作用是配置模型如何训练
1. optimizer（优化器-学习方法）：指定优化器为adam，它是一种基于梯度下降的优化算法，具有自适应学习率，收敛快、效果稳。
    常见的优化器还有：sgd（随机梯度下降）、rmsprop、adamax、adagrad等。
2. loss（损失函数-用于评估模型训练效果）：损失函数为sparse_categorical_crossentropy，适用于多分类问题，其中标签是整数。
    常见的损失函数还有：binary_crossentropy（二分类，标签是0和1）、 categorical_crossentropy（多分类，标签是one-hot向量，标签是0和1的数组）。
    sparse_categorical_crossentropy（多分类，标签是整数，因为数据集中的标签是0-9的整数，所以使用sparse_categorical_crossentropy损失函数）。
3. metrics（评估指标-用于评估效果的指标是什）：评估指标为accuracy，即正确分类的样本数占总样本数的比例。
    常见的指标非常多。根据不同的使用场景，使用不同的指标。例如：分类任务、回归任务、概率 / 排序任务等。
整个compile的意思就是
x_train[0]   # 一张 28×28 的图像矩阵，画的是数字 "5"
             # [[0, 0, 0, ..., 0],
             #  [0, 0, 12, ..., 0],
             #  ...
             #  [0, 0, 0, ..., 0]]

y_train[0]   # 5   ← 告诉模型"上面那张图画的是 5"
'''
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
print("编译模型完成")

# 训练模型
print("训练模型开始")
model.fit(x_train, y_train, epochs=10)
print("训练模型完成")
'''
epochs=10 都做了什么？
  Epoch 1/10  →  模型第一次看完所有 60000 张图
  Epoch 2/10  →  模型第二次看完所有 60000 张图（在第一次基础上继续学）
  ...
  Epoch 10/10 →  模型第十次看完所有 60000 张图   

每个 epoch 内部，模型会按照下面的流程，不断的重复训练。

训练时的流程：
x_train  →  模型  →  预测值 ŷ
                       ↓
                     比较 ŷ 和 y_train
                       ↓
                     计算 loss → 反向传播 → 更新模型

执行结果
Epoch 1/10
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 3s 1ms/step - accuracy: 0.9283 - loss: 0.2519
Epoch 2/10
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9674 - loss: 0.1110
Epoch 3/10
....
Epoch 9/10
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9943 - loss: 0.0182
Epoch 10/10
1875/1875 ━━━━━━━━━━━━━━━━━━━━ 2s 1ms/step - accuracy: 0.9949 - loss: 0.0159

1. 1875/1875：默认 batch_size=32 ，60000 ÷ 32 = 1875 个批次 
2. step：每处理一个 batch 算一步 
3. loss： 训练集上的损失值， 越小越好 ，逐轮下降 
4. accuracy： 训练集上的准确率， 越大越好 ，逐轮上升
可以看出从第一轮的 0.9283 到第十轮的 0.9949 ，准确率不断提高，说明模型在训练集上的表现越来越好。

为什么训练10轮，而不是1轮或者100轮：
1. 太少（如 1） 模型还没学够，准确率低（欠拟合）
2. 太多（如 100） 训练集准确率可能 100%，但测试集反而下降（ 过拟合 ），防止死记硬背，不会举一反三。
'''

# 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test loss: {test_loss}, Test accuracy: {test_acc}")
'''
参数：x_test 和 y_test 测试集数据都是模型没有见过的。
响应：
- test_loss ← 测试集上的 损失值 （交叉熵，越小越好）
- test_acc ← 测试集上的 准确率 （越大越好）

313/313 ━━━━━━━━━━━━━━━━━━━━ 0s 810us/step - accuracy: 0.9786 - loss: 0.0885
Test loss: 0.08845454454421997, Test accuracy: 0.978600025177002
'''

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten

# 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 数据预处理
x_train = x_train / 255.0
x_test = x_test / 255.0

# 构建前馈神经网络模型
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

# 编译模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
model.fit(x_train, y_train, epochs=5)

# 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc}")

import numpy as np
import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import SimpleRNN, Dense

# 生成简单的序列数据
data = np.array([[0.1, 0.2], [0.3, 0.4], [0.5, 0.6], [0.7, 0.8]])
target = np.array([[0.9], [1.0], [1.1], [1.2]])

# 调整数据形状以适应RNN输入 [样本数, 时间步长, 特征数]
data = np.expand_dims(data, axis=1)

# 构建RNN模型
model = Sequential([
    SimpleRNN(16, input_shape=(1, 2)),
    Dense(1)
])

# 编译模型
model.compile(optimizer='adam', loss='mse')

# 训练模型
model.fit(data, target, epochs=100, verbose=1)

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 数据预处理
x_train = x_train.reshape(-1, 28, 28, 1).astype('float32') / 255.0
x_test = x_test.reshape(-1, 28, 28, 1).astype('float32') / 255.0

# 构建CNN模型
model = Sequential([
    Conv2D(10, kernel_size=(5, 5), activation='relu', input_shape=(28, 28, 1)),
    MaxPooling2D(pool_size=(2, 2)),
    Conv2D(20, kernel_size=(5, 5), activation='relu'),
    MaxPooling2D(pool_size=(2, 2)),
    Flatten(),
    Dense(50, activation='relu'),
    Dense(10, activation='softmax')
])

# 编译模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

# 训练模型
model.fit(x_train, y_train, epochs=5)

# 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc}")

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Dense, Flatten, Reshape
from tensorflow.keras.models import Sequential
import numpy as np

# 加载MNIST数据集
(x_train, _), (_, _) = mnist.load_data()

# 数据预处理
x_train = x_train.reshape(-1, 784).astype('float32') / 255.0

# 定义生成器
generator = Sequential([
    Dense(256, input_dim=100, activation='relu'),
    Dense(784, activation='sigmoid'),
    Reshape((28, 28))
])

# 定义判别器
discriminator = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(1, activation='sigmoid')
])

# 编译判别器
discriminator.compile(optimizer='adam', loss='binary_crossentropy')

# 组合生成器和判别器
discriminator.trainable = False
gan_input = keras.Input(shape=(100,))
x = generator(gan_input)
gan_output = discriminator(x)
gan = keras.Model(gan_input, gan_output)
gan.compile(optimizer='adam', loss='binary_crossentropy')

# 训练GAN
batch_size = 64
epochs = 5
for epoch in range(epochs):
    for _ in range(len(x_train) // batch_size):
        # 训练判别器
        noise = np.random.normal(0, 1, size=[batch_size, 100])
        generated_images = generator.predict(noise)
        real_images = x_train[np.random.randint(0, x_train.shape[0], size=batch_size)]
        x = np.concatenate([real_images, generated_images])
        y_dis = np.zeros(2 * batch_size)
        y_dis[:batch_size] = 1
        discriminator.trainable = True
        discriminator.train_on_batch(x, y_dis)

        # 训练生成器
        noise = np.random.normal(0, 1, size=[batch_size, 100])
        y_gen = np.ones(batch_size)
        discriminator.trainable = False
        gan.train_on_batch(noise, y_gen)

    print(f'Epoch {epoch + 1} completed')

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense

# 1. 加载MNIST数据集
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 2. 数据预处理
# 调整数据形状以适应CNN输入 [样本数, 高度, 宽度, 通道数]
x_train = x_train.reshape(-1, 28, 28, 1).astype('float32')
x_test = x_test.reshape(-1, 28, 28, 1).astype('float32')

# 归一化处理，将像素值缩放到0 - 1之间
x_train /= 255
x_test /= 255

# 3. 构建CNN模型
model = Sequential([
    # 第一个卷积层，使用32个3x3的卷积核，激活函数为ReLU
    Conv2D(32, kernel_size=(3, 3), activation='relu', input_shape=(28, 28, 1)),
    # 最大池化层，池化窗口大小为2x2
    MaxPooling2D(pool_size=(2, 2)),
    # 第二个卷积层，使用64个3x3的卷积核，激活函数为ReLU
    Conv2D(64, kernel_size=(3, 3), activation='relu'),
    # 最大池化层，池化窗口大小为2x2
    MaxPooling2D(pool_size=(2, 2)),
    # 将多维的特征图展平为一维向量
    Flatten(),
    # 全连接层，包含128个神经元，激活函数为ReLU
    Dense(128, activation='relu'),
    # 输出层，包含10个神经元，对应0 - 9的10个数字类别，激活函数为softmax
    Dense(10, activation='softmax')
])

# 4. 编译模型
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

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

# 6. 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f"Test accuracy: {test_acc}")

import numpy as np

# 输入数据。5x5 的二维数组。这里模拟的数字1
data = np.array([
    [0, 1, 1, 0, 0],
    [0, 1, 1, 0, 0],
    [0, 1, 1, 0, 0],
    [0, 0, 0, 0, 0],
    [0, 0, 0, 0, 0]
])

# 3x3 卷积核
kernel = np.array([
    [1, 0, 1],
    [0, 1, 0],
    [1, 0, 1]
])

k_raw = kernel.shape[0]
k_col = kernel.shape[1]
print("Kernel size:", k_col, k_raw)


# 卷积计算操作
def convolve(input, kernel):
    # 输出的结果
    output = np.zeros(kernel.shape)
    # 第一层卷积计算
    for i in range(len(output)):
        for j in range(len(output[0])):
            output[i][j] = (input[i:i + k_raw, j:j + k_col] * kernel).sum()
    return output


res1 = convolve(data, kernel)
print("第一层:卷积后的特征图:", res1)


# 激活层（ReLU）
def relu(x):
    return np.maximum(0, x)


res1_relu = relu(res1)
print("ReLU激活后的特征图:", res1_relu)


# 池化层（最大池化）
def max_pooling(input_data, pool_size=2, step=2):
    output = np.zeros((pool_size, pool_size))
    for i in range(pool_size):
        for j in range(pool_size):
            patch = input_data[i * step:i * step + pool_size, j * step:j * step + pool_size]
            output[i, j] = np.max(patch)
    return output


res_1_maxpool = max_pooling(res1_relu)
print("最大池化后的特征图:", res_1_maxpool)

# 展平操作【二维转一维】
res_1_flatten = res_1_maxpool.flatten()
print("展平后的特征向量:", res_1_flatten)

# 全连接层权重矩阵
weights = np.array([
    [0.1, 0.2, 0.3, 0.4],
    [0.5, 0.6, 0.7, 0.8],
    [0.9, 1.0, 1.1, 1.2]
])


# 全连接层计算
def fully_connected(input_data, weights):
    return np.dot(weights, input_data)


# 全连接层输出
res_1_dense = fully_connected(res_1_flatten, weights)
print("全连接层输出向量:", res_1_dense)

# 走这个输出的函数为数字1通过卷积神经网络计算后的特性，如果后续使用另一个数字1的图片，可以直接使用训练后的res_1_dense作为模型进行对比。

# 编译模型
# 指定优化器为adam，它是一种基于梯度下降的优化算法，具有自适应学习率。
# 损失函数为sparse_categorical_crossentropy，适用于多分类问题，其中标签是整数。
# 评估指标为accuracy，即正确分类的样本数占总样本数的比例。
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

import os
import numpy as np
from tensorflow.keras.datasets import mnist
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.models import Sequential, load_model

'''
本案例演示如何"保存训练好的模型"和"加载模型并使用"。

为什么要保存模型？
- 训练一个模型可能要几分钟甚至几天，训练完如果不保存，程序结束就全丢了。
- 保存后，下次可以直接加载模型进行预测，无需重新训练。
- 模型可以部署到服务器、手机、边缘设备上对外提供服务。

模型的保存与加载是深度学习工程化的基础：
  训练模型 → 保存模型（.keras 文件） → 加载模型 → 使用模型预测

本案例基于 cp01_1_feed.py 的前馈神经网络，核心流程：
  1. 加载数据 → 训练模型 → 保存模型
  2. 加载模型 → 预测单张图片 → 评估测试集
'''

# ============================================================
# 第一部分：加载数据（与 cp01_1_feed.py 相同）
# ============================================================
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# 数据预处理：将像素值归一化到 [0, 1] 范围
x_train = x_train / 255.0
x_test = x_test / 255.0


# ============================================================
# 第二部分：构建并训练模型（与 cp01_1_feed.py 相同，这里 epochs=3 加快演示速度）
# ============================================================

# 构建前馈神经网络模型
# - Flatten：把 28×28 图像压扁成 784 维一维向量
# - Dense(128, relu)：隐藏层，128 个神经元，ReLU 激活
# - Dense(10, softmax)：输出层，10 个神经元，softmax 转概率分布
model = Sequential([
    Flatten(input_shape=(28, 28)),
    Dense(128, activation='relu'),
    Dense(10, activation='softmax')
])

# 编译模型：配置优化器、损失函数、评估指标
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])

print("训练模型开始（epochs=3，仅为演示，实际可用 10）")
model.fit(x_train, y_train, epochs=3)
print("训练模型完成")


# ============================================================
# 第三部分：保存模型到本地
# ============================================================

# 模型保存路径
# - .keras 是 Keras 3 推荐的统一格式（旧版有 .h5 格式和 SavedModel 目录格式）
# - .keras 文件是一个 zip 压缩包，内部包含：模型结构、权重、优化器状态、编译配置
# - 一个文件就能完整恢复模型，无需重新构建和训练
model_path = os.path.join(os.path.dirname(__file__), 'mnist_model.keras')

print(f"\n保存模型到: {model_path}")
model.save(model_path)
print("模型保存完成")
# 说明：model.save() 保存的内容
# - 模型结构（各层的类型、参数、连接方式）
# - 模型权重（所有可训练参数 W 和 b 的数值）
# - 编译配置（optimizer、loss、metrics）
# - 优化器状态（Adam 的动量等，可用于继续训练）


# ============================================================
# 第四部分：加载模型并使用
# ============================================================

print("\n" + "=" * 50)
print("加载保存的模型")
print("=" * 50)

# 加载模型
# - load_model() 会从 .keras 文件中恢复完整的模型（结构 + 权重 + 编译配置）
# - 加载后的模型可以直接用于预测，也可以继续训练
# - 注意：加载前不需要重新 build/compile 模型，load_model 全部搞定
loaded_model = load_model(model_path)
print("模型加载完成")
print(loaded_model.summary())

'''
model.save() 的几种格式对比：

1. .keras（推荐）
   model.save('model.keras')
   - Keras 3 默认格式，zip 压缩，单文件
   - 保存最完整：结构 + 权重 + 优化器状态

2. .h5（旧版格式）
   model.save('model.h5')
   - Keras 2 时代的格式，单文件
   - 兼容性好，但官方不再推荐

3. SavedModel（目录格式）
   model.save('model_folder/')     # 末尾带斜杠或目录名
   - TensorFlow 原生格式，是一个文件夹
   - 适合 TensorFlow Serving / TFLite 部署
'''
# ============================================================
# 第五部分：使用加载的模型进行预测
# ============================================================

print("\n" + "=" * 50)
print("使用加载的模型进行预测")
print("=" * 50)

# 取测试集中的前 5 张图片进行预测
# - x_test[:5]：形状 (5, 28, 28)，5 张 28×28 的图片
test_images = x_test[:5]
test_labels = y_test[:5]

# model.predict() 对输入数据进行预测
# - 输入：图片数据，形状 (5, 28, 28)
# - 输出：概率分布，形状 (5, 10)，每行是该图片属于 0-9 各数字的概率
# - 注意：predict 的输入要做和训练时 相同的预处理（这里已归一化）
predictions = loaded_model.predict(test_images)

print("\n预测结果：")
for i in range(5):
    # np.argmax() 返回概率最大的那个类别的索引，即模型预测的数字
    predicted_label = np.argmax(predictions[i])
    true_label = test_labels[i]
    # predictions[i][predicted_label] 是预测概率的最大值
    confidence = predictions[i][predicted_label]

    status = "[OK]" if predicted_label == true_label else "[X]"
    print(f"  图片 {i}: 预测={predicted_label}, 真实={true_label}, "
          f"置信度={confidence:.2%} {status}")


# ============================================================
# 第六部分：评估加载的模型
# ============================================================

print("\n" + "=" * 50)
print("评估加载的模型（在整个测试集上）")
print("=" * 50)

# evaluate() 在测试集上计算 loss 和 accuracy
# - 与训练时相同，返回 [loss, accuracy]
# - 加载的模型评估结果应该和保存前 完全一致（因为是同一个模型）
test_loss, test_acc = loaded_model.evaluate(x_test, y_test)
print(f"Test loss: {test_loss:.4f}")
print(f"Test accuracy: {test_acc:.4f}")


# ============================================================
# 第七部分：清理（可选）—— 删除保存的模型文件
# ============================================================
# 如果想保留模型文件供下次使用，注释掉下面这段即可
# import os
# if os.path.exists(model_path):
#     os.remove(model_path)
#     print(f"\n已删除模型文件: {model_path}")

'''
总结：模型保存与加载的完整工作流

  训练阶段                          使用阶段
  ┌─────────────┐                ┌─────────────┐
  │  加载数据    │                │  加载模型    │
  │  预处理      │                │ load_model() │
  │  构建模型    │                └──────┬──────┘
  │  编译模型    │                       │
  │  训练模型    │                       ↓
  │  fit()      │                ┌─────────────┐
  └──────┬──────┘                │  预处理新数据 │
         │                       │  (必须一致)  │
         ↓                       └──────┬──────┘
  ┌─────────────┐                       │
  │ 保存模型     │                       ↓
  │ model.save()│                ┌─────────────┐
  │ → .keras    │                │  模型预测    │
  └─────────────┘                │ predict()   │
                                 └─────────────┘

关键注意点：
1. 预处理必须一致 ：加载模型预测时，输入数据的归一化方式必须和训练时完全相同。
2. 保存格式推荐 .keras ：单文件、完整保存、Keras 3 默认。
3. 加载后可直接用 ：无需重新 build/compile，load_model 一步到位。
4. 可继续训练 ：加载的模型可以用 model.fit() 继续训练（优化器状态也保存了）。
'''