>- **🍨 本文为[🔗365天深度学习训练营]中的学习记录博客**
>- **🍖 原作者：[K同学啊]**
- 难度：夯实基础⭐⭐
- 语言：Python3、TensorFlow2
🍺 要求：
- 了解
model.train_on_batch()并运用 - 了解tqdm，并使用tqdm实现可视化进度条
🍻 拔高（可选）：
- 本文代码中存在一个严重的BUG，请找出它并配以文字说明
🔎 探索（难度有点大）
- 修改代码，处理BUG
本次项目放弃了以往的model.fit()训练方法，改用model.train_on_batch方法。两种方法的比较：
model.fit()：用起来十分简单，对新手非常友好
model.train_on_batch()：封装程度更低，可以玩更多花样。
此外，引入了进度条的显示方式，更加方便我们及时查看模型训练过程中的情况，可以及时打印各项指标。
🚀我的环境：
- 语言环境：Python3.11.7
- 编译器：jupyter notebook
- 深度学习框架：TensorFlow2.13.0
一、前期工作
1. 设置GPU
如果使用的是CPU可以注释掉这部分的代码。
import tensorflow as tf
gpus=tf.config.list_physical_devices("GPU")
if gpus:
tf.config.experimental.set_memory_growth(gpus[0],True)
tf.config.set_visible_devices([gpus[0]],"GPU")
#打印显卡信息，确认GPU可用
print(gpus)2. 导入数据
import warnings
warnings.filterwarnings('ignore')
import pathlib
data_dir="D:\THE MNIST DATABASE\T8"
data_dir=pathlib.Path(data_dir)
image_count=len(list(data_dir.glob('*/*')))
print("图片总数为：",image_count)运行结果：
图片总数为： 3400二、数据预处理
1. 加载数据
使用image_dataset_from_directory方法将磁盘中的数据加载到tf.data.Dataset中
加载训练集：
train_ds=tf.keras.preprocessing.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="training",
seed=12,image_size=(224,224),
batch_size=8
)运行结果：
Found 3400 files belonging to 2 classes.
Using 2720 files for training.加载验证集：
val_ds=tf.keras.preprocessing.image_dataset_from_directory(
data_dir,
validation_split=0.2,
subset="validation",
seed=12,
image_size=(224,224),
batch_size=8
)运行结果：
Found 3400 files belonging to 2 classes.
Using 680 files for validation.通过class_names输出数据集的标签。标签将按字母顺序对应于目录名称。
class_names=train_ds.class_names
print(class_names)运行结果：
['cat', 'dog']2. 再次检查数据
for image_batch,labels_batch in train_ds:
print(image_batch.shape)
print(labels_batch.shape)
break运行结果：
(8, 224, 224, 3)
(8,)Image_batch是形状的张量（8, 224, 224, 3)。这是一批形状224x224x3的8张图片（最后一维指的是彩色通道RGB）。
Label_batch是形状（8，）的张量，这些标签对应8张图片
3. 配置数据集
- shuffle() ： 打乱数据，关于此函数的详细介绍可以参考：https://zhuanlan.zhihu.com/p/42417456
- prefetch() ：预取数据，加速运行，其详细介绍可以参考我前两篇文章，里面都有讲解。
- cache() ：将数据集缓存到内存当中，加速运行
AUTOTUNE=tf.data.AUTOTUNE
def preprocess_image(image,label):
return (image/255.0,label)
#归一化处理
train_ds=train_ds.map(preprocess_image,num_parallel_calls=AUTOTUNE)
val_ds=val_ds.map(preprocess_image,num_parallel_calls=AUTOTUNE)
train_ds=train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
val_ds=val_ds.cache().prefetch(buffer_size=AUTOTUNE)如果报 AttributeError: module 'tensorflow._api.v2.data' has no attribute 'AUTOTUNE' 错误，就将 AUTOTUNE = tf.data.AUTOTUNE 更换为 AUTOTUNE = tf.data.experimental.AUTOTUNE，这个错误是由于版本问题引起的。
4. 可视化数据
import matplotlib.pyplot as plt
plt.figure(figsize=(15,10))
for images,labels in train_ds.take(1):
for i in range(8):
ax=plt.subplot(5,8,i+1)
plt.imshow(images[i])
plt.title(class_names[labels[i]])
plt.axis("off")运行结果：
三、构建VG-16网络
VGG优缺点分析：
- VGG优点
VGG的结构非常简洁，整个网络都使用了同样大小的卷积核尺寸（3x3）和最大池化尺寸（2x2）。
- VGG缺点
1)训练时间过长，调参难度大。2)需要的存储容量大，不利于部署。例如存储VGG-16权重值文件的大小为500多MB，不利于安装到嵌入式系统中
结构说明：
●13个卷积层（Convolutional Layer），分别用blockX_convX表示
●3个全连接层（Fully connected Layer），分别用fcX与predictions表示
●5个池化层（Pool layer），分别用blockX_pool表示
VGG-16包含了16个隐藏层（13个卷积层和3个全连接层），故称为VGG-16
from tensorflow.keras import layers,models,Input
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Conv2D,MaxPooling2D,Dense,Flatten,Dropout
def vgg16(nb_classes,input_shape):
input_tensor=Input(shape=input_shape)
#1st block
x=Conv2D(64,(3,3),activation='relu',padding='same')(input_tensor)
x=Conv2D(64,(3,3),activation='relu',padding='same')(x)
x=MaxPooling2D((2,2),strides=(2,2))(x)
#2nd block
x=Conv2D(128,(3,3),activation='relu',padding='same')(x)
x=Conv2D(128,(3,3),activation='relu',padding='same')(x)
x=MaxPooling2D((2,2),strides=(2,2))(x)
#3rd block
x=Conv2D(256,(3,3),activation='relu',padding='same')(x)
x=Conv2D(256,(3,3),activation='relu',padding='same')(x)
x=Conv2D(256,(3,3),activation='relu',padding='same')(x)
x=MaxPooling2D((2,2),strides=(2,2))(x)
#4th block
x=Conv2D(512,(3,3),activation='relu',padding='same')(x)
x=Conv2D(512,(3,3),activation='relu',padding='same')(x)
x=Conv2D(512,(3,3),activation='relu',padding='same')(x)
x=MaxPooling2D((2,2),strides=(2,2))(x)
#5th block
x=Conv2D(512,(3,3),activation='relu',padding='same')(x)
x=Conv2D(512,(3,3),activation='relu',padding='same')(x)
x=Conv2D(512,(3,3),activation='relu',padding='same')(x)
x=MaxPooling2D((2,2),strides=(2,2))(x)
#full connection
x=Flatten()(x)
x=Dense(1024,activation='relu')(x)
x=Dense(108,activation='relu')(x)
output_tensor=Dense(nb_classes,activation='softmax')(x)
model=Model(input_tensor,output_tensor)
return model
model=vgg16(1000,(224,224,3))
model.summary()在此，我直接采用轻量化方式，减少了全连接层的参数数量，使模型大小由500MB减少到150MB。
Model: "model_1"
_________________________________________________________________
Layer (type) Output Shape Param #
=================================================================
input_2 (InputLayer) [(None, 224, 224, 3)] 0
conv2d_13 (Conv2D) (None, 224, 224, 64) 1792
conv2d_14 (Conv2D) (None, 224, 224, 64) 36928
max_pooling2d_5 (MaxPoolin (None, 112, 112, 64) 0
g2D)
conv2d_15 (Conv2D) (None, 112, 112, 128) 73856
conv2d_16 (Conv2D) (None, 112, 112, 128) 147584
max_pooling2d_6 (MaxPoolin (None, 56, 56, 128) 0
g2D)
conv2d_17 (Conv2D) (None, 56, 56, 256) 295168
conv2d_18 (Conv2D) (None, 56, 56, 256) 590080
conv2d_19 (Conv2D) (None, 56, 56, 256) 590080
max_pooling2d_7 (MaxPoolin (None, 28, 28, 256) 0
g2D)
conv2d_20 (Conv2D) (None, 28, 28, 512) 1180160
conv2d_21 (Conv2D) (None, 28, 28, 512) 2359808
conv2d_22 (Conv2D) (None, 28, 28, 512) 2359808
max_pooling2d_8 (MaxPoolin (None, 14, 14, 512) 0
g2D)
conv2d_23 (Conv2D) (None, 14, 14, 512) 2359808
conv2d_24 (Conv2D) (None, 14, 14, 512) 2359808
conv2d_25 (Conv2D) (None, 14, 14, 512) 2359808
max_pooling2d_9 (MaxPoolin (None, 7, 7, 512) 0
g2D)
flatten_1 (Flatten) (None, 25088) 0
dense_3 (Dense) (None, 1024) 25691136
dense_4 (Dense) (None, 108) 110700
dense_5 (Dense) (None, 1000) 109000
=================================================================
Total params: 40625524 (154.97 MB)
Trainable params: 40625524 (154.97 MB)
Non-trainable params: 0 (0.00 Byte)
_________________________________________________________________四、编译
在准备对模型进行训练之前，还需要再对其进行一些设置。以下内容是在模型的编译步骤中添加的：
- 损失函数（loss）：用于衡量模型在训练期间的准确率。
- 优化器（optimizer）：决定模型如何根据其看到的数据和自身的损失函数进行更新。
- 评价函数（metrics）：用于监控训练和测试步骤。以下示例使用了准确率，即被正确分类的图像的比率。
model.compile(optimizer="adam",
loss='sparse_categorical_crossentropy',
metrics=['accuracy']
)五、训练模型
tqdm的原型是通过包裹可迭代对象来显示进度条，提供实时的进度更新和定制化的展示信息。
参数：
- 基本参数
- iterable：必须提供的参数，指定要迭代的对象。
- desc：进度条的描述文字，默认为None，用于在进度条前显示自定义的前缀。
- total：总的迭代次数，用于计算进度百分比，默认为None。
- 输出控制参数
- leave：控制进度条完成后是否保留，默认为True。
- file：指定输出进度条信息的文件对象，默认为sys.stderr。
- ncols：进度条的总宽度，即显示的字符数，默认为None，自动调整宽度。
- 进度条外观参数
- bar_format：自定义进度条的格式，默认为 "{desc}: {percentage:3.0f}%|{bar}| {n_fmt}/{total_fmt}"。
- unit：进度条的单位名称，默认为"it"。
- unit_scale：控制是否自动缩放单位，取值为True或False，默认为False。
- 动态调整参数
- dynamic_ncols：控制是否动态调整进度条宽度以适应终端大小，默认为False。
- smoothing：控制平滑进度条的更新，取值范围0到1，默认为0.3。
- 更新频率控制参数
- mininterval：最小更新间隔时间（秒），默认为0.1。
- maxinterval：最大更新间隔时间（秒），默认为10。
- miniters：最小更新次数，用于控制进度条的更新频率，默认为1。
- 其他选项参数
- ascii：控制是否使用ASCII字符显示进度条，默认为False。
- disable：控制是否禁用进度条，默认为False。
示例：
import time
from tqdm import tqdm
def action():
time.sleep(0.5)
with tqdm(total=5000, desc='test', leave=True, ncols=100, unit='B', unit_scale=True) as pbar:
for i in range(10):
# sleep 0.5秒
action()
# 更新sleep进度
pbar.update(500)运行结果：
test: 100%|██████████████████████████████████████████████████████| 5.00k/5.00k [00:05<00:00, 984B/s]这段代码使用了tqdm库来显示一个进度条。首先导入了time和tqdm库，然后定义了一个名为action的函数，该函数会暂停0.5秒。接下来，使用with语句创建一个tqdm对象，设置了总进度为5000，描述为'test'，进度条宽度为100个字符，单位为'B'，并且启用了单位缩放。在循环中，每次调用action()函数后，使用pbar.update(500)更新进度条。最后，进度条显示了100%完成，总共用时5秒，速度为998字节/秒。
train_on_batch函数的原型是
train_on_batch(x, y=None,sample_weight=None,class_weight=None,
reset_metrics=True,return_dict=False)
参数：
- 输入数据
- x：这是必须提供的参数，指代模型的输入数据。如果模型只有一个输入，那么x可以是一个numpy数组；如果模型有多个输入，那么x应该是一个numpy数组的列表。当模型的输入被命名时，x还可以是一个字典，将输入名称映射到对应的numpy数组。
- 目标数据
- y：这是可选参数，用于指定模型的目标（标签）数据。对于单输出模型，y是一个numpy数组；对于多输出模型，y是numpy数组的列表。与x类似，如果模型的输出层被命名，y也可以是一个字典，将输出层的名称映射到对应的numpy数组。
- 样本权重
- sample_weight：这是可选参数，用于指定mini-batch中每个样本的权重。该参数接受一个形状为(batch_size)的数组，这些权重会被应用于每个样本的模型损失。在处理时间序列数据的情况下，可以传递一个形状为(samples, sequence_length)的二维数组，以对每个样本的每个时间步应用不同的权重。此时需要在编译模型时指定
sample_weight_mode="temporal"。- 类别权重
- class_weight：这是可选参数，用于在损失函数中为不同类别指定不同的权重，特别适用于处理类别不平衡的情况。该参数接受一个字典，将类索引（整数）映射到权重（浮点数），从而在训练期间对来自代表性不足类的样本进行重点关注。
- 重置指标
- reset_metrics：这是可选参数，默认值为True。当设置为True时，返回的度量值仅针对当前的mini-batch。如果设置为False，度量值会在各个批次之间累积。这在需要监控跨批次的度量值时非常有用。
- 返回字典
- return_dict：这是可选参数，默认为False。当设置为False时，
train_on_batch返回一个标量或标量列表，具体取决于模型的输出数量和度量数量。如果设置为True，则train_on_batch返回一个字典，其中包含loss和所有度量的名称及其相应的值。这个参数在需要以结构化方式处理多个输出结果时非常有用。
对于keras中的fit()和train_on_batch()的比较可以参考：
Keras中的fit、fit_generator、train_on_batch的用法介绍
开始模型训练：
from tqdm import tqdm
import tensorflow.keras.backend as K
epochs=10
lr=1e-4
#记录训练数据，方便后面的分析
history_train_loss=[]
history_train_accuracy=[]
history_val_loss=[]
history_val_accuracy=[]
for epoch in range(epochs):
train_total=len(train_ds)
val_total=len(val_ds)
"""
total：预期迭代数目
ncols：控制进度条宽度
mininterval：进度更新最小间隔，以秒为单位（默认值：0.1）
"""
with tqdm(total=train_total,desc=f'Epoch {epoch+1}/{epochs}',mininterval=1,ncols=100) as pbar:
lr=lr*0.92
K.set_value(model.optimizer.lr,lr)
for image,label in train_ds:
"""
训练模型，简单理解train_on_batch就是：它是比model.fit()%更高级的一个用法
"""
history=model.train_on_batch(image,label)
train_loss=history[0]
train_accuracy=history[1]
pbar.set_postfix({"loss":"%.4f"%train_loss,
"accuracy":"%.4f"%train_accuracy,
"lr":K.get_value(model.optimizer.lr)})
pbar.update(1)
history_train_loss.append(train_loss)
history_train_accuracy.append(train_accuracy)
print('开始验证！')
with tqdm(total=val_total,desc=f'Epoch {epoch+1}/{epochs}',mininterval=0.3,ncols=100) as pbar:
for image,label in val_ds:
history=model.test_on_batch(image,label)
val_loss=history[0]
val_accuracy=history[1]
pbar.set_postfix({"loss":"%.4f"%val_loss,
"accuracy":"%.4f"%val_accuracy})
pbar.update(1)
history_val_loss.append(val_loss)
history_val_accuracy.append(val_accuracy)
print('结束验证！')
print("验证loss为：%.4f"%val_loss)
print("验证准确率为：%.4f"%val_accuracy)运行结果：
Epoch 1/10: 100%|████████| 340/340 [17:54<00:00, 3.16s/it, loss=0.3833, accuracy=0.8750, lr=9.2e-5]
开始验证！
Epoch 1/10: 100%|█████████████████████| 85/85 [00:49<00:00, 1.72it/s, loss=0.0737, accuracy=1.0000]
结束验证！
验证loss为：0.0737
验证准确率为：1.0000
Epoch 2/10: 100%|███████| 340/340 [17:50<00:00, 3.15s/it, loss=0.1127, accuracy=1.0000, lr=8.46e-5]
开始验证！
Epoch 2/10: 100%|█████████████████████| 85/85 [00:49<00:00, 1.71it/s, loss=0.1149, accuracy=1.0000]
结束验证！
验证loss为：0.1149
验证准确率为：1.0000
Epoch 3/10: 100%|███████| 340/340 [18:05<00:00, 3.19s/it, loss=0.1163, accuracy=0.8750, lr=7.79e-5]
开始验证！
Epoch 3/10: 100%|█████████████████████| 85/85 [00:53<00:00, 1.58it/s, loss=0.2065, accuracy=0.8750]
结束验证！
验证loss为：0.2065
验证准确率为：0.8750
Epoch 4/10: 100%|███████| 340/340 [19:12<00:00, 3.39s/it, loss=0.0564, accuracy=1.0000, lr=7.16e-5]
开始验证！
Epoch 4/10: 100%|█████████████████████| 85/85 [00:49<00:00, 1.70it/s, loss=0.0003, accuracy=1.0000]
结束验证！
验证loss为：0.0003
验证准确率为：1.0000
Epoch 5/10: 100%|███████| 340/340 [18:26<00:00, 3.26s/it, loss=0.3317, accuracy=0.8750, lr=6.59e-5]
开始验证！
Epoch 5/10: 100%|█████████████████████| 85/85 [00:49<00:00, 1.72it/s, loss=0.0819, accuracy=1.0000]
结束验证！
验证loss为：0.0819
验证准确率为：1.0000
Epoch 6/10: 100%|███████| 340/340 [18:46<00:00, 3.31s/it, loss=0.0013, accuracy=1.0000, lr=6.06e-5]
开始验证！
Epoch 6/10: 100%|█████████████████████| 85/85 [00:50<00:00, 1.69it/s, loss=0.0273, accuracy=1.0000]
结束验证！
验证loss为：0.0273
验证准确率为：1.0000
Epoch 7/10: 100%|███████| 340/340 [18:44<00:00, 3.31s/it, loss=0.6714, accuracy=0.8750, lr=5.58e-5]
开始验证！
Epoch 7/10: 100%|█████████████████████| 85/85 [00:50<00:00, 1.68it/s, loss=0.0260, accuracy=1.0000]
结束验证！
验证loss为：0.0260
验证准确率为：1.0000
Epoch 8/10: 100%|███████| 340/340 [18:30<00:00, 3.27s/it, loss=0.0013, accuracy=1.0000, lr=5.13e-5]
开始验证！
Epoch 8/10: 100%|█████████████████████| 85/85 [00:56<00:00, 1.51it/s, loss=0.1152, accuracy=0.8750]
结束验证！
验证loss为：0.1152
验证准确率为：0.8750
Epoch 9/10: 100%|███████| 340/340 [18:34<00:00, 3.28s/it, loss=0.0113, accuracy=1.0000, lr=4.72e-5]
开始验证！
Epoch 9/10: 100%|█████████████████████| 85/85 [00:48<00:00, 1.77it/s, loss=0.0047, accuracy=1.0000]
结束验证！
验证loss为：0.0047
验证准确率为：1.0000
Epoch 10/10: 100%|██████| 340/340 [18:10<00:00, 3.21s/it, loss=0.0000, accuracy=1.0000, lr=4.34e-5]
开始验证！
Epoch 10/10: 100%|████████████████████| 85/85 [00:48<00:00, 1.77it/s, loss=0.0035, accuracy=1.0000]
结束验证！
验证loss为：0.0035
验证准确率为：1.0000六、模型评估
epochs_range = range(epochs)
plt.figure(figsize=(14, 4))
plt.subplot(1, 2, 1)
plt.plot(epochs_range, history_train_accuracy, label='Training Accuracy')
plt.plot(epochs_range, history_val_accuracy, label='Validation Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')
plt.subplot(1, 2, 2)
plt.plot(epochs_range, history_train_loss, label='Training Loss')
plt.plot(epochs_range, history_val_loss, label='Validation Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()运行结果：
七、预测
import numpy as np
#采用加载的模型来看预测结果
plt.figure(figsize=(18,3)) #图形的宽为18高为3
plt.rcParams['font.sans-serif']=['SimHei'] #用来正常显示中文标签
plt.rcParams['axes.unicode_minus']=False #用来正常显示负号
for images,labels in val_ds.take(1):
for i in range(8):
ax=plt.subplot(1,8,i+1)
#显示图片
plt.imshow(images[i].numpy())
#需要给图片增加一个维度
img_array=tf.expand_dims(images[i],0)
#使用模型预测图片中的人物
predictions=model.predict(img_array)
plt.title(class_names[np.argmax(predictions)])
plt.axis("off")运行结果：
八、心得体会
本次项目使用了train_on_batch()函数，使用过程中学习了其包含的各种参数及其使用方法。但模型结果并不理想，产生的问题留待下一周进行解决。
378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
