t1手写数字识别

• 🍨 本文为🔗365天深度学习训练营 中的学习记录博客
• 🍖 原作者：K同学啊 | 接辅导、项目定制

前言

虽然现在pytorch占主流但是tensorflow也有许多优秀的源码值得借鉴，故打算学习一下tensorflow。打卡t1实现手写数字识别。

1设置GPU

import tensorflow as tf

gpus = tf.config.list_physical_devices("GPU")

if gpus:
    gpu0 = gpus[0]  # 如果有多个GPU，仅使用第0个GPU
    tf.config.experimental.set_memory_growth(gpu0, True)  # 设置GPU显存用量按需使用
    tf.config.set_visible_devices([gpu0], "GPU")

    print("GPU设备设置成功。")
else:
    print("没有找到可用的GPU设备。")

2 导入数据

import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt

# 导入mnist数据，依次分别为训练集图片、训练集标签、测试集图片、测试集标签
(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data()

3数据预处理

# 将像素的值标准化至0到1的区间内。(对于灰度图片来说，每个像素最大值是255，每个像素最小值是0，也就是直接除以255就可以完成归一化。)
train_images, test_images = train_images / 255.0, test_images / 255.0
# 查看数据维数信息
train_images.shape,test_images.shape,train_labels.shape,test_labels.shape

4查看数据

# 将数据集前20个图片数据可视化显示
# 进行图像大小为20宽、10长的绘图(单位为英寸inch)
plt.figure(figsize=(20,10))
# 遍历MNIST数据集下标数值0~49
for i in range(20):
    # 将整个figure分成5行10列，绘制第i+1个子图。
    plt.subplot(2,10,i+1)
    # 设置不显示x轴刻度
    plt.xticks([])
    # 设置不显示y轴刻度
    plt.yticks([])
    # 设置不显示子图网格线
    plt.grid(False)
    # 图像展示，cmap为颜色图谱，"plt.cm.binary"为matplotlib.cm中的色表
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    # 设置x轴标签显示为图片对应的数字
    plt.xlabel(train_labels[i])
# 显示图片
plt.show()

5格式调整

#调整数据到我们需要的格式
train_images = train_images.reshape((60000, 28, 28, 1))
test_images = test_images.reshape((10000, 28, 28, 1))

train_images.shape,test_images.shape,train_labels.shape,test_labels.shape

注意：这里数据的形状被调整为 (height, width, channels) 的格式，其中 channels 表示图像的通道数。这样的数据格式适用于 TensorFlow，特别是使用 Keras 这样的高层 API。

在 PyTorch 中，数据的格式通常是 (batch_size, channels, height, width)，其中 batch_size 表示每个批次的样本数量，channels 表示图像的通道数，height 和 width 表示图像的高度和宽度。这是因为 PyTorch 中的卷积层默认接受这种格式的输入。

6搭建网络结构

# 创建并设置卷积神经网络
# 卷积层：通过卷积操作对输入图像进行降维和特征抽取
# 池化层：是一种非线性形式的下采样。主要用于特征降维，压缩数据和参数的数量，减小过拟合，同时提高模型的鲁棒性。
# 全连接层：在经过几个卷积和池化层之后，神经网络中的高级推理通过全连接层来完成。
model = models.Sequential([
    # 设置二维卷积层1，设置32个3*3卷积核，activation参数将激活函数设置为ReLu函数，input_shape参数将图层的输入形状设置为(28, 28, 1)
    # ReLu函数作为激活励函数可以增强判定函数和整个神经网络的非线性特性，而本身并不会改变卷积层
    # 相比其它函数来说，ReLU函数更受青睐，这是因为它可以将神经网络的训练速度提升数倍，而并不会对模型的泛化准确度造成显著影响。
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    #池化层1，2*2采样
    layers.MaxPooling2D((2, 2)),                   
    # 设置二维卷积层2，设置64个3*3卷积核，activation参数将激活函数设置为ReLu函数
    layers.Conv2D(64, (3, 3), activation='relu'),  
    #池化层2，2*2采样
    layers.MaxPooling2D((2, 2)),                   
    
    layers.Flatten(),                    #Flatten层，连接卷积层与全连接层
    layers.Dense(64, activation='relu'), #全连接层，特征进一步提取，64为输出空间的维数，activation参数将激活函数设置为ReLu函数
    layers.Dense(10)                     #输出层，输出预期结果，10为输出空间的维数
])
# 打印网络结构
model.summary()

卷积层1：

32 个 3x3 的卷积核。
激活函数使用 ReLU。
输入形状是 (28, 28, 1)，表示图像的高度为 28，宽度为 28，通道数为 1。
池化层1：

2x2 的最大池化。
卷积层2：

64 个 3x3 的卷积核。
激活函数使用 ReLU。
池化层2：

2x2 的最大池化。
Flatten 层：

将卷积层和池化层输出的多维数据拉平为一维，以便连接到全连接层。
全连接层1：

64 个神经元。
激活函数使用 ReLU。
全连接层2（输出层）：

10 个神经元，对应于数据集中的 10 个类别（0 到 9）。
没有激活函数，因为这是一个多类别分类问题，输出将通过 softmax 函数进行归一化。
与pytorch比较=

import torch
import torch.nn as nn
import torch.nn.functional as F

class SimpleCNN(nn.Module):
    def __init__(self):
        super(SimpleCNN, self).__init__()
        # 卷积层1
        self.conv1 = nn.Conv2d(1, 32, kernel_size=3, stride=1, padding=1)
        # 池化层1
        self.pool1 = nn.MaxPool2d(kernel_size=2, stride=2)
        # 卷积层2
        self.conv2 = nn.Conv2d(32, 64, kernel_size=3, stride=1, padding=1)
        # 池化层2
        self.pool2 = nn.MaxPool2d(kernel_size=2, stride=2)
        # 全连接层1
        self.fc1 = nn.Linear(64 * 7 * 7, 64)
        # 全连接层2（输出层）
        self.fc2 = nn.Linear(64, 10)

    def forward(self, x):
        x = F.relu(self.conv1(x))
        x = self.pool1(x)
        x = F.relu(self.conv2(x))
        x = self.pool2(x)
        x = x.view(-1, 64 * 7 * 7)  # 将特征图展平
        x = F.relu(self.fc1(x))
        x = self.fc2(x)
        return x

# 创建模型实例
model = SimpleCNN()

# 打印网络结构
print(model)

7设置相关参数

"""
这里设置优化器、损失函数以及metrics
这三者具体介绍可参考我的博客：
https://blog.csdn.net/qq_38251616/category_10258234.html
"""
# model.compile()方法用于在配置训练方法时，告知训练时用的优化器、损失函数和准确率评测标准
model.compile(
	# 设置优化器为Adam优化器
    optimizer='adam',
	# 设置损失函数为交叉熵损失函数（tf.keras.losses.SparseCategoricalCrossentropy()）
    # from_logits为True时，会将y_pred转化为概率（用softmax），否则不进行转换，通常情况下用True结果更稳定
    loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
    # 设置性能指标列表，将在模型训练时监控列表中的指标
    metrics=['accuracy'])

model.compile 是 Keras 中用于配置模型训练的方法。它接受三个重要的参数：optimizer（优化器）、loss（损失函数）、metrics（性能指标）。下面是详细介绍这些参数的信息：

model.compile(
    optimizer,
    loss,
    metrics=None,
    loss_weights=None,
    weighted_metrics=None,
    run_eagerly=None,
    steps_per_execution=None,
    **kwargs
)

optimizer：

类型： 字符串标识、tf.keras.optimizers.Optimizer 实例。
说明： 优化器用于指定模型的训练过程中使用的优化算法。常见的优化器包括 ‘sgd’（随机梯度下降）、‘adam’（Adam 优化器）、‘rmsprop’（RMSprop 优化器）等。也可以使用 Keras 中的优化器类的实例，如 tf.keras.optimizers.SGD()。
loss：

类型： 字符串标识、tf.keras.losses.Loss 实例。
说明： 损失函数用于衡量模型输出与实际标签之间的差异。对于分类问题，常用的损失函数包括 ‘categorical_crossentropy’（多类别交叉熵）、‘sparse_categorical_crossentropy’（稀疏多类别交叉熵）等。也可以使用 Keras 中的损失函数类的实例，如 tf.keras.losses.CategoricalCrossentropy()。
metrics：

类型： 列表，元素可以是字符串标识、tf.keras.metrics.Metric 实例。
说明： 用于在训练过程中监测的性能指标。常见的性能指标包括 ‘accuracy’（准确率）、‘precision’（精确度）、‘recall’（召回率）等。也可以使用 Keras 中的性能指标类的实例，如 tf.keras.metrics.Accuracy()。
loss_weights：

类型： 字典，用于给不同的损失函数分配不同的权重。
说明： 适用于多输出模型，可以为每个损失函数指定一个权重，以调整其在总体损失中的影响。
weighted_metrics：

类型： 列表，与 metrics 参数类似，但允许为每个指标分配权重。
run_eagerly：

类型： 布尔值，默认为 None。
说明： 如果为 True，则在执行模型的每一步时都会执行 eager 模式。适用于调试和开发。
steps_per_execution：

类型： 整数，默认为 None。
说明： 一次执行的步数。如果设置为整数，将按批次执行模型的多个步骤。可以用于加速训练。
kwargs：

类型： 其他可选参数。
说明： 允许传递其他参数，具体取决于底层的后端实现。

8模型训练

history = model.fit(
    # 输入训练集图片
	train_images,
	# 输入训练集标签
	train_labels,
	# 设置10个epoch，每一个epoch都将会把所有的数据输入模型完成一次训练。
	epochs=10,
	# 设置验证集
    validation_data=(test_images, test_labels))

model.fit 方法是 Keras 中用于训练模型的主要方法之一。它的主要作用是通过在训练数据上迭代，更新模型的权重，以最小化损失函数。以下是 model.fit 方法的主要参数：

model.fit(
    x=None,
    y=None,
    batch_size=None,
    epochs=1,
    verbose=1,
    callbacks=None,
    validation_split=0.0,
    validation_data=None,
    shuffle=True,
    class_weight=None,
    sample_weight=None,
    initial_epoch=0,
    steps_per_epoch=None,
    validation_steps=None,
    validation_batch_size=None,
    validation_freq=1,
    max_queue_size=10,
    workers=1,
    use_multiprocessing=False
)

x, y:

类型： 输入数据和目标数据。
说明： x 表示输入数据，可以是 NumPy 数组、Tensor，或者是一个包含多个输入的列表。y 表示目标数据（标签），可以是 NumPy 数组、Tensor，或者是一个包含多个目标数据的列表。
batch_size:

类型： 整数。
说明： 每个训练批次的样本数。默认为 32。该参数决定在模型参数更新之前模型一次性看多少个样本。
epochs:

类型： 整数。
说明： 训练的 epochs 数量。一个 epoch 表示将所有训练数据传递给模型一次。默认为 1。
verbose:

类型： 整数。
说明： 控制训练过程中打印信息的详细程度。0 表示不打印任何信息，1 表示打印进度条，2 表示打印每个 epoch 的摘要信息。
callbacks:

类型： 回调函数列表。
说明： 回调函数是在训练过程中的不同阶段调用的函数，可以用于实现例如模型检查点、提前停止、学习率调整等功能。
validation_split:

类型： 浮点数。
说明： 在训练数据中选择用于验证的一部分数据的比例。例如，validation_split=0.2 表示将 20% 的数据用于验证。
validation_data:

类型： 元组 (x_val, y_val)。
说明： 用于在每个 epoch 结束时评估模型性能的验证数据。这里是验证集的输入和目标数据。
shuffle:

类型： 布尔值。
说明： 是否在每个 epoch 之前随机打乱训练数据。默认为 True。
class_weight:

类型： 字典。
说明： 类别权重的可选字典，用于平衡不同类别的样本。
sample_weight:

类型： NumPy 数组。
说明： 为每个输入样本分配的权重数组。
initial_epoch:

类型： 整数。
说明： 开始训练的 epoch 索引。用于继续之前的训练。
steps_per_epoch:

类型： 整数。
说明： 一个 epoch 中的步数。默认为训练数据的样本数除以批次大小。
validation_steps:

类型： 整数。
说明： 在每个 epoch 结束时从验证集中抽取的步数。
validation_batch_size:

类型： 整数。
说明： 用于评估验证集的批次大小。
validation_freq:

类型： 整数或列表。
说明： 仅在指定的 epoch 数执行验证。例如，validation_freq=5 表示每 5 个 epoch 执行一次验证。
max_queue_size:

类型： 整数。
说明： 生成器

9训练结果

总结

通过这次简单的实验对tensorflow有了简单的了解，熟悉了其训练流程并且比较了与pytorch的差异。