VGG
上一篇文章关于AlexNet网络的复现中学习了pytorch和tensorflow两种实现方式，刚开始接触两个框架不太合适，决定先用tensorflow这个框架进行学习网络复现
学习流程
- 阅读VGG论文原文
- 搜集学习资源：视频讲解-博客资源
- 熟悉VGG网络结构
- 代码复现，清楚网络结构中层与层之间的操作
VGG论文
原论文：very deep convolutional networks for large-scale image recognition
论文翻译：暂时没有找到合适的翻译文章
学习资源
博客资源
- 神经网络中卷积层的堆叠
- 随机初始化（Random Initialization）
- 静态图与动态图+Tensorflow中run和.eval的区别+TensorFlow中的Learning rate decay介绍
- 神经网络训练中Epoch、batch_size、iterator的关系
- 基于深度学习的目标检测：数据增强（一）图像翻转、图像旋转、图像放缩
- RGB图像（三通道）的卷积运算
- VGG论文翻译（翻译比较多错误，需要自己识别）
视频资源
- VGG网络详解及感受野的计算
- 使用tensorflow搭建VGG网络
- 霹雳吧啦Wz-太阳花的小绿豆的CSDN博客（博主博客下搜索网络名称即可找到博主的网络解答）
- 霹雳吧啦Wz-github（代码可从github从下载）
VGG网络结构
代码复现
文件目录
其中read_ckpt.py是迁移学习中读取ckpt权重文件的代码，这里不作阐述，fine_train_vgg16.py是训练深度为16时的VGG网络结构的完整代码
剩下的py文件的解析除了视频的讲解，本人也作了大量中文注释及解释
model.py
from tensorflow.keras import layers, models, Model, Sequential
#vgg网络结构生成def
def VGG(feature, im_height=224, im_width=224, num_classes=1000):
# tensorflow中的tensor通道排序是NHWC
input_image = layers.Input(shape=(im_height, im_width, 3), dtype="float32")
x = feature(input_image)
x = layers.Flatten()(x)
x = layers.Dropout(rate=0.5)(x)#随机失活50%的神经元，减少过拟合
x = layers.Dense(2048, activation='relu')(x)
x = layers.Dropout(rate=0.5)(x)#随机失活50%的神经元，减少过拟合
x = layers.Dense(2048, activation='relu')(x)
x = layers.Dense(num_classes)(x)#1000个神经元，最后的一层全连接层
output = layers.Softmax()(x)#类别概率分布层
model = models.Model(inputs=input_image, outputs=output)
return model
#生成提取特征网络结构，根据cfg生成对应的网络配置
def features(cfg):
feature_layers = []
for v in cfg:
if v == "M":
feature_layers.append(layers.MaxPool2D(pool_size=2, strides=2))
else:
conv2d = layers.Conv2D(v, kernel_size=3, padding="SAME", activation="relu")
feature_layers.append(conv2d)
return Sequential(feature_layers, name="feature")#将feature_layers列表中的layers生成为一个网络结构
#A-D的网络配置参数字典，KEY为A-D配置，Values为各层的定义，数字为卷积核的个数，‘M’为最大池化层，调用在def VGG中调用，注意传入参数cfg = cfgs[model_name]，
cfgs = {
'vgg11': [64, 'M', 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
'vgg13': [64, 64, 'M', 128, 128, 'M', 256, 256, 'M', 512, 512, 'M', 512, 512, 'M'],
'vgg16': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 'M', 512, 512, 512, 'M', 512, 512, 512, 'M'],
'vgg19': [64, 64, 'M', 128, 128, 'M', 256, 256, 256, 256, 'M', 512, 512, 512, 512, 'M', 512, 512, 512, 512, 'M'],
}
def vgg(model_name="vgg16", im_height=224, im_width=224, num_classes=1000):
assert model_name in cfgs.keys(), "not support model {}".format(model_name)#异常报错断言
cfg = cfgs[model_name]
model = VGG(features(cfg), im_height=im_height, im_width=im_width, num_classes=num_classes)
return model
model = vgg(model_name='vgg11')
train.py
基于CPU训练的py训练文件，主要的注释和解释放在trainGPU.py的文件那，需要看更清楚的解释去看trainGPU
from tensorflow.keras.preprocessing.image import ImageDataGenerator
import matplotlib.pyplot as plt
from model import vgg
import tensorflow as tf
import json
import os
def main():
#训练集及验证集的路径
data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path
image_path = os.path.join(data_root, "data_set", "flower_data") # flower data set path
train_dir = os.path.join(image_path, "train")
validation_dir = os.path.join(image_path, "val")
#数据异常断言
assert os.path.exists(train_dir), "cannot find {}".format(train_dir)
assert os.path.exists(validation_dir), "cannot find {}".format(validation_dir)
#创建一个保存网络训练权重的文件
# create direction for saving weights
if not os.path.exists("save_weights"):
os.makedirs("save_weights")
#初始化输入规格，训练bach大小和epochs
im_height = 224
im_width = 224
batch_size = 32
epochs = 10
# data generator with data augmentation
#数据预处理，将图像归一化，图像水平翻转
train_image_generator = ImageDataGenerator(rescale=1. / 255,
horizontal_flip=True)
validation_image_generator = ImageDataGenerator(rescale=1. / 255)
#读取图像文件，shuffle：是否随机打乱，target_size网络输入的规格，class_mode分类模式
train_data_gen = train_image_generator.flow_from_directory(directory=train_dir,
batch_size=batch_size,
shuffle=True,
target_size=(im_height, im_width),
class_mode='categorical')
#训练集的数据量，即图片数量
total_train = train_data_gen.n
# get class dict，这里在执行图像生成器train_image_generator.flow_from_directory时，
# class_mode载入训练数据的路径时，train_dir中的目录结构就已经分好类了，总共遍历到train文件夹下的5个花分类文件夹，执行完后train_data_gen的成员
#class_indices初始化为5
class_indices = train_data_gen.class_indices#数据结构为{'daisy': 0, 'dandelion': 1, 'roses': 2, 'sunflowers': 3, 'tulips': 4}
# transform value and key of dict
inverse_dict = dict((val, key) for key, val in class_indices.items())#数据结构为{0: 'daisy', 1: 'dandelion', 2: 'roses', 3: 'sunflowers', 4: 'tulips'}
# write dict into json file，dumps函数将字典转换为json格式，indent是json的格式参数
json_str = json.dumps(inverse_dict, indent=4)
with open('class_indices.json', 'w') as json_file:
json_file.write(json_str)
val_data_gen = validation_image_generator.flow_from_directory(directory=validation_dir,
batch_size=batch_size,
shuffle=False,
target_size=(im_height, im_width),
class_mode='categorical')
total_val = val_data_gen.n
print("using {} images for training, {} images for validation.".format(total_train,
total_val))
model = vgg("vgg16", 224, 224, 5)
model.summary()
# using keras high level api for training
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0001),
loss=tf.keras.losses.CategoricalCrossentropy(from_logits=False),#模型已经经过softmax，from_logits就为false
metrics=["accuracy"])
#回调函数，控制模型训练过程中保存的参数，filepath保存模型的位置，save_best_only只保存最佳的模型，save_weights_only只保存权重文件，存储小点
#monitor监控参数，判断最佳的损失函数定义为val_loss，用验证集的损失来验证模型好坏
callbacks = [tf.keras.callbacks.ModelCheckpoint(filepath='./save_weights/myVGG.h5',
save_best_only=True,
save_weights_only=True,
monitor='val_loss')]
# tensorflow2.1 recommend to using fit
#step_per_epoch:Total number of steps (batches of samples)
history = model.fit(x=train_data_gen,
steps_per_epoch=total_train // batch_size,
epochs=epochs,
validation_data=val_data_gen,
validation_steps=total_val // batch_size,
callbacks=callbacks)
# plot loss and accuracy image
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"]
# figure 1
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')
# figure 2
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')
plt.show()
if __name__ == '__main__':
main()
trainGPU.py
import matplotlib.pyplot as plt
from model import vgg
import tensorflow as tf
import json
import os
import time
import glob
import random
#设置tf只能使用哪块gpu
os.environ["CUDA_DEVICE_ORDER"] = "PCI_BUS_ID"
os.environ["CUDA_VISIBLE_DEVICES"] = "0"
def main():
#设置训练设备参数
# gpus = tf.config.experimental.list_physical_devices("GPU")
# if gpus:
# try:
# for gpu in gpus:
# #设置tf对显卡根据模型大小设置显存占用
# tf.config.experimental.set_memory_growth(gpu, True)
# except RuntimeError as e:
# print(e)
# exit(-1)
#训练集及验证集的路径
data_root = os.path.abspath(os.path.join(os.getcwd(), "../..")) # get data root path
image_path = os.path.join(data_root, "data_set", "flower_data") # flower data set path
train_dir = os.path.join(image_path, "train")
validation_dir = os.path.join(image_path, "val")
# 数据异常断言
assert os.path.exists(train_dir), "cannot find {}".format(train_dir)
assert os.path.exists(validation_dir), "cannot find {}".format(validation_dir)
# 创建一个保存网络训练权重的文件
# create direction for saving weights
if not os.path.exists("save_weights"):
os.makedirs("save_weights")
# 初始化输入规格，训练bach大小和epochs
im_height = 224
im_width = 224
batch_size = 32
epochs = 10
# class dict
#这里由于没有用到ImageDataGenerator，不像train.py训练时使用了ImageDataGenerator方法能够通过
#ImageDataGenerator的flow_from_directory方法根据文件目录得到class_indices，这里需要自己生成
#data_class包含train文件夹的所有子文件夹，用到listdir方法
data_class = [cla for cla in os.listdir(train_dir) if os.path.isdir(os.path.join(train_dir, cla))]
#训练类个数
class_num = len(data_class)
# >> > seasons = ['Spring', 'Summer', 'Fall', 'Winter']
# >> > list(enumerate(seasons))
# [(0, 'Spring'), (1, 'Summer'), (2, 'Fall'), (3, 'Winter')]
# 这里说明enumerate的作用
class_dict = dict((value, index) for index, value in enumerate(data_class))
# 数据结构为{'daisy': 0, 'dandelion': 1, 'roses': 2, 'sunflowers': 3, 'tulips': 4}
# reverse value and key of dict
# 数据结构为{0: 'daisy', 1: 'dandelion', 2: 'roses', 3: 'sunflowers', 4: 'tulips'}
inverse_dict = dict((val, key) for key, val in class_dict.items())
# write dict into json file
# json_str数据结构
# '{
# "0": "daisy",
# "1": "dandelion",
# "2": "roses",
# "3": "sunflowers",
# "4": "tulips"
# }'
# dumps函数将字典转换为json格式，indent是json的格式参数
json_str = json.dumps(inverse_dict, indent=4)
# 将json_str写入json_file
with open('class_indices.json', 'w') as json_file:
json_file.write(json_str)
# load train images list
# glob.glob函数遍历train目录下各个类文件夹下的jpg文件，返回一个跟文件目录同序的列表，列表元素均为每个jpg的路径
train_image_list = glob.glob(train_dir+"/*/*.jpg")
#随机打乱
random.shuffle(train_image_list)
train_num = len(train_image_list)
# 异常断言
assert train_num > 0, "cannot find any .jpg file in {}".format(train_dir)
# os.path.sep 为 / 分隔符，[-2]是倒数第2个分隔符，即jpg的前两个分隔符的位置，比如/类/jpg，
# 倒数第2个和的为类，class_path[类]即这个类对应的数字，具体可看debug
train_label_list = [class_dict[path.split(os.path.sep)[-2]] for path in train_image_list]
# load validation images list
val_image_list = glob.glob(validation_dir+"/*/*.jpg")
random.shuffle(val_image_list)
val_num = len(val_image_list)
assert val_num > 0, "cannot find any .jpg file in {}".format(validation_dir)
val_label_list = [class_dict[path.split(os.path.sep)[-2]] for path in val_image_list]
# 输出训练集验证集的图片个数
print("using {} images for training, {} images for validation.".format(train_num,
val_num))
# 上面得到训练集验证集的路径，标签在这个方法进行载入处理
def process_path(img_path, label):
#标签改为onehot编码，深度depth即编码的最大值，是一个标量，用于定义一个 one hot 维度的深度
label = tf.one_hot(label, depth=class_num)
# 处理图片路径
image = tf.io.read_file(img_path)#读取文件路径
image = tf.image.decode_jpeg(image)#解析为jpg
image = tf.image.convert_image_dtype(image, tf.float32)#转换数据类型为float32
# 调整图片大小，调整图像大小的方法使用默认的方法，比较常见有双线性插值，最邻近，双三次插值，面积插值
image = tf.image.resize(image, [im_height, im_width])#
return image, label
# 根据可用的CPU动态设置并行调用的数量
AUTOTUNE = tf.data.experimental.AUTOTUNE
# load train dataset
# tf.data.Dataset相对ImageDataGenerator的区别是多线程载入数据，相比ImageDataGenerator快很多
#详细的库说明查看Tensorflow，tf.data库文档说明
#将元组(train_image_list, train_labe_list)切片，详情如下
#>>> dataset = tf.data.Dataset.from_tensor_slices(([1, 2], [3, 4], [5, 6]))
# >>> list(dataset.as_numpy_iterator())
# [(1, 3, 5), (2, 4, 6)]
#这里原本的(train_image_list, train_label_list):([p1,p2,...,pn],[l1,l2,...,ln])
#这里将训练图片路径和训练图片标签一对一组成元组对:[(p1，l1)，(p2，l2),...,(pn,ln)]
train_dataset = tf.data.Dataset.from_tensor_slices((train_image_list, train_label_list))
#shuffle对前buffer_size个数据进行打乱
#map(map_func, num_parallel_calls=None, deterministic=None)
#map_func方法会遍历dataset所有的元素，将每个元素应用map_func转换数据，并且返回一个新的dataset，包含了
#这些转换后的元素，顺序不变，map_func能够更改dataset的值和结构
#num_parallel_calls参数是处理数据的方式，具体见官方文档，第三个参数没用到，用到再学
#repeat方法repeat(count=None),重复原生数据count次，count为None表示无限期重复，
#这里repeat方法非常重要，是训练或者验证时防止数据不够的措施，所有数据训练完之后，没有数据了，下一个epoch要训练
#却没有数据了，这里的repeat方法能够不断循环取得原生数据来训练或者验证
#batch(batch_size, drop_remainder=False)将dataset数据分成每批batch_size的列表
#drop_remainder表示如果最后一个批次的数量少于batch_size元素，是否应删除该批次；默认行为是不删除较小的批次
#这里repeat用了之后，drop_remainder无需理会
#prefetch(buffer_size)创建一个数据集，该数据集从该数据集中预取元素，
#这里.batch(batch_size).prefetch(AUTOTUNE)表示预先取AUTOTUNE批数据，每批有batch_size个元素供并行处理
train_dataset = train_dataset.shuffle(buffer_size=train_num)\
.map(process_path, num_parallel_calls=AUTOTUNE)\
.repeat().batch(batch_size).prefetch(AUTOTUNE)
# load train dataset
val_dataset = tf.data.Dataset.from_tensor_slices((val_image_list, val_label_list))
val_dataset = val_dataset.map(process_path, num_parallel_calls=tf.data.experimental.AUTOTUNE)\
.repeat().batch(batch_size)
# 实例化模型
model = vgg("vgg16", 224, 224, 5)
model.summary()
# using keras low level api for training
# loss_object = tf.keras.losses.CategoricalCrossentropy(from_logits=False)
# optimizer = tf.keras.optimizers.Adam(learning_rate=0.0001)
#
# train_loss = tf.keras.metrics.Mean(name='train_loss')
# train_accuracy = tf.keras.metrics.CategoricalAccuracy(name='train_accuracy')
#
# test_loss = tf.keras.metrics.Mean(name='test_loss')
# test_accuracy = tf.keras.metrics.CategoricalAccuracy(name='test_accuracy')
#
# @tf.function
# def train_step(images, labels):
# with tf.GradientTape() as tape:
# predictions = model(images, training=True)
# loss = loss_object(labels, predictions)
# gradients = tape.gradient(loss, model.trainable_variables)
# optimizer.apply_gradients(zip(gradients, model.trainable_variables))
#
# train_loss(loss)
# train_accuracy(labels, predictions)
#
# @tf.function
# def test_step(images, labels):
# predictions = model(images, training=False)
# t_loss = loss_object(labels, predictions)
#
# test_loss(t_loss)
# test_accuracy(labels, predictions)
#
# best_test_loss = float('inf')
# train_step_num = train_num // batch_size
# val_step_num = val_num // batch_size
# for epoch in range(1, epochs+1):
# train_loss.reset_states() # clear history info
# train_accuracy.reset_states() # clear history info
# test_loss.reset_states() # clear history info
# test_accuracy.reset_states() # clear history info
#
# t1 = time.perf_counter()
# for index, (images, labels) in enumerate(train_dataset):
# train_step(images, labels)
# if index+1 == train_step_num:
# break
# print(time.perf_counter()-t1)
#
# for index, (images, labels) in enumerate(val_dataset):
# test_step(images, labels)
# if index+1 == val_step_num:
# break
#
# template = 'Epoch {}, Loss: {}, Accuracy: {}, Test Loss: {}, Test Accuracy: {}'
# print(template.format(epoch,
# train_loss.result(),
# train_accuracy.result() * 100,
# test_loss.result(),
# test_accuracy.result() * 100))
# if test_loss.result() < best_test_loss:
# model.save_weights("./save_weights/myVGG.ckpt".format(epoch), save_format='tf')
# using keras high level api for training
#model.compile()方法用于在配置训练方法时，告知训练时用的优化器、损失函数和准确率评测标准
model.compile(optimizer=tf.keras.optimizers.Adam(learning_rate=0.0005),
loss=tf.keras.losses.CategoricalCrossentropy(from_logits=False),
metrics=["accuracy"])
# 回调函数，控制模型训练过程中保存的参数，filepath保存模型的位置，save_best_only只保存最佳的模型，save_weights_only只保存权重文件，存储小点
# monitor监控参数，判断最佳的损失函数定义为val_loss，用验证集的损失来验证模型好坏
callbacks = [tf.keras.callbacks.ModelCheckpoint(filepath='./save_weights/myVGG_{epoch}.h5',
save_best_only=True,
save_weights_only=True,
monitor='val_loss')]
# tensorflow2.1 recommend to using fit
#step_per_epoch:Total number of steps (batches of samples)
#// 表示整数除法，向下取整
# fit方法执行训练过程
history = model.fit(x=train_dataset,
steps_per_epoch=train_num // batch_size,
epochs=epochs,
validation_data=val_dataset,
validation_steps=val_num // batch_size,
callbacks=callbacks)
# plot loss and accuracy image
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"]
# figure 1
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')
# figure 2
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')
plt.show()
if __name__ == '__main__':
main()
predict.py
import os
import json
from PIL import Image
import numpy as np
import matplotlib.pyplot as plt
from model import vgg
def main():
im_height = 224
im_width = 224
num_classes = 5
# load image
img_path = "../tulip.jpg"
assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
img = Image.open(img_path)
# resize image to 224x224
img = img.resize((im_width, im_height))
plt.imshow(img)
# scaling pixel value to (0-1)
img = np.array(img) / 255.
# Add the image to a batch where it's the only member.
img = (np.expand_dims(img, 0))
# read class_indict
json_path = './class_indices.json'
assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)
json_file = open(json_path, "r")
class_indict = json.load(json_file)
# create model
model = vgg("vgg16", im_height=im_height, im_width=im_width, num_classes=num_classes)
weights_path = "./save_weights/myVGG.h5"
assert os.path.exists(img_path), "file: '{}' dose not exist.".format(weights_path)
model.load_weights(weights_path)
# prediction
result = np.squeeze(model.predict(img))
predict_class = np.argmax(result)
print_res = "class: {} prob: {:.3}".format(class_indict[str(predict_class)],
result[predict_class])
plt.title(print_res)
print(print_res)
plt.show()
if __name__ == '__main__':
main()
预测结果
以batch_size=10去训练得到权重
378
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
