学习：制作自己的数据集并训练yolo模型(yolov3_keras版本)

学习深度学习目标检测的yolo模型有一段时间了，但是一直没有真正接触最底层的网络构建和训练，之前在Darknet官网上看到有关于训练yolo模型的方法，但是是基于linux操作系统的，那时候还没有接触虚拟机和双系统，于是就搁浅了。其实有不少深度学习框架都已经对yolo进行了复现，比如Tensorflow、Keras、Pytorch，Windows系统下也可以对Darknet框架下的yolo模型进行训练。
选择了Keras和Darknet进行了尝试，先把自己使用keras的方法记录下来，之后再记录Darknet。
一些参考资料：
Keras框架下训练yolo：
https://blog.csdn.net/u012746060/article/details/81183006
https://blog.csdn.net/Patrick_Lxc/article/details/80615433
https://blog.csdn.net/mingqi1996/article/details/83343289
https://blog.csdn.net/qq_39622065/article/details/86174142
windows系统，Darknet框架下训练yolo：
https://blog.csdn.net/maweifei/article/details/81137563
https://blog.csdn.net/kk123k/article/details/86696540
https://blog.csdn.net/syyyy712/article/details/79632016
https://blog.csdn.net/congcong7267/article/details/82981084
https://blog.csdn.net/HelloCode1900/article/details/80906141

step1 基本环境

1、Anaconda(Python 3.6)
内部需包含的库有：
(1)tensorflow-gpu
(2)keras
2、Pycharm

step2 准备工作

1、下载yolov3_keras版本的源代码：https://github.com/qqwweee/keras-yolo3
（解压得到keras-yolo3-master文件夹）

2、下载预训练权重yolov3.weights：https://pjreddie.com/media/files/yolov3.weights
（放入keras-yolo3-master文件夹中）

3、在Anaconda环境中执行如下命令，将权重文件weights转换为适用于keras的h5文件：

python convert.py yolov3.cfg yolov3.weights model_data/yolo.h5

4、h5文件转换完成后，在keras-yolo3-master文件夹中找到yolo.py文件，在该文件最后加上以上代码，并使用命令行运行：

def detect_img(yolo):
    while True:
        img = input('Input image filename:')
        try:
            image = Image.open(img)
        except:
            print('Open Error! Try again!')
            continue
        else:
            r_image = yolo.detect_image(image)
            r_image.show()
            yolo.close_session()


if __name__ == '__main__':
    detect_img(YOLO())

命令行：
python yolo.py
程序会提示你输入图片路径及名称，输入正确后即可显示模型的识别结果

step3 制作数据集

1、创建文件结构目录
（1）在keras-yolo3-master文件夹中创建如下结构的文件夹：
JPEGImages用于存放你的图片；Annotations用于存放标注文件(xml格式，Darknet框架下需要转换为txt格式)；ImageSets/Main用于存放自动生成的训练集、验证集和测试集的图片路径的txt文件；

（2）标注数据：
LabelImg软件下载：https://github.com/tzutalin/labelImg
（解压得到labelImg-master文件夹）
在Anaconda环境中切换到该文件夹目录，并且安装好依赖项：pyqt5和lxml；安装完成后执行如下命令即可打开软件使用：

pip install pyqt5
pip install lxml

pyrcc5 -0 resources.py resources.qrc (该句执行完后没有输出)
python labelImg.py

Open Dir打开图片文件夹目录，Create RectBox创建标注框，Ctrl-S保存xml文件至Annotations文件夹；

（3）在keras-yolo3-master文件夹中找到voc_annotation.py文件，将classes改为自己的类别：

（4）在创建的目录结构中创建一个makedataset.py文件，在ImageSets/Main/文件夹下添加trainval.txt,train.txt,val.txt,test.txt，添加以下代码，并运行，完成数据集的制作：
（关于训练集和验证集的划分比例应根据样本数据确定，如果样本较少，建议改为0.1和0.9）

import os
import random
 
trainval_percent = 0.2
train_percent = 0.8
xmlfilepath = 'Annotations'
txtsavepath = 'ImageSets\Main'
total_xml = os.listdir(xmlfilepath)
 
num = len(total_xml)
list = range(num)
tv = int(num * trainval_percent)
tr = int(tv * train_percent)
trainval = random.sample(list, tv)
train = random.sample(trainval, tr)
 
ftrainval = open('ImageSets/Main/trainval.txt', 'w')
ftest = open('ImageSets/Main/test.txt', 'w')
ftrain = open('ImageSets/Main/train.txt', 'w')
fval = open('ImageSets/Main/val.txt', 'w')
 
for i in list:
    name = total_xml[i][:-4] + '\n'
    if i in trainval:
        ftrainval.write(name)
        if i in train:
            ftest.write(name)
        else:
            fval.write(name)
    else:
        ftrain.write(name)
 
ftrainval.close()
ftrain.close()
fval.close()
ftest.close()

2、
在keras-yolo3-master文件夹中找到yolo3.cfg文件，搜索yolo，一共出现三次，对每个yolo块都作如下修改：
filter=(5+classes)*3 根据自己的类别情况进行计算
classes 根据自己的分类数设置
random 默认为1，如果显存小于4G建议改为0

3、
在keras-yolo3-master/model_data文件夹中找到voc_classes.txt文件，改为自己的类别：

step4 训练

以上所有准备工作全部完成后，就可以进行最后一步训练了。
1、在keras-yolo3-master文件夹下建立文件夹目录：logs/000，用于保存训练生成的模型；

2、在keras-yolo3-master文件夹下找到 train.py，替换为如下代码开始训练：

"""
Retrain the YOLO model for your own dataset.
"""
import numpy as np
import keras.backend as K
from keras.layers import Input, Lambda
from keras.models import Model
from keras.callbacks import TensorBoard, ModelCheckpoint, EarlyStopping
 
from yolo3.model import preprocess_true_boxes, yolo_body, tiny_yolo_body, yolo_loss
from yolo3.utils import get_random_data
 
 
def _main():
    annotation_path = '2007_train.txt'
    log_dir = 'logs/000/'
    classes_path = 'model_data/voc_classes.txt'
    anchors_path = 'model_data/yolo_anchors.txt'
    class_names = get_classes(classes_path)
    anchors = get_anchors(anchors_path)
    input_shape = (416,416) # multiple of 32, hw
    model = create_model(input_shape, anchors, len(class_names) )
    train(model, annotation_path, input_shape, anchors, len(class_names), log_dir=log_dir)
 
def train(model, annotation_path, input_shape, anchors, num_classes, log_dir='logs/'):
    model.compile(optimizer='adam', loss={
        'yolo_loss': lambda y_true, y_pred: y_pred})
    logging = TensorBoard(log_dir=log_dir)
    checkpoint = ModelCheckpoint(log_dir + "ep{epoch:03d}-loss{loss:.3f}-val_loss{val_loss:.3f}.h5",
        monitor='val_loss', save_weights_only=True, save_best_only=True, period=1)
    batch_size = 10
    val_split = 0.1
    with open(annotation_path) as f:
        lines = f.readlines()
    np.random.shuffle(lines)
    num_val = int(len(lines)*val_split)
    num_train = len(lines) - num_val
    print('Train on {} samples, val on {} samples, with batch size {}.'.format(num_train, num_val, batch_size))
 
    model.fit_generator(data_generator_wrap(lines[:num_train], batch_size, input_shape, anchors, num_classes),
            steps_per_epoch=max(1, num_train//batch_size),
            validation_data=data_generator_wrap(lines[num_train:], batch_size, input_shape, anchors, num_classes),
            validation_steps=max(1, num_val//batch_size),
            epochs=500,
            initial_epoch=0)
    model.save_weights(log_dir + 'trained_weights.h5')
 
def get_classes(classes_path):
    with open(classes_path) as f:
        class_names = f.readlines()
    class_names = [c.strip() for c in class_names]
    return class_names
 
def get_anchors(anchors_path):
    with open(anchors_path) as f:
        anchors = f.readline()
    anchors = [float(x) for x in anchors.split(',')]
    return np.array(anchors).reshape(-1, 2)
 
def create_model(input_shape, anchors, num_classes, load_pretrained=False, freeze_body=False,
            weights_path='model_data/yolo_weights.h5'):
    K.clear_session() # get a new session
    image_input = Input(shape=(None, None, 3))
    h, w = input_shape
    num_anchors = len(anchors)
    y_true = [Input(shape=(h//{0:32, 1:16, 2:8}[l], w//{0:32, 1:16, 2:8}[l], \
        num_anchors//3, num_classes+5)) for l in range(3)]
 
    model_body = yolo_body(image_input, num_anchors//3, num_classes)
    print('Create YOLOv3 model with {} anchors and {} classes.'.format(num_anchors, num_classes))
 
    if load_pretrained:
        model_body.load_weights(weights_path, by_name=True, skip_mismatch=True)
        print('Load weights {}.'.format(weights_path))
        if freeze_body:
            # Do not freeze 3 output layers.
            num = len(model_body.layers)-7
            for i in range(num): model_body.layers[i].trainable = False
            print('Freeze the first {} layers of total {} layers.'.format(num, len(model_body.layers)))
 
    model_loss = Lambda(yolo_loss, output_shape=(1,), name='yolo_loss',
        arguments={'anchors': anchors, 'num_classes': num_classes, 'ignore_thresh': 0.5})(
        [*model_body.output, *y_true])
    model = Model([model_body.input, *y_true], model_loss)
    return model
def data_generator(annotation_lines, batch_size, input_shape, anchors, num_classes):
    n = len(annotation_lines)
    np.random.shuffle(annotation_lines)
    i = 0
    while True:
        image_data = []
        box_data = []
        for b in range(batch_size):
            i %= n
            image, box = get_random_data(annotation_lines[i], input_shape, random=True)
            image_data.append(image)
            box_data.append(box)
            i += 1
        image_data = np.array(image_data)
        box_data = np.array(box_data)
        y_true = preprocess_true_boxes(box_data, input_shape, anchors, num_classes)
        yield [image_data, *y_true], np.zeros(batch_size)
 
def data_generator_wrap(annotation_lines, batch_size, input_shape, anchors, num_classes):
    n = len(annotation_lines)
    if n==0 or batch_size<=0: return None
    return data_generator(annotation_lines, batch_size, input_shape, anchors, num_classes)
 
if __name__ == '__main__':
    _main()

训练过程中可以看到gpu的运行情况：

由于只是以学习为目的，所以选取的样本较少（只有十几张图片），迭代次数只有500次，最后的loss有点大，预测结果很一般。
使用Darknet训练时，增大了样本数和迭代次数，loss变小了很多，预测结果相对而言好了很多。

其他参考文章：
标注数据软件使用：
https://blog.csdn.net/u012746060/article/details/81016993
https://www.cnblogs.com/Terrypython/p/9577657.html

Juliet 于 2019.4