各位同学好，今天和大家分享一下如何使用 Tensorflow 构建 ResNeXt 神经网络模型，通过案例实战 ResNeXt 的训练以及预测过程。每个小节的末尾有网络、训练、预测的完整代码。想要数据集的私聊我就行。

ResNeXt 是 ResNet 的改进版，在 bottleneck卷积块结构上进行了较小的改动，其他都和 ResNet 模块相近，如下图所示，ResNeXt 比 ResNet 的精度更好。

本节只介绍 ResNeXt 的改进部分，想了解 ResNet 网络的，可以看我的这篇文章：https://blog.csdn.net/dgvv4/article/details/122396424

1. ResNeXt 模型结构

1.1 分组卷积

（1）在标准卷积中，输入有多少个通道，卷积核就有多少个通道。

举个例子：若输入的图像shape为5x5x6，一个卷积核的shape为3x3x6，使用3个卷积核，得到的特征图shape为3x3x3。参数量 = 5x5x6x3 = 450

（2）在分组卷积中，每个卷积核只处理部分通道。如下图，红色的卷积核只处理输入图像中红色的两个通道，绿色的卷积核只处理输入图像中间的两个绿色的通道，第三个卷积核只处理黄色的两个通道。此时，每个卷积核有两个通道，每个卷积核生成一个特征图。

举个例子：若输入的图像shape为5x5x6，一个分组卷积核的shape为3x3x2，使用3个分组卷积核，得到的特征图shape为3x3x3。参数量 = 5x5x(6/3)x(3/3)x3 = 5x5x2x1x3 = 150 。可见，分成三组，参数量为原来的三分之一。

因此，分组卷积能够有效地降低参数量和计算量。

代码实现：

#（1）分组卷积块
def group_conv(inputs, filters, stride, num_groups):'''inputs为输入特征图filters为每个分组卷积的输出通道数stride为分组卷积的步长num_groups为分几组'''# 用来保存每个分组卷积的输出特征图groupList = []for i in range(num_groups):  # 遍历每一组# 均匀取出需要卷积的特征图inputs.shape=[b,h,w,c]x = inputs[:, :, :, i*filters: (i+1)*filters]# 分别对每一组卷积使用3*3卷积x = layers.Conv2D(filters, kernel_size=3, strides=stride, padding='same', use_bias=False)(x)# 将每个分组卷积结果保存起来groupList.append(x)# 将每个分组卷积的输出特征图在通道维度上堆叠x = layers.Concatenate()(groupList)x = layers.BatchNormalization()(x)  # 批标准化x = layers.Activation('relu')(x)  # 激活函数return x

1.2 残差结构单元

论文中的残差单元结构图如下，它们在数学计算上完全等价。

如图c，首先经过1x1卷积下降通道数 [h,w,256]==>[h,w,128]；然后经过3x3分组卷积提取特征；再经过1x1卷积上升通道数 [h,w,128]==>[h,w,256]；最后，如果输入和输出的shape相同，通过残差连接输入和输出。

如图b，可以理解为，第一层的32个1x1卷积相当于图c的第一个1x1卷积；第二三层的将分组卷积的结果在通道上堆叠，就是图c的3x3分组卷积

代码实现

#（2）一个残差单元
def res_block(inputs, out_channel, stride, shortcut, num_groups=32):'''inputs输入特征图out_channel最后一个1*1卷积的输出通道数stride=2下采样, 图像长宽减半, 残差边对输入卷积后再连接输出stride=1基本模块, size不变, 残差连接输入和输出num_groups代表3*3分组卷积分了几组shortcut判断是否要调整通道数'''# 残差边if shortcut is False:  # 直接使用参加连接输入和输出residual = inputselif shortcut is True:  # 调整通道数# 1*1卷积调整通道数，使输入输出的size和通道数相同residual = layers.Conv2D(out_channel, kernel_size=1, strides=stride, padding='same', use_bias=False)(inputs)# 有BN层就不需要偏置residual = layers.BatchNormalization()(residual)# 1*1卷积，输出通道数是最后一个1*1卷积层输出通道数的一半x = layers.Conv2D(filters = out_channel//2, kernel_size=1, strides=1,padding = 'same', use_bias = False)(inputs)x = layers.BatchNormalization()(x)x = layers.Activation('relu')(x)# 3*3分组卷积group_filters = (out_channel//2) // num_groups  # 每一组卷积的输出通道数x = group_conv(x, filters = group_filters, stride = stride, num_groups = num_groups)# 1*1卷积上升通道x = layers.Conv2D(filters = out_channel, kernel_size = 1, strides = 1,padding = 'same', use_bias = False)(x)x = layers.BatchNormalization()(x)# 残差连接，保证x和残差边的shape相同x = layers.Add()([x, residual])x = layers.Activation('relu')(x)return x

1.3 网络结构

下图是 ResNet 和 ResNeXt 网络结构对比图，接下来就一层一层堆叠网络就可以了

完整代码展示：

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import layers, Model#（1）分组卷积块
def group_conv(inputs, filters, stride, num_groups):'''inputs为输入特征图filters为每个分组卷积的输出通道数stride为分组卷积的步长num_groups为分几组'''# 用来保存每个分组卷积的输出特征图groupList = []for i in range(num_groups):  # 遍历每一组# 均匀取出需要卷积的特征图inputs.shape=[b,h,w,c]x = inputs[:, :, :, i*filters: (i+1)*filters]# 分别对每一组卷积使用3*3卷积x = layers.Conv2D(filters, kernel_size=3, strides=stride, padding='same', use_bias=False)(x)# 将每个分组卷积结果保存起来groupList.append(x)# 将每个分组卷积的输出特征图在通道维度上堆叠x = layers.Concatenate()(groupList)x = layers.BatchNormalization()(x)  # 批标准化x = layers.Activation('relu')(x)  # 激活函数return x#（2）一个残差单元
def res_block(inputs, out_channel, stride, shortcut, num_groups=32):'''inputs输入特征图out_channel最后一个1*1卷积的输出通道数stride=2下采样, 图像长宽减半, 残差边对输入卷积后再连接输出stride=1基本模块, size不变, 残差连接输入和输出num_groups代表3*3分组卷积分了几组shortcut判断是否要调整通道数'''# 残差边if shortcut is False:  # 直接使用参加连接输入和输出residual = inputselif shortcut is True:  # 调整通道数# 1*1卷积调整通道数，使输入输出的size和通道数相同residual = layers.Conv2D(out_channel, kernel_size=1, strides=stride, padding='same', use_bias=False)(inputs)# 有BN层就不需要偏置residual = layers.BatchNormalization()(residual)# 1*1卷积，输出通道数是最后一个1*1卷积层输出通道数的一半x = layers.Conv2D(filters = out_channel//2, kernel_size=1, strides=1,padding = 'same', use_bias = False)(inputs)x = layers.BatchNormalization()(x)x = layers.Activation('relu')(x)# 3*3分组卷积group_filters = (out_channel//2) // num_groups  # 每一组卷积的输出通道数x = group_conv(x, filters = group_filters, stride = stride, num_groups = num_groups)# 1*1卷积上升通道x = layers.Conv2D(filters = out_channel, kernel_size = 1, strides = 1,padding = 'same', use_bias = False)(x)x = layers.BatchNormalization()(x)# 残差连接，保证x和残差边的shape相同x = layers.Add()([x, residual])x = layers.Activation('relu')(x)return x#（3）一个残差块
def stage(x, num, out_channel, first_stride):# 第一个残差单元下采样步长可能是1也可能是2，第一个残差单元需要调整残差边通道数x = res_block(x, out_channel, stride=first_stride, shortcut=True)# 其他的都是基本模块strides=1for _ in range(num-1):x = res_block(x, out_channel, stride=1, shortcut=False)# 残差块输出结果return x#（4）网络骨架
def resnext(input_shape, classes):'''input_shape代表输入图像的shapeclasses代表分类类别的数量'''# 构造输入层inputs = keras.Input(shape=input_shape)# 7*7标准卷积[224,224,3]==>[112,112,64]x = layers.Conv2D(filters=64, kernel_size=7, strides=2,padding='same', use_bias=False)(inputs)x = layers.BatchNormalization()(x)x = layers.Activation('relu')(x)# 最大池化[112,112,64]==>[56,56,64]x = layers.MaxPooling2D(pool_size=(3,3), strides=2, padding='same')(x)# [56,56,64]==>[56,56,256]x = stage(x, num=3, out_channel=256, first_stride=1)# [56,56,256]==>[28,28,512]x = stage(x, num=4, out_channel=512, first_stride=2)# [28,28,512]==>[14,14,1024]x = stage(x, num=6, out_channel=1024, first_stride=2)# [14,14,1024]==>[7,7,2048]x = stage(x, num=3, out_channel=2048, first_stride=2)# [7,7,2048]==>[None,2048]x = layers.GlobalAveragePooling2D()(x)# [None,2048]==>[None,classes]logits = layers.Dense(classes)(x)  # 输出不经过softmax激活函数# 构建模型model = Model(inputs, logits)# 返回模型return model#（5）接收网络模型
if __name__ == '__main__':model = resnext(input_shape = [224,224,3],  # 输入图像shapeclasses = 1000)  # 分类数model.summary()  # 查看网络架构

通过model.summary()查看网络参数量

==================================================================================================
Total params: 25,097,128
Trainable params: 25,028,904
Non-trainable params: 68,224
__________________________________________________________________________________________________

2. 模型训练

我是用的GPU训练网络，先将各种包导入进来，并设置GPU内存占用，防止内存爆炸。

from tensorflow.keras.preprocessing.image import ImageDataGenerator  # 预处理
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow import keras
from ResNeXt import resnext  # 网络模型
import json
import osos.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'  # 调用GPU训练
os.environ['CUDA_VISIBLE_DEVICES'] = '0'  # 使用当前设备的第一块GPUgpus = tf.config.experimental.list_physical_devices("GPU")# 设置GPU内存占用，根据网络模型大小占用相应的内存
if gpus:try:for gpu in gpus:tf.config.experimental.set_memory_growth(gpu, True)except RuntimeError as e:print(e)exit(-1)

2.1 数据集加载

接下来，在文件夹中图片数据以测试集、验证集、测试集分类。

函数 tf.keras.preprocessing.image_dataset_from_directory() 构造数据集，

分批次读取图片数据，参数 img_size 会对读进来的图片resize成指定大小；参数 label_mode 中，'int'代表目标值y是数值类型索引，即0, 1, 2, 3等；'categorical'代表onehot类型，对应正确类别的索引的值为1，如图像属于第二类则表示为0,1,0,0,0；'binary'代表二分类。

#（1）加载数据集
def get_data(height, width, batchsz):# 训练集数据train_ds = keras.preprocessing.image_dataset_from_directory(directory = filepath + 'train',  # 训练集图片所在文件夹label_mode = 'categorical',  # onehot编码image_size = (height, width),  # 输入图象的sizebatch_size = batchsz)  # 每批次训练32张图片# 验证集数据val_ds = keras.preprocessing.image_dataset_from_directory(directory = filepath + 'val', label_mode = 'categorical', image_size = (height, width),  batch_size = batchsz)  # 返回划分好的数据集return train_ds, val_ds# 读取数据集
train_ds, val_ds = get_data(height, width, batchsz)

2.2 显示图像信息

接下来绘图查看图像信息，iter()生成迭代器，配合next()每次运行取出训练集中的一个batch数据。

def plot_show(train_ds):# 生成迭代器,每次取出一个batch的数据sample = next(iter(train_ds))  # sample[0]图像信息, sample[1]标签信息# 显示前5张图for i in range(5):plt.subplot(1,5,i+1)  # 在一块画板的子画板上绘制1行5列plt.imshow(sample[0][i]/255.0)  # 图像的像素值压缩到0-1plt.xticks([])  # 不显示xy坐标刻度plt.yticks([])plt.show()# 是否展示图像信息
if plotShow is True:plot_show(train_ds)

显示图像如下：

2.3 数据预处理

使用.map()函数转换数据集中所有x和y的类型，并将每张图象的像素值映射到[0,1]之间，打乱训练集数据的顺序.shuffle()

def processing(x,y):  # 定义预处理函数x = tf.cast(x, dtype=tf.float32) / 255.0  # 图片转换为tensor类型，并归一化y = tf.cast(y, dtype=tf.int32)  # 分类标签转换成tensor类型return x,y# 对所有数据预处理
train_ds = train_ds.map(processing).shuffle(10000)  # map调用自定义预处理函数, shuffle打乱数据集
val_ds = val_ds.map(processing)

2.4 网络训练

在网络编译.compile()，指定损失loss采用交叉熵损失。设置参数from_logits=True，由于网络的输出层没有使用softmax函数将输出的实数转为概率，参数设置为True时，会自动将logits的实数转为概率值，再和真实值计算损失，这里的真实值y是经过onehot编码之后的结果。

#（7）保存权重文件
if not os.path.exists(weights_dir):  # 判断当前文件夹下有没有一个叫save_weights的文件夹os.makedirs(weights_dir)  # 如果没有就创建一个#（8）模型编译
opt = optimizers.Adam(learning_rate=learning_rate)  # 设置Adam优化器model.compile(optimizer=opt, #学习率loss=keras.losses.CategoricalCrossentropy(from_logits=True), # 交叉熵损失，logits层先经过softmaxmetrics=['accuracy']) #评价指标#（9）定义回调函数，一个列表
# 保存模型参数
callbacks = [keras.callbacks.ModelCheckpoint(filepath = 'save_weights/resnext.h5',  # 参数保存的位置save_best_only = True,  # 保存最佳参数save_weights_only = True,  # 只保存权重文件monitor = 'val_loss')]  # 通过验证集损失判断是否是最佳参数#（10）模型训练，history保存训练信息
history = model.fit(x = train_ds,  # 训练集validation_data = val_ds,  # 验证集epochs = epochs,  #迭代30次callbacks = callbacks)

训练过程中的损失值和准确率如下：

Epoch 1/10
556/556 [==============================] - 247s 370ms/step - loss: 1.3545 - accuracy: 0.5662 - val_loss: 0.1252 - val_accuracy: 0.9664
Epoch 2/10
556/556 [==============================] - 175s 305ms/step - loss: 0.1186 - accuracy: 0.9622 - val_loss: 0.1337 - val_accuracy: 0.9724
Epoch 3/10
556/556 [==============================] - 176s 307ms/step - loss: 0.0499 - accuracy: 0.9859 - val_loss: 3.8282 - val_accuracy: 0.6735
Epoch 4/10
556/556 [==============================] - 176s 305ms/step - loss: 0.0697 - accuracy: 0.9816 - val_loss: 0.0783 - val_accuracy: 0.9796
Epoch 5/10
556/556 [==============================] - 176s 306ms/step - loss: 0.1167 - accuracy: 0.9661 - val_loss: 0.0843 - val_accuracy: 0.9844
Epoch 6/10
556/556 [==============================] - 177s 308ms/step - loss: 0.0703 - accuracy: 0.9841 - val_loss: 0.0096 - val_accuracy: 0.9964
Epoch 7/10
556/556 [==============================] - 176s 306ms/step - loss: 0.0267 - accuracy: 0.9920 - val_loss: 0.0295 - val_accuracy: 0.9940
Epoch 8/10
556/556 [==============================] - 176s 306ms/step - loss: 0.0339 - accuracy: 0.9925 - val_loss: 0.0870 - val_accuracy: 0.9712
Epoch 9/10
556/556 [==============================] - 174s 302ms/step - loss: 0.0622 - accuracy: 0.9851 - val_loss: 0.0588 - val_accuracy: 0.9904
Epoch 10/10
556/556 [==============================] - 176s 306ms/step - loss: 0.0384 - accuracy: 0.9889 - val_loss: 3.3135 - val_accuracy: 0.6591

2.5 绘制训练曲线

history 中保存了本轮训练的信息，由于没有使用预训练权重，模型的训练损失和准确率波动比较大，但准确率还是可以的。并且训练时设置了回调函数callbacks，只保存验证集损失最小时的权重参数。

#（11）获取训练信息
history_dict = history.history  # 获取训练的数据字典
train_loss = history_dict['loss']  # 训练集损失
train_accuracy = history_dict['accuracy']  # 训练集准确率
val_loss = history_dict['val_loss']  # 验证集损失
val_accuracy = history_dict['val_accuracy']  # 验证集准确率#（12）绘制训练损失和验证损失
plt.figure()
plt.plot(range(epochs), train_loss, label='train_loss')  # 训练集损失
plt.plot(range(epochs), val_loss, label='val_loss')  # 验证集损失
plt.legend()  # 显示标签
plt.xlabel('epochs')
plt.ylabel('loss')#（13）绘制训练集和验证集准确率
plt.figure()
plt.plot(range(epochs), train_accuracy, label='train_accuracy')  # 训练集准确率
plt.plot(range(epochs), val_accuracy, label='val_accuracy')  # 验证集准确率
plt.legend()
plt.xlabel('epochs')
plt.ylabel('accuracy')

绘制损失曲线和准确率曲线

2.6 训练过程完整代码

训练阶段一定要注意 batch_size 的大小，batch_size 设置的越大，越容易导致显存爆炸，要改的话最好设置2的n次方

import tensorflow as tf
from tensorflow import keras
from tensorflow.keras import optimizers
from ResNeXt import resnext  # 导入模型
import os
import matplotlib.pyplot as pltos.environ['CUDA_DEVICE_ORDER'] = 'PCI_BUS_ID'  # 调用GPU训练
os.environ['CUDA_VISIBLE_DEVICES'] = '0'  # 使用当前设备的第一块GPUgpus = tf.config.experimental.list_physical_devices("GPU")# 设置GPU内存占用，根据网络模型大小占用相应的内存
if gpus:try:for gpu in gpus:tf.config.experimental.set_memory_growth(gpu, True)except RuntimeError as e:print(e)exit(-1)# ------------------------------------- #
# 加载数据集，batchsz太大会导致显存爆炸
# ------------------------------------- #
filepath = 'D:/deeplearning/test/数据集/交通标志/new_data/'  # 数据集所在文件夹
height = 224  # 输入图象的高
width = 224  # 输入图象的宽
batchsz = 8  # 每个batch处理32张图片
checkData = False  # 查看数据集划分的信息
plotShow = True  # 绘制图像
checkDataAgain = False  # 预处理之后是否再次查看数据集信息
# ------------------------------------- #
# 网络模型结构
# ------------------------------------- #
input_shape = (224,224,3)  # 输入图象的shape
classes = 4  # 图像分类的类别数
checkNet = False  # 是否查看网络架构
# ------------------------------------- #
# 网络训练
# ------------------------------------- #
weights_dir = 'save_weights'  # 权重文件保存的文件夹路径
learning_rate = 0.0005  # adam优化器的学习率
epochs = 10  # 训练迭代次数#（1）加载数据集
def get_data(height, width, batchsz):# 训练集数据train_ds = keras.preprocessing.image_dataset_from_directory(directory = filepath + 'train',  # 训练集图片所在文件夹label_mode = 'categorical',  # onehot编码image_size = (height, width),  # 输入图象的sizebatch_size = batchsz)  # 每批次训练32张图片# 验证集数据val_ds = keras.preprocessing.image_dataset_from_directory(directory = filepath + 'val', label_mode = 'categorical', image_size = (height, width),  batch_size = batchsz)  # 返回划分好的数据集return train_ds, val_ds# 读取数据集
train_ds, val_ds = get_data(height, width, batchsz) #（2）查看数据集信息
def check_data(train_ds):  # 传入训练集数据集# 查看数据集有几个分类类别class_names = train_ds.class_namesprint('classNames:', class_names)# 查看数据集的shape, x代表图片数据, y代表分类类别数据sample = next(iter(train_ds))  # 生成迭代器,每次取出一个batch的数据print('x_batch.shape:', sample[0].shape, 'y_batch.shape:', sample[1].shape)print('前五个目标值:', sample[1][:5])# 是否查看数据集信息
if checkData is True:check_data(train_ds)#（3）查看图像
def plot_show(train_ds):# 生成迭代器,每次取出一个batch的数据sample = next(iter(train_ds))  # sample[0]图像信息, sample[1]标签信息# 显示前5张图for i in range(5):plt.subplot(1,5,i+1)  # 在一块画板的子画板上绘制1行5列plt.imshow(sample[0][i])  # 图像的像素值压缩到0-1plt.xticks([])  # 不显示xy坐标刻度plt.yticks([])plt.show()# 是否展示图像信息
if plotShow is True:plot_show(train_ds)#（4）数据预处理
def processing(x,y):  # 定义预处理函数x = tf.cast(x, dtype=tf.float32) / 255.0  # 图片转换为tensor类型，并归一化y = tf.cast(y, dtype=tf.int32)  # 分类标签转换成tensor类型return x,y# 对所有数据预处理
train_ds = train_ds.map(processing).shuffle(10000)  # map调用自定义预处理函数, shuffle打乱数据集
val_ds = val_ds.map(processing)#（5）查看预处理后的数据是否正确
def check_data_again(train_ds):  # 传入训练集数据集sample = next(iter(train_ds))  # 生成迭代器,每次取出一个batch的数据print('-------after preprocessing-------')print('x_batch.shape:', sample[0].shape, 'y_batch.shape:', sample[1].shape)print('前五个目标值:', sample[1][:5])# 是否查看数据集信息
if checkDataAgain is True:check_data_again(train_ds)#（6）导入网络模型
model = resnext(input_shape=input_shape, # 网络的输入图像的sizeclasses=classes)  # 分类数# 查看网络构架
if checkNet is True:model.summary()#（7）保存权重文件
if not os.path.exists(weights_dir):  # 判断当前文件夹下有没有一个叫save_weights的文件夹os.makedirs(weights_dir)  # 如果没有就创建一个#（8）模型编译
opt = optimizers.Adam(learning_rate=learning_rate)  # 设置Adam优化器model.compile(optimizer=opt, #学习率loss=keras.losses.CategoricalCrossentropy(from_logits=True), # 交叉熵损失，logits层先经过softmaxmetrics=['accuracy']) #评价指标#（9）定义回调函数，一个列表
# 保存模型参数
callbacks = [keras.callbacks.ModelCheckpoint(filepath = 'save_weights/resnext.h5',  # 参数保存的位置save_best_only = True,  # 保存最佳参数save_weights_only = True,  # 只保存权重文件monitor = 'val_loss')]  # 通过验证集损失判断是否是最佳参数#（10）模型训练，history保存训练信息
history = model.fit(x = train_ds,  # 训练集validation_data = val_ds,  # 验证集epochs = epochs,  #迭代30次callbacks = callbacks) #（11）获取训练信息
history_dict = history.history  # 获取训练的数据字典
train_loss = history_dict['loss']  # 训练集损失
train_accuracy = history_dict['accuracy']  # 训练集准确率
val_loss = history_dict['val_loss']  # 验证集损失
val_accuracy = history_dict['val_accuracy']  # 验证集准确率#（12）绘制训练损失和验证损失
plt.figure()
plt.plot(range(epochs), train_loss, label='train_loss')  # 训练集损失
plt.plot(range(epochs), val_loss, label='val_loss')  # 验证集损失
plt.legend()  # 显示标签
plt.xlabel('epochs')
plt.ylabel('loss')#（13）绘制训练集和验证集准确率
plt.figure()
plt.plot(range(epochs), train_accuracy, label='train_accuracy')  # 训练集准确率
plt.plot(range(epochs), val_accuracy, label='val_accuracy')  # 验证集准确率
plt.legend()
plt.xlabel('epochs')
plt.ylabel('accuracy')

3. 预测阶段

以对整个测试集的图片预测为例，test_ds 存放测试集的图片和类别标签，对测试集进行和训练集相同的预处理方法，将像素值映射到0-1之间。

model.predict(img) 返回的是每张图片属于每个类别的概率，需要找到概率最大值所对应的索引 np.argmax(result)，该索引对应的分类名称就是最终预测结果。

打印前10组预测结果

真实值:  ['forbiden', 'forbiden', 'slow', 'forbiden', 'goahead', 'slow', 'goahead', 'slow', 'slow', 'forbiden']
预测值:  ['forbiden', 'forbiden', 'slow', 'forbiden', 'goahead', 'slow', 'goahead', 'slow', 'slow', 'forbiden']

生成真实值和预测值的对比热力图可以观察整个测试集的预测情况

完整代码如下：

import tensorflow as tf
from tensorflow import keras
from ResNeXt import resnext
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt# 报错解决：NotFoundError: No algorithm worked! when using Conv2D
from tensorflow.compat.v1 import ConfigProto
from tensorflow.compat.v1 import InteractiveSession
config = ConfigProto()
config.gpu_options.allow_growth = True
session = InteractiveSession(config=config)# ------------------------------------ #
# 预测参数设置
# ------------------------------------ #
im_height = 224  # 输入图像的高
im_width = 224   # 输入图像的高
# 分类名称
class_names = ['forbiden', 'warning', 'goahead', 'slow']
# 权重路径
weight_dir = 'save_weights/resnext.h5'# ------------------------------------ #
# 单张图片预测
# ------------------------------------ #
# 是否只预测一张图
single_pic = False
# 图像所在文件夹的路径
single_filepath = 'D:/deeplearning/test/数据集/交通标志/new_data/test/禁令标志/'
# 指定某张图片
picture = single_filepath + '010_0001.png'# ------------------------------------ #
# 对测试集图片预测
# ------------------------------------ #
test_pack = True
# 验证集文件夹路径
test_filepath = 'D:/deeplearning/test/数据集/交通标志/new_data/test/'#（1）载入模型
model = resnext(input_shape=[224,224,3], classes=4)  # 模型的输入shape和输出分类数
print('model is loaded')#（2）载入权重.h文件
model.load_weights(weight_dir)
print('weights is loaded')#（3）只对单张图像预测
if single_pic is True:# 加载图片img = Image.open(picture)# 改变图片sizeimg = img.resize((im_height, im_width))# 展示图像plt.figure()plt.imshow(img)plt.xticks([])plt.yticks([])# 图像像素值归一化处理img = np.array(img) / 255.0# 输入网络的要求，给图像增加一个batch维度, [h,w,c]==>[b,h,w,c]img = np.expand_dims(img, axis=0)# 预测图片，返回结果包含batch维度[b,n]result = model.predict(img)# 转换成一维，挤压掉batch维度result = np.squeeze(result)# 找到概率最大值对应的索引predict_class = np.argmax(result)# 打印预测类别及概率print('class:', class_names[predict_class], 'prob:', result[predict_class])plt.title(f'{class_names[predict_class]}')plt.show()#（4）对测试集图像预测
if test_pack is True:# 载入测试集test_ds = keras.preprocessing.image_dataset_from_directory(directory = test_filepath, label_mode = 'int',  # 不经过ont编码, 1、2、3、4、、、 image_size = (im_height, im_width),  # 测试集的图像resizebatch_size = 32)  # 每批次32张图# 测试机预处理#（2）数据预处理def processing(image, label): image = tf.cast(image, tf.float32) / 255.0  #[0,1]之间label = tf.cast(label, tf.int32)  # 修改数据类型return (image, label)test_ds = test_ds.map(processing) # 预处理test_true = []  # 存放真实值test_pred = []  # 存放预测值# 遍历测试集所有的batchfor imgs, labels in test_ds:# 每次每次取出一个batch的一张图像和一个标签for img, label in zip(imgs, labels):# 网络输入的要求，给图像增加一个维度[h,w,c]==>[b,h,w,c]image_array = tf.expand_dims(img, axis=0)# 预测某一张图片，返回图片属于许多类别的概率prediction = model.predict(image_array)# 找到预测概率最大的索引对应的类别test_pred.append(class_names[np.argmax(prediction)])# label是真实标签索引test_true.append(class_names[label])# 展示结果print('真实值: ', test_true[:10])print('预测值: ', test_pred[:10])# 绘制混淆矩阵from sklearn.metrics import confusion_matriximport seaborn as snsimport pandas as pdplt.rcParams['font.sans-serif'] = ['SimSun']  #宋体plt.rcParams['font.size'] = 15  #设置字体大小# 生成混淆矩阵conf_numpy = confusion_matrix(test_true, test_pred)# 转换成DataFrame表格类型，设置行列标签conf_df = pd.DataFrame(conf_numpy, index=class_names, columns=class_names)# 创建绘图区plt.figure(figsize=(8,7))# 生成热力图sns.heatmap(conf_df, annot=True, fmt="d", cmap="BuPu")# 设置标签plt.title('Confusion_Matrix')plt.xlabel('Predict')plt.ylabel('True')

【图像分类案例】(1) ResNeXt 交通标志四分类，附Tensorflow完整代码相关推荐

【图像分类案例】(2) DenseNet 天气图片四分类（权重迁移学习），附Tensorflow完整代码
各位同学好,今天和大家分享一下使用 Tensorflow 构建 DenseNet 卷积神经网络模型,并使用预训练模型的权重,完成对四种天气图片的分类. 完整代码在我的 Gitee 中,有需要的自取: ...
【opencv】(13) 案例：停车场空余车位检测，附python完整代码
各位同学好,今天和大家分享一下如何使用Opencv完成停车场的车位检测,及空余车位计数,先放张图看效果. 红框代表该车位有车,绿框代表该车位空余,左上角记录有几个空余车位,黄色数字代表该车位内的像素个 ...
【数值预测案例】(7) CNN-LSTM 混合神经网络气温预测，附TensorFlow完整代码
大家好,今天和各位分享一下如何使用 Tensorflow 构建 CNN卷积神经网络和 LSTM 循环神经网络相结合的混合神经网络模型,完成对多特征的时间序列预测. 本文预测模型的主要结构由 CNN 和 ...
【数值预测案例】(6) LSTM、GRU 时间序列股票数据预测，附TensorFlow完整代码
大家好,今天和各位分享一下如何使用循环神经网络 LSTM 和 GRU 完成对股票数据的预测.GRU 是在 LSTM 基础上的简化,将 LSTM 内部的三个闸门简化成两个,往往 GRU 的计算效果会优于 ...
【数值预测案例】(5) LSTM 时间序列气温数据预测，附TensorFlow完整代码
大家好,今天和各位分享一下如何使用循环神经网络 LSTM 完成有多个特征的气温预测.上一节中我介绍了 LSTM 的单个特征的预测,感兴趣的可以看一下:https://blog.csdn.net/dgv ...
【机器视觉案例】(5) AI视觉，手势调节物体尺寸，附python完整代码
各位同学好,今天和大家分享一下如何使用opencv+mediapipe完成远程手势调节图片尺寸的案例.先放张图看效果.当拇指和食指竖起时,根据食指间的连线的长度自由缩放图片尺寸.图片的中点始终位于指尖 ...
【机器视觉案例】(5) AI视觉，远程手势控制虚拟计算器，附python完整代码
各位同学好,今天和大家分享一下如何使用MediaPipe+Opencv完成虚拟计算器,先放张图看效果.FPS值为29,食指和中指距离小于规定阈值则认为点击按键,为避免重复数字出现,规定每20帧可点击一 ...
【深度学习】(5) 简单网络，案例：服装图片分类，附python完整代码
1. 数据获取使用系统内部的服装数据集构建神经网络.首先导入需要的库文件,x和y中保存训练集的图像和目标.x_test和y_test中保存测试集需要的图像和目标.(x, y)及(x_test, y_ ...
基于深度学习的大规模交通标志识别（附6GB交通标志数据集）
01 1.文章信息 <Deep Learning for Large-Scale Traffic-Sign Detection and Recognition>. 国外学者2020年发在I ...

【图像分类案例】(1) ResNeXt 交通标志四分类，附Tensorflow完整代码