03-0.2到0.3——构建你的第一个深度学习模型

import numpy as np
import os
import matplotlib.pyplot as plt

# 加载MNIST数据集（npz格式）
mnist_path = os.path.expanduser('~/.keras/datasets/mnist.npz')
data = np.load(mnist_path)

# 显示数据集包含的数组名称
print("MNIST 数据集包含以下数组:")
print(data.files)

# 提取训练集和测试集数据
x_train = data['x_train']  # 训练图像
y_train = data['y_train']  # 训练标签
x_test = data['x_test']    # 测试图像
y_test = data['y_test']    # 测试标签

# 显示数据形状和类型信息
print(f"\n训练图像: {x_train.shape}, 类型: {x_train.dtype}")
print(f"训练标签: {y_train.shape}, 类型: {y_train.dtype}")
print(f"测试图像: {x_test.shape}, 类型: {x_test.dtype}")
print(f"测试标签: {y_test.shape}, 类型: {y_test.dtype}")

# 显示10张示例图像并保存
plt.rcParams['font.family'] = 'SimSong'  # 设置中文字体
plt.figure(figsize=(10, 5))

for i in range(10):
    plt.subplot(2, 5, i + 1)
    plt.imshow(x_train[i], cmap='gray')
    plt.title(f"标签: {y_train[i]}")
    plt.axis('off')

plt.tight_layout()
plt.savefig('mnist_samples.png')  # 保存图像到文件
print("\n已保存10张示例图像到 mnist_samples.png")

# 将部分训练图像保存为单独的PNG文件
output_dir = 'mnist_extracted'
if not os.path.exists(output_dir):
    os.makedirs(output_dir)  # 创建输出目录（如果不存在）

# 保存前20张训练图像
for i in range(20):
    img_path = f"{output_dir}/train_{i}_label_{y_train[i]}.png"
    plt.imsave(img_path, x_train[i], cmap='gray')

print(f"\n已提取20张训练图像到 {output_dir} 目录")

from sklearn.model_selection import train_test_split  # 需要导入该模块

# 数据预处理：将像素值从0-255归一化到0-1之间，提升模型训练效率
train_images = x_train / 255.0  # 训练集归一化
test_images = x_test / 255.0    # 测试集归一化

# 从训练集中划分验证集（验证集占比20%）
# random_state=42 保证每次划分结果一致，便于实验复现
train_images, val_images, train_labels, val_labels = train_test_split(
    train_images, y_train, test_size=0.2, random_state=42
)

# 打印划分后的数据集形状，验证处理结果
print("\n数据预处理后形状：")
print(f"训练集图像: {train_images.shape}, 训练集标签: {train_labels.shape}")
print(f"验证集图像: {val_images.shape}, 验证集标签: {val_labels.shape}")
print(f"测试集图像: {test_images.shape}, 测试集标签: {y_test.shape}")

from tensorflow import keras  # 需导入keras模块

# 定义神经网络模型
model = keras.Sequential([
    # 输入层：指定输入图像形状为28x28（MNIST图像尺寸）
    keras.Input(shape=(28, 28)),
    # 展平层：将28x28的二维图像转换为784维的一维向量（28*28=784）
    keras.layers.Flatten(),
    # 第一个全连接隐藏层：128个神经元，使用ReLU激活函数（引入非线性非线性）
    keras.layers.Dense(128, activation='relu'),
    # 第二个全连接隐藏层：64个神经元，继续使用ReLU激活函数
    keras.layers.Dense(64, activation='relu'),
    # 输出层：10个神经元（对应0-9共10个类别），使用softmax激活函数（输出概率分布）
    keras.layers.Dense(10, activation='softmax')
])

# 编译模型
model.compile(
    optimizer='adam',  # 常用的自适应优化器
    loss='sparse_categorical_crossentropy',  # 适用于整数标签的多分类损失
    metrics=['accuracy']  # 训练中监控准确率
)

history = model.fit(
    x=train_images,          # 训练集图像数据
    y=train_labels,          # 训练集标签
    epochs=5,                # 训练轮次：整个训练集将被迭代5次
    batch_size=32,           # 批次大小：每次迭代使用32个样本更新一次参数
    validation_data=(val_images, val_labels)  # 验证集：用于监控训练过程中的泛化能力
)

# 评估模型
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'Test accuracy: {test_acc}')

# 进行预测
predictions = model.predict(test_images)

# 找出每个样本中概率最大的元素所在的索引，即预测的类别
predicted_labels = np.argmax(predictions, axis=1)

# 打印前10个样本的预测结果和真实标签
for i in range(10):
    print(f"样本 {i}：预测标签 = {predicted_labels[i]}, 真实标签 = {test_labels[i]}")

import matplotlib.pyplot as plt

def plot_image(i, predictions_array, true_label, img):
    predictions_array, true_label, img = predictions_array, true_label[i], img[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])
    
    plt.imshow(img, cmap=plt.cm.binary)
    
    predicted_label = np.argmax(predictions_array)
    if predicted_label == true_label:
        color = 'blue'
    else:
        color = 'red'
    
    plt.xlabel(f"{predicted_label} {100*np.max(predictions_array):2.0f}% ({true_label})",
               color=color)

def plot_value_array(i, predictions_array, true_label):
    predictions_array, true_label = predictions_array, true_label[i]
    plt.grid(False)
    plt.xticks(range(10))
    plt.yticks([])
    thisplot = plt.bar(range(10), predictions_array, color="#777777")
    plt.ylim([0, 1])
    predicted_label = np.argmax(predictions_array)
    
    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')

# 显示前15个测试图像的预测结果
num_rows = 5
num_cols = 3
num_images = num_rows * num_cols
plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))
for i in range(num_images):
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)
    plot_image(i, predictions[i], test_labels, test_images)
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)
    plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split

# 加载MNIST手写数字数据集
mnist = keras.datasets.mnist
(train_images, train_labels), (test_images, test_labels) = mnist.load_data()

# 数据预处理：将像素值归一化到0-1之间，提升训练效率
train_images = train_images / 255.0
test_images = test_images / 255.0

# 从训练集中划分验证集（验证集占比20%）
train_images, val_images, train_labels, val_labels = train_test_split(
    train_images, train_labels, test_size=0.2, random_state=42
)

# 定义模型
model = keras.Sequential([
    # 输入层：指定输入图像形状为28x28
    keras.Input(shape=(28, 28)),
    # 展平层：将28x28的二维图像转换为一维向量
    keras.layers.Flatten(),
    # 第一个隐藏层：128个神经元，使用ReLU激活函数
    keras.layers.Dense(128, activation='relu'),
    # 第二个隐藏层：64个神经元，使用ReLU激活函数
    keras.layers.Dense(64, activation='relu'),
    # 输出层：10个神经元（对应0-9类别），使用softmax激活函数
    keras.layers.Dense(10, activation='softmax')
])

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

# 训练模型
model.fit(
    train_images, train_labels,
    epochs=5, batch_size=32,
    validation_data=(val_images, val_labels)
)

# 评估模型
test_loss, test_acc = model.evaluate(test_images, test_labels)
print(f'Test accuracy: {test_acc}')

# 进行预测
predictions = model.predict(test_images)

# 提取预测类别（概率最大的索引）
predicted_labels = np.argmax(predictions, axis=1)

# 打印前10个样本的预测结果与真实标签
for i in range(10):
    print(f"样本 {i}：预测标签 = {predicted_labels[i]}, 真实标签 = {test_labels[i]}")

# 定义可视化函数
def plot_image(i, predictions_array, true_label, img):
    predictions_array, true_label, img = predictions_array, true_label[i], img[i]
    plt.grid(False)
    plt.xticks([])
    plt.yticks([])
    plt.imshow(img, cmap=plt.cm.binary)
    
    predicted_label = np.argmax(predictions_array)
    color = 'blue' if predicted_label == true_label else 'red'
    
    plt.xlabel(
        f"{predicted_label} {100*np.max(predictions_array):2.0f}% ({true_label})",
        color=color
    )

def plot_value_array(i, predictions_array, true_label):
    predictions_array, true_label = predictions_array, true_label[i]
    plt.grid(False)
    plt.xticks(range(10))
    plt.yticks([])
    thisplot = plt.bar(range(10), predictions_array, color="#777777")
    plt.ylim([0, 1])
    
    predicted_label = np.argmax(predictions_array)
    thisplot[predicted_label].set_color('red')
    thisplot[true_label].set_color('blue')

# 显示前15个测试图像的预测结果
num_rows = 5
num_cols = 3
num_images = num_rows * num_cols

plt.figure(figsize=(2 * 2 * num_cols, 2 * num_rows))
for i in range(num_images):
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 1)
    plot_image(i, predictions[i], test_labels, test_images)
    plt.subplot(num_rows, 2 * num_cols, 2 * i + 2)
    plot_value_array(i, predictions[i], test_labels)

plt.tight_layout()
plt.show()

# 定义CNN（卷积神经网络）模型
model = keras.Sequential([
    # 输入层：指定输入为28x28的单通道图像（需明确通道维度1，适配卷积层输入要求）
    keras.Input(shape=(28, 28, 1)),
    
    # 第一个卷积层：32个3x3卷积核，ReLU激活，提取基础图像特征
    keras.layers.Conv2D(32, kernel_size=(3, 3), activation='relu'),
    # 第一个最大池化层：2x2池化窗口，降低特征图尺寸，保留关键特征
    keras.layers.MaxPooling2D(pool_size=(2, 2)),
    
    # 第二个卷积层：64个3x3卷积核，ReLU激活，提取更复杂的特征
    keras.layers.Conv2D(64, kernel_size=(3, 3), activation='relu'),
    # 第二个最大池化层：2x2池化窗口，进一步压缩特征图
    keras.layers.MaxPooling2D(pool_size=(2, 2)),
    
    # 展平层：将卷积层输出的二维特征图转换为一维向量，适配全连接层
    keras.layers.Flatten(),
    
    # 全连接层：128个神经元，ReLU激活，整合展平后的特征
    keras.layers.Dense(128, activation='relu'),
    
    # 输出层：10个神经元（对应0-9类别），softmax激活，输出类别概率分布
    keras.layers.Dense(10, activation='softmax')
])

# （可选）打印模型结构摘要，查看各层输出形状和参数数量
model.summary()