使用yolov3训练的数据集

1， 建立VOC2007文件夹，按照原来的文件夹名称新建

2， 将图片按照00000x统一命名，保存在JPEGImages文件夹中

3，工具给图片打标签

https://pan.baidu.com/s/1eoUOFVyz7AuB79h_sRgo5Q labelImg，密码：gyf3。

下载文件后，打开…/data/predefined_classes.txt文件，可以发现这里都是图片标签——把你将要用到的标签都事先存入在这里，注意标签不能有中文。每次使用都把.exe、data这两个文件拖到桌面上（如果直接在文件夹内运行.exe会报错不能运行），打开labelImg.exe文件，运行界面如下：就可以开始给图片打标签了

Ctrl+s 保存

d 下一张图片

w 建立选框

4，在VOC2007下新建test.py文件用来生成ImageSets/Main/4个文件

import os

import
random

 

trainval_percent
= 0.1

train_percent
= 0.9

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()

           

5，生成yolov3需要的train.txt,val.txt,test,txt

运行voc_annotation.py,class一检测一类为例（鱼），在voc_annotation.py需改你的数据集为

6，下载代码 https://github.com/qqwweee/keras-yolo3，权重https://pjreddie.com/media/files/yolov3.weights，将权重放在keras-yolo3下文件夹下

7，在工程下新建VOCdeckit文件夹，将VOC2007放在此文件夹下

8，将weight文件转换为h5文件

9，修改yolov3.cfg

搜索yolo(共出现三次)，每次按下图都要修改

filter：3*（5+len（classes））

classes:你要训练的类别数（我这里是训练两类）

random：原来是1，显存小改为0

10， 修改model_data下的voc_classes.txt为自己训练的类别

11，修改train.py代码（用下面代码直接替换原来的代码）

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()


           

替换完成后，因为程序中有logs/000/目录，你需要创建这样一个目录，这个目录的作用就是存放自己的数据集训练得到的模型。不然程序运行到最后会因为找不到该路径而发生错误。

12，修改yolo.py文件，如下这三行修改为各自对应的路径

debug

annotation中路径问题