>- **🍨 本文为[🔗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()函数,使用过程中学习了其包含的各种参数及其使用方法。但模型结果并不理想,产生的问题留待下一周进行解决。