0008-目标检测-基于keras-yolov3训练自己的数据集

墨蓝 2023-01-07 07:19 238阅读 0赞

# 数据准备 #

## 首先按照voc格式提前准备好文件夹，示例如下： ##

![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25nbG9uZ3NoZW4_size_16_color_FFFFFF_t_70]

## 生成训练集/测试集，train.txt/test.txt ##

主要代码如下：

import os
    import random
    
    test_percent = 0.1 #可根据自己需要进行调整
    train_percent = 0.9
    xmlfilepath = 'Annotations'
    txtsavepath = 'ImageSets\Main'
    total_xml = os.listdir(xmlfilepath)
    
    num = len(total_xml)
    list = range(num)
    te = int(num * test_percent)
    # tr = int(num * train_percent)
    test = random.sample(list, te)
    # train = random.sample(trainval, tr)
    
    ftest = open('ImageSets/Main/test.txt', 'w')
    ftrain = open('ImageSets/Main/train.txt', 'w')
    
    for i in list:
        name = total_xml[i][:-4] + '\n'
        if i in test:
            ftest.write(name)
        else:
            ftrain.write(name)
    
    ftrain.close()
    ftest.close()

### 定义标签名称，fish-class.txt ###

human_face
    fish

### 定制属于自己数据集anchor ###

这里主要用到kmeans对自己对数据进行聚类所得，具体原理，以后再详细讲

import numpy as np
    
    
    class YOLO_Kmeans:
    
        def __init__(self, cluster_number, filename):
            self.cluster_number = cluster_number
            self.filename = "2012_train.txt"
    
        def iou(self, boxes, clusters):  # 1 box -> k clusters
            n = boxes.shape[0]
            k = self.cluster_number
    
            box_area = boxes[:, 0] * boxes[:, 1]
            box_area = box_area.repeat(k)
            box_area = np.reshape(box_area, (n, k))
    
            cluster_area = clusters[:, 0] * clusters[:, 1]
            cluster_area = np.tile(cluster_area, [1, n])
            cluster_area = np.reshape(cluster_area, (n, k))
    
            box_w_matrix = np.reshape(boxes[:, 0].repeat(k), (n, k))
            cluster_w_matrix = np.reshape(np.tile(clusters[:, 0], (1, n)), (n, k))
            min_w_matrix = np.minimum(cluster_w_matrix, box_w_matrix)
    
            box_h_matrix = np.reshape(boxes[:, 1].repeat(k), (n, k))
            cluster_h_matrix = np.reshape(np.tile(clusters[:, 1], (1, n)), (n, k))
            min_h_matrix = np.minimum(cluster_h_matrix, box_h_matrix)
            inter_area = np.multiply(min_w_matrix, min_h_matrix)
    
            result = inter_area / (box_area + cluster_area - inter_area)
            return result
    
        def avg_iou(self, boxes, clusters):
            accuracy = np.mean([np.max(self.iou(boxes, clusters), axis=1)])
            return accuracy
    
        def kmeans(self, boxes, k, dist=np.median):
            box_number = boxes.shape[0]
            distances = np.empty((box_number, k))
            last_nearest = np.zeros((box_number,))
            np.random.seed()
            clusters = boxes[np.random.choice(
                box_number, k, replace=False)]  # init k clusters
            while True:
    
                distances = 1 - self.iou(boxes, clusters)
    
                current_nearest = np.argmin(distances, axis=1)
                if (last_nearest == current_nearest).all():
                    break  # clusters won't change
                for cluster in range(k):
                    clusters[cluster] = dist(  # update clusters
                        boxes[current_nearest == cluster], axis=0)
    
                last_nearest = current_nearest
    
            return clusters
    
        def result2txt(self, data):
            f = open("yolo_anchors.txt", 'w')
            row = np.shape(data)[0]
            for i in range(row):
                if i == 0:
                    x_y = "%d,%d" % (data[i][0], data[i][1])
                else:
                    x_y = ", %d,%d" % (data[i][0], data[i][1])
                f.write(x_y)
            f.close()
    
        def txt2boxes(self):
            f = open(self.filename, 'r')
            dataSet = []
            for line in f:
                infos = line.split(" ")
                length = len(infos)
                for i in range(1, length):
                    width = int(infos[i].split(",")[2]) - \
                        int(infos[i].split(",")[0])
                    height = int(infos[i].split(",")[3]) - \
                        int(infos[i].split(",")[1])
                    dataSet.append([width, height])
            result = np.array(dataSet)
            f.close()
            return result
    
        def txt2clusters(self):
            all_boxes = self.txt2boxes()
            result = self.kmeans(all_boxes, k=self.cluster_number)
            result = result[np.lexsort(result.T[0, None])]
            self.result2txt(result)
            print("K anchors:\n {}".format(result))
            print("Accuracy: {:.2f}%".format(
                self.avg_iou(all_boxes, result) * 100))
    
    
    if __name__ == "__main__":
        cluster_number = 9 #这里要根据是使用的yoloV3还是tiny 区分设置
        filename = "2012_train.txt"
        kmeans = YOLO_Kmeans(cluster_number, filename)
        kmeans.txt2clusters()

### 生成voc\_annotation文件 ###

import xml.etree.ElementTree as ET
    from os import getcwd
    
    # sets=[('2007', 'train'), ('2007', 'val'), ('2007', 'test')]
    sets=[('2007', 'train'), ('2007', 'test')]
    
    classes = ["human_face","fish"] #这里换成自己刚才定义的类别名字
    
    
    def convert_annotation(year, image_id, list_file):
        in_file = open('VOCdevkit/VOC%s/Annotations/%s.xml'%(year, image_id))
        tree=ET.parse(in_file)
        root = tree.getroot()
    
        for obj in root.iter('object'):
            difficult = obj.find('difficult').text
            cls = obj.find('name').text
            if cls not in classes or int(difficult)==1:
                continue
            cls_id = classes.index(cls)
            xmlbox = obj.find('bndbox')
            b = (int(xmlbox.find('xmin').text), int(xmlbox.find('ymin').text), int(xmlbox.find('xmax').text), int(xmlbox.find('ymax').text))
            list_file.write(" " + ",".join([str(a) for a in b]) + ',' + str(cls_id))
    
    wd = getcwd()
    
    for year, image_set in sets:
        image_ids = open('VOCdevkit/VOC%s/ImageSets/Main/%s.txt'%(year, image_set)).read().strip().split()
        list_file = open('%s_%s.txt'%(year, image_set), 'w')
        for image_id in image_ids:
            list_file.write('%s/VOCdevkit/VOC%s/JPEGImages/%s.jpg'%(wd, year, image_id))
            convert_annotation(year, image_id, list_file)
            list_file.write('\n')
        list_file.close()

### 由于我们是在原来作者对基础上进行fine-tune对，所以需要将weights文件转化为h5文件 ###

#! /usr/bin/env python
    """
    Reads Darknet config and weights and creates Keras model with TF backend.
    
    """
    
    import argparse
    import configparser
    import io
    import os
    from collections import defaultdict
    
    import numpy as np
    from keras import backend as K
    from keras.layers import (Conv2D, Input, ZeroPadding2D, Add,
                              UpSampling2D, MaxPooling2D, Concatenate)
    from keras.layers.advanced_activations import LeakyReLU
    from keras.layers.normalization import BatchNormalization
    from keras.models import Model
    from keras.regularizers import l2
    from keras.utils.vis_utils import plot_model as plot
    
    
    parser = argparse.ArgumentParser(description='Darknet To Keras Converter.')
    parser.add_argument('config_path', help='Path to Darknet cfg file.')
    parser.add_argument('weights_path', help='Path to Darknet weights file.')
    parser.add_argument('output_path', help='Path to output Keras model file.')
    parser.add_argument(
        '-p',
        '--plot_model',
        help='Plot generated Keras model and save as image.',
        action='store_true')
    parser.add_argument(
        '-w',
        '--weights_only',
        help='Save as Keras weights file instead of model file.',
        action='store_true')
    
    def unique_config_sections(config_file):
        """Convert all config sections to have unique names.
    
        Adds unique suffixes to config sections for compability with configparser.
        """
        section_counters = defaultdict(int)
        output_stream = io.StringIO()
        with open(config_file) as fin:
            for line in fin:
                if line.startswith('['):
                    section = line.strip().strip('[]')
                    _section = section + '_' + str(section_counters[section])
                    section_counters[section] += 1
                    line = line.replace(section, _section)
                output_stream.write(line)
        output_stream.seek(0)
        return output_stream
    
    # %%
    def _main(args):
        config_path = os.path.expanduser(args.config_path)
        weights_path = os.path.expanduser(args.weights_path)
        assert config_path.endswith('.cfg'), '{} is not a .cfg file'.format(
            config_path)
        assert weights_path.endswith(
            '.weights'), '{} is not a .weights file'.format(weights_path)
    
        output_path = os.path.expanduser(args.output_path)
        assert output_path.endswith(
            '.h5'), 'output path {} is not a .h5 file'.format(output_path)
        output_root = os.path.splitext(output_path)[0]
    
        # Load weights and config.
        print('Loading weights.')
        weights_file = open(weights_path, 'rb')
        major, minor, revision = np.ndarray(
            shape=(3, ), dtype='int32', buffer=weights_file.read(12))
        if (major*10+minor)>=2 and major<1000 and minor<1000:
            seen = np.ndarray(shape=(1,), dtype='int64', buffer=weights_file.read(8))
        else:
            seen = np.ndarray(shape=(1,), dtype='int32', buffer=weights_file.read(4))
        print('Weights Header: ', major, minor, revision, seen)
    
        print('Parsing Darknet config.')
        unique_config_file = unique_config_sections(config_path)
        cfg_parser = configparser.ConfigParser()
        cfg_parser.read_file(unique_config_file)
    
        print('Creating Keras model.')
        input_layer = Input(shape=(None, None, 3))
        prev_layer = input_layer
        all_layers = []
    
        weight_decay = float(cfg_parser['net_0']['decay']
                             ) if 'net_0' in cfg_parser.sections() else 5e-4
        count = 0
        out_index = []
        for section in cfg_parser.sections():
            print('Parsing section {}'.format(section))
            if section.startswith('convolutional'):
                filters = int(cfg_parser[section]['filters'])
                size = int(cfg_parser[section]['size'])
                stride = int(cfg_parser[section]['stride'])
                pad = int(cfg_parser[section]['pad'])
                activation = cfg_parser[section]['activation']
                batch_normalize = 'batch_normalize' in cfg_parser[section]
    
                padding = 'same' if pad == 1 and stride == 1 else 'valid'
    
                # Setting weights.
                # Darknet serializes convolutional weights as:
                # [bias/beta, [gamma, mean, variance], conv_weights]
                prev_layer_shape = K.int_shape(prev_layer)
    
                weights_shape = (size, size, prev_layer_shape[-1], filters)
                darknet_w_shape = (filters, weights_shape[2], size, size)
                weights_size = np.product(weights_shape)
    
                print('conv2d', 'bn'
                      if batch_normalize else '  ', activation, weights_shape)
    
                conv_bias = np.ndarray(
                    shape=(filters, ),
                    dtype='float32',
                    buffer=weights_file.read(filters * 4))
                count += filters
    
                if batch_normalize:
                    bn_weights = np.ndarray(
                        shape=(3, filters),
                        dtype='float32',
                        buffer=weights_file.read(filters * 12))
                    count += 3 * filters
    
                    bn_weight_list = [
                        bn_weights[0],  # scale gamma
                        conv_bias,  # shift beta
                        bn_weights[1],  # running mean
                        bn_weights[2]  # running var
                    ]
    
                conv_weights = np.ndarray(
                    shape=darknet_w_shape,
                    dtype='float32',
                    buffer=weights_file.read(weights_size * 4))
                count += weights_size
    
                # DarkNet conv_weights are serialized Caffe-style:
                # (out_dim, in_dim, height, width)
                # We would like to set these to Tensorflow order:
                # (height, width, in_dim, out_dim)
                conv_weights = np.transpose(conv_weights, [2, 3, 1, 0])
                conv_weights = [conv_weights] if batch_normalize else [
                    conv_weights, conv_bias
                ]
    
                # Handle activation.
                act_fn = None
                if activation == 'leaky':
                    pass  # Add advanced activation later.
                elif activation != 'linear':
                    raise ValueError(
                        'Unknown activation function `{}` in section {}'.format(
                            activation, section))
    
                # Create Conv2D layer
                if stride>1:
                    # Darknet uses left and top padding instead of 'same' mode
                    prev_layer = ZeroPadding2D(((1,0),(1,0)))(prev_layer)
                conv_layer = (Conv2D(
                    filters, (size, size),
                    strides=(stride, stride),
                    kernel_regularizer=l2(weight_decay),
                    use_bias=not batch_normalize,
                    weights=conv_weights,
                    activation=act_fn,
                    padding=padding))(prev_layer)
    
                if batch_normalize:
                    conv_layer = (BatchNormalization(
                        weights=bn_weight_list))(conv_layer)
                prev_layer = conv_layer
    
                if activation == 'linear':
                    all_layers.append(prev_layer)
                elif activation == 'leaky':
                    act_layer = LeakyReLU(alpha=0.1)(prev_layer)
                    prev_layer = act_layer
                    all_layers.append(act_layer)
    
            elif section.startswith('route'):
                ids = [int(i) for i in cfg_parser[section]['layers'].split(',')]
                layers = [all_layers[i] for i in ids]
                if len(layers) > 1:
                    print('Concatenating route layers:', layers)
                    concatenate_layer = Concatenate()(layers)
                    all_layers.append(concatenate_layer)
                    prev_layer = concatenate_layer
                else:
                    skip_layer = layers[0]  # only one layer to route
                    all_layers.append(skip_layer)
                    prev_layer = skip_layer
    
            elif section.startswith('maxpool'):
                size = int(cfg_parser[section]['size'])
                stride = int(cfg_parser[section]['stride'])
                all_layers.append(
                    MaxPooling2D(
                        pool_size=(size, size),
                        strides=(stride, stride),
                        padding='same')(prev_layer))
                prev_layer = all_layers[-1]
    
            elif section.startswith('shortcut'):
                index = int(cfg_parser[section]['from'])
                activation = cfg_parser[section]['activation']
                assert activation == 'linear', 'Only linear activation supported.'
                all_layers.append(Add()([all_layers[index], prev_layer]))
                prev_layer = all_layers[-1]
    
            elif section.startswith('upsample'):
                stride = int(cfg_parser[section]['stride'])
                assert stride == 2, 'Only stride=2 supported.'
                all_layers.append(UpSampling2D(stride)(prev_layer))
                prev_layer = all_layers[-1]
    
            elif section.startswith('yolo'):
                out_index.append(len(all_layers)-1)
                all_layers.append(None)
                prev_layer = all_layers[-1]
    
            elif section.startswith('net'):
                pass
    
            else:
                raise ValueError(
                    'Unsupported section header type: {}'.format(section))
    
        # Create and save model.
        if len(out_index)==0: out_index.append(len(all_layers)-1)
        model = Model(inputs=input_layer, outputs=[all_layers[i] for i in out_index])
        print(model.summary())
        if args.weights_only:
            model.save_weights('{}'.format(output_path))
            print('Saved Keras weights to {}'.format(output_path))
        else:
            model.save('{}'.format(output_path))
            print('Saved Keras model to {}'.format(output_path))
    
        # Check to see if all weights have been read.
        remaining_weights = len(weights_file.read()) / 4
        weights_file.close()
        print('Read {} of {} from Darknet weights.'.format(count, count +
                                                           remaining_weights))
        if remaining_weights > 0:
            print('Warning: {} unused weights'.format(remaining_weights))
    
        if args.plot_model:
            plot(model, to_file='{}.png'.format(output_root), show_shapes=True)
            print('Saved model plot to {}.png'.format(output_root))
    
    
    if __name__ == '__main__':
        _main(parser.parse_args())

# 模型训练 #

### 1.创建yolo模型框架model.py ###

"""YOLO_v3 Model Defined in Keras."""
    
    from functools import wraps
    
    import numpy as np
    import tensorflow as tf
    from keras import backend as K
    from keras.layers import Conv2D, Add, ZeroPadding2D, UpSampling2D, Concatenate, MaxPooling2D
    from keras.layers.advanced_activations import LeakyReLU
    from keras.layers.normalization import BatchNormalization
    from keras.models import Model
    from keras.regularizers import l2
    
    from yolo3.utils import compose
    
    
    @wraps(Conv2D)
    def DarknetConv2D(*args, **kwargs):
        """Wrapper to set Darknet parameters for Convolution2D."""
        darknet_conv_kwargs = {'kernel_regularizer': l2(5e-4)}
        darknet_conv_kwargs['padding'] = 'valid' if kwargs.get('strides')==(2,2) else 'same'
        darknet_conv_kwargs.update(kwargs)
        return Conv2D(*args, **darknet_conv_kwargs)
    
    def DarknetConv2D_BN_Leaky(*args, **kwargs):
        """Darknet Convolution2D followed by BatchNormalization and LeakyReLU."""
        no_bias_kwargs = {'use_bias': False}
        no_bias_kwargs.update(kwargs)
        return compose(
            DarknetConv2D(*args, **no_bias_kwargs),
            BatchNormalization(),
            LeakyReLU(alpha=0.1))
    
    def resblock_body(x, num_filters, num_blocks):
        '''A series of resblocks starting with a downsampling Convolution2D'''
        # Darknet uses left and top padding instead of 'same' mode
        x = ZeroPadding2D(((1,0),(1,0)))(x)
        x = DarknetConv2D_BN_Leaky(num_filters, (3,3), strides=(2,2))(x)
        for i in range(num_blocks):
            y = compose(
                    DarknetConv2D_BN_Leaky(num_filters//2, (1,1)),
                    DarknetConv2D_BN_Leaky(num_filters, (3,3)))(x)
            x = Add()([x,y])
        return x
    
    def darknet_body(x):
        '''Darknent body having 52 Convolution2D layers'''
        x = DarknetConv2D_BN_Leaky(32, (3,3))(x)
        x = resblock_body(x, 64, 1)
        x = resblock_body(x, 128, 2)
        x = resblock_body(x, 256, 8)
        x = resblock_body(x, 512, 8)
        x = resblock_body(x, 1024, 4)
        return x
    
    def make_last_layers(x, num_filters, out_filters):
        '''6 Conv2D_BN_Leaky layers followed by a Conv2D_linear layer'''
        x = compose(
                DarknetConv2D_BN_Leaky(num_filters, (1,1)),
                DarknetConv2D_BN_Leaky(num_filters*2, (3,3)),
                DarknetConv2D_BN_Leaky(num_filters, (1,1)),
                DarknetConv2D_BN_Leaky(num_filters*2, (3,3)),
                DarknetConv2D_BN_Leaky(num_filters, (1,1)))(x)
        y = compose(
                DarknetConv2D_BN_Leaky(num_filters*2, (3,3)),
                DarknetConv2D(out_filters, (1,1)))(x)
        return x, y
    
    
    def yolo_body(inputs, num_anchors, num_classes):
        """Create YOLO_V3 model CNN body in Keras."""
        darknet = Model(inputs, darknet_body(inputs))
        x, y1 = make_last_layers(darknet.output, 512, num_anchors*(num_classes+5))
    
        x = compose(
                DarknetConv2D_BN_Leaky(256, (1,1)),
                UpSampling2D(2))(x)
        x = Concatenate()([x,darknet.layers[152].output])
        x, y2 = make_last_layers(x, 256, num_anchors*(num_classes+5))
    
        x = compose(
                DarknetConv2D_BN_Leaky(128, (1,1)),
                UpSampling2D(2))(x)
        x = Concatenate()([x,darknet.layers[92].output])
        x, y3 = make_last_layers(x, 128, num_anchors*(num_classes+5))
    
        return Model(inputs, [y1,y2,y3])
    
    def tiny_yolo_body(inputs, num_anchors, num_classes):
        '''Create Tiny YOLO_v3 model CNN body in keras.'''
        x1 = compose(
                DarknetConv2D_BN_Leaky(16, (3,3)),
                MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
                DarknetConv2D_BN_Leaky(32, (3,3)),
                MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
                DarknetConv2D_BN_Leaky(64, (3,3)),
                MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
                DarknetConv2D_BN_Leaky(128, (3,3)),
                MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
                DarknetConv2D_BN_Leaky(256, (3,3)))(inputs)
        x2 = compose(
                MaxPooling2D(pool_size=(2,2), strides=(2,2), padding='same'),
                DarknetConv2D_BN_Leaky(512, (3,3)),
                MaxPooling2D(pool_size=(2,2), strides=(1,1), padding='same'),
                DarknetConv2D_BN_Leaky(1024, (3,3)),
                DarknetConv2D_BN_Leaky(256, (1,1)))(x1)
        y1 = compose(
                DarknetConv2D_BN_Leaky(512, (3,3)),
                DarknetConv2D(num_anchors*(num_classes+5), (1,1)))(x2)
    
        x2 = compose(
                DarknetConv2D_BN_Leaky(128, (1,1)),
                UpSampling2D(2))(x2)
        y2 = compose(
                Concatenate(),
                DarknetConv2D_BN_Leaky(256, (3,3)),
                DarknetConv2D(num_anchors*(num_classes+5), (1,1)))([x2,x1])
    
        return Model(inputs, [y1,y2])
    
    
    def yolo_head(feats, anchors, num_classes, input_shape, calc_loss=False):
        """Convert final layer features to bounding box parameters."""
        num_anchors = len(anchors)
        # Reshape to batch, height, width, num_anchors, box_params.
        anchors_tensor = K.reshape(K.constant(anchors), [1, 1, 1, num_anchors, 2])
    
        grid_shape = K.shape(feats)[1:3] # height, width
        grid_y = K.tile(K.reshape(K.arange(0, stop=grid_shape[0]), [-1, 1, 1, 1]),
            [1, grid_shape[1], 1, 1])
        grid_x = K.tile(K.reshape(K.arange(0, stop=grid_shape[1]), [1, -1, 1, 1]),
            [grid_shape[0], 1, 1, 1])
        grid = K.concatenate([grid_x, grid_y])
        grid = K.cast(grid, K.dtype(feats))
    
        feats = K.reshape(
            feats, [-1, grid_shape[0], grid_shape[1], num_anchors, num_classes + 5])
    
        # Adjust preditions to each spatial grid point and anchor size.
        box_xy = (K.sigmoid(feats[..., :2]) + grid) / K.cast(grid_shape[::-1], K.dtype(feats))
        box_wh = K.exp(feats[..., 2:4]) * anchors_tensor / K.cast(input_shape[::-1], K.dtype(feats))
        box_confidence = K.sigmoid(feats[..., 4:5])
        box_class_probs = K.sigmoid(feats[..., 5:])
    
        if calc_loss == True:
            return grid, feats, box_xy, box_wh
        return box_xy, box_wh, box_confidence, box_class_probs
    
    
    def yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape):
        '''Get corrected boxes'''
        box_yx = box_xy[..., ::-1]
        box_hw = box_wh[..., ::-1]
        input_shape = K.cast(input_shape, K.dtype(box_yx))
        image_shape = K.cast(image_shape, K.dtype(box_yx))
        new_shape = K.round(image_shape * K.min(input_shape/image_shape))
        offset = (input_shape-new_shape)/2./input_shape
        scale = input_shape/new_shape
        box_yx = (box_yx - offset) * scale
        box_hw *= scale
    
        box_mins = box_yx - (box_hw / 2.)
        box_maxes = box_yx + (box_hw / 2.)
        boxes =  K.concatenate([
            box_mins[..., 0:1],  # y_min
            box_mins[..., 1:2],  # x_min
            box_maxes[..., 0:1],  # y_max
            box_maxes[..., 1:2]  # x_max
        ])
    
        # Scale boxes back to original image shape.
        boxes *= K.concatenate([image_shape, image_shape])
        return boxes
    
    
    def yolo_boxes_and_scores(feats, anchors, num_classes, input_shape, image_shape):
        '''Process Conv layer output'''
        box_xy, box_wh, box_confidence, box_class_probs = yolo_head(feats,
            anchors, num_classes, input_shape)
        boxes = yolo_correct_boxes(box_xy, box_wh, input_shape, image_shape)
        boxes = K.reshape(boxes, [-1, 4])
        box_scores = box_confidence * box_class_probs
        box_scores = K.reshape(box_scores, [-1, num_classes])
        return boxes, box_scores
    
    
    def yolo_eval(yolo_outputs,
                  anchors,
                  num_classes,
                  image_shape,
                  max_boxes=20,
                  score_threshold=.6,
                  iou_threshold=.5):
        """Evaluate YOLO model on given input and return filtered boxes."""
        num_layers = len(yolo_outputs)
        anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]] # default setting
        input_shape = K.shape(yolo_outputs[0])[1:3] * 32
        boxes = []
        box_scores = []
        for l in range(num_layers):
            _boxes, _box_scores = yolo_boxes_and_scores(yolo_outputs[l],
                anchors[anchor_mask[l]], num_classes, input_shape, image_shape)
            boxes.append(_boxes)
            box_scores.append(_box_scores)
        boxes = K.concatenate(boxes, axis=0)
        box_scores = K.concatenate(box_scores, axis=0)
    
        mask = box_scores >= score_threshold
        max_boxes_tensor = K.constant(max_boxes, dtype='int32')
        boxes_ = []
        scores_ = []
        classes_ = []
        for c in range(num_classes):
            # TODO: use keras backend instead of tf.
            class_boxes = tf.boolean_mask(boxes, mask[:, c])
            class_box_scores = tf.boolean_mask(box_scores[:, c], mask[:, c])
            nms_index = tf.image.non_max_suppression(
                class_boxes, class_box_scores, max_boxes_tensor, iou_threshold=iou_threshold)
            class_boxes = K.gather(class_boxes, nms_index)
            class_box_scores = K.gather(class_box_scores, nms_index)
            classes = K.ones_like(class_box_scores, 'int32') * c
            boxes_.append(class_boxes)
            scores_.append(class_box_scores)
            classes_.append(classes)
        boxes_ = K.concatenate(boxes_, axis=0)
        scores_ = K.concatenate(scores_, axis=0)
        classes_ = K.concatenate(classes_, axis=0)
    
        return boxes_, scores_, classes_
    
    
    def preprocess_true_boxes(true_boxes, input_shape, anchors, num_classes):
        '''Preprocess true boxes to training input format
    
        Parameters
        ----------
        true_boxes: array, shape=(m, T, 5)
            Absolute x_min, y_min, x_max, y_max, class_id relative to input_shape.
        input_shape: array-like, hw, multiples of 32
        anchors: array, shape=(N, 2), wh
        num_classes: integer
    
        Returns
        -------
        y_true: list of array, shape like yolo_outputs, xywh are reletive value
    
        '''
        assert (true_boxes[..., 4]<num_classes).all(), 'class id must be less than num_classes'
        num_layers = len(anchors)//3 # default setting
        anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]]
    
        true_boxes = np.array(true_boxes, dtype='float32')
        input_shape = np.array(input_shape, dtype='int32')
        boxes_xy = (true_boxes[..., 0:2] + true_boxes[..., 2:4]) // 2
        boxes_wh = true_boxes[..., 2:4] - true_boxes[..., 0:2]
        true_boxes[..., 0:2] = boxes_xy/input_shape[::-1]
        true_boxes[..., 2:4] = boxes_wh/input_shape[::-1]
    
        m = true_boxes.shape[0]
        grid_shapes = [input_shape//{0:32, 1:16, 2:8}[l] for l in range(num_layers)]
        y_true = [np.zeros((m,grid_shapes[l][0],grid_shapes[l][1],len(anchor_mask[l]),5+num_classes),
            dtype='float32') for l in range(num_layers)]
    
        # Expand dim to apply broadcasting.
        anchors = np.expand_dims(anchors, 0)
        anchor_maxes = anchors / 2.
        anchor_mins = -anchor_maxes
        valid_mask = boxes_wh[..., 0]>0
    
        for b in range(m):
            # Discard zero rows.
            wh = boxes_wh[b, valid_mask[b]]
            if len(wh)==0: continue
            # Expand dim to apply broadcasting.
            wh = np.expand_dims(wh, -2)
            box_maxes = wh / 2.
            box_mins = -box_maxes
    
            intersect_mins = np.maximum(box_mins, anchor_mins)
            intersect_maxes = np.minimum(box_maxes, anchor_maxes)
            intersect_wh = np.maximum(intersect_maxes - intersect_mins, 0.)
            intersect_area = intersect_wh[..., 0] * intersect_wh[..., 1]
            box_area = wh[..., 0] * wh[..., 1]
            anchor_area = anchors[..., 0] * anchors[..., 1]
            iou = intersect_area / (box_area + anchor_area - intersect_area)
    
            # Find best anchor for each true box
            best_anchor = np.argmax(iou, axis=-1)
    
            for t, n in enumerate(best_anchor):
                for l in range(num_layers):
                    if n in anchor_mask[l]:
                        i = np.floor(true_boxes[b,t,0]*grid_shapes[l][1]).astype('int32')
                        j = np.floor(true_boxes[b,t,1]*grid_shapes[l][0]).astype('int32')
                        k = anchor_mask[l].index(n)
                        c = true_boxes[b,t, 4].astype('int32')
                        y_true[l][b, j, i, k, 0:4] = true_boxes[b,t, 0:4]
                        y_true[l][b, j, i, k, 4] = 1
                        y_true[l][b, j, i, k, 5+c] = 1
    
        return y_true
    
    
    def box_iou(b1, b2):
        '''Return iou tensor
    
        Parameters
        ----------
        b1: tensor, shape=(i1,...,iN, 4), xywh
        b2: tensor, shape=(j, 4), xywh
    
        Returns
        -------
        iou: tensor, shape=(i1,...,iN, j)
    
        '''
    
        # Expand dim to apply broadcasting.
        b1 = K.expand_dims(b1, -2)
        b1_xy = b1[..., :2]
        b1_wh = b1[..., 2:4]
        b1_wh_half = b1_wh/2.
        b1_mins = b1_xy - b1_wh_half
        b1_maxes = b1_xy + b1_wh_half
    
        # Expand dim to apply broadcasting.
        b2 = K.expand_dims(b2, 0)
        b2_xy = b2[..., :2]
        b2_wh = b2[..., 2:4]
        b2_wh_half = b2_wh/2.
        b2_mins = b2_xy - b2_wh_half
        b2_maxes = b2_xy + b2_wh_half
    
        intersect_mins = K.maximum(b1_mins, b2_mins)
        intersect_maxes = K.minimum(b1_maxes, b2_maxes)
        intersect_wh = K.maximum(intersect_maxes - intersect_mins, 0.)
        intersect_area = intersect_wh[..., 0] * intersect_wh[..., 1]
        b1_area = b1_wh[..., 0] * b1_wh[..., 1]
        b2_area = b2_wh[..., 0] * b2_wh[..., 1]
        iou = intersect_area / (b1_area + b2_area - intersect_area)
    
        return iou
    
    
    def yolo_loss(args, anchors, num_classes, ignore_thresh=.5, print_loss=False):
        '''Return yolo_loss tensor
    
        Parameters
        ----------
        yolo_outputs: list of tensor, the output of yolo_body or tiny_yolo_body
        y_true: list of array, the output of preprocess_true_boxes
        anchors: array, shape=(N, 2), wh
        num_classes: integer
        ignore_thresh: float, the iou threshold whether to ignore object confidence loss
    
        Returns
        -------
        loss: tensor, shape=(1,)
    
        '''
        num_layers = len(anchors)//3 # default setting
        yolo_outputs = args[:num_layers]
        y_true = args[num_layers:]
        anchor_mask = [[6,7,8], [3,4,5], [0,1,2]] if num_layers==3 else [[3,4,5], [1,2,3]]
        input_shape = K.cast(K.shape(yolo_outputs[0])[1:3] * 32, K.dtype(y_true[0]))
        grid_shapes = [K.cast(K.shape(yolo_outputs[l])[1:3], K.dtype(y_true[0])) for l in range(num_layers)]
        loss = 0
        m = K.shape(yolo_outputs[0])[0] # batch size, tensor
        mf = K.cast(m, K.dtype(yolo_outputs[0]))
    
        for l in range(num_layers):
            object_mask = y_true[l][..., 4:5]
            true_class_probs = y_true[l][..., 5:]
    
            grid, raw_pred, pred_xy, pred_wh = yolo_head(yolo_outputs[l],
                 anchors[anchor_mask[l]], num_classes, input_shape, calc_loss=True)
            pred_box = K.concatenate([pred_xy, pred_wh])
    
            # Darknet raw box to calculate loss.
            raw_true_xy = y_true[l][..., :2]*grid_shapes[l][::-1] - grid
            raw_true_wh = K.log(y_true[l][..., 2:4] / anchors[anchor_mask[l]] * input_shape[::-1])
            raw_true_wh = K.switch(object_mask, raw_true_wh, K.zeros_like(raw_true_wh)) # avoid log(0)=-inf
            box_loss_scale = 2 - y_true[l][...,2:3]*y_true[l][...,3:4]
    
            # Find ignore mask, iterate over each of batch.
            ignore_mask = tf.TensorArray(K.dtype(y_true[0]), size=1, dynamic_size=True)
            object_mask_bool = K.cast(object_mask, 'bool')
            def loop_body(b, ignore_mask):
                true_box = tf.boolean_mask(y_true[l][b,...,0:4], object_mask_bool[b,...,0])
                iou = box_iou(pred_box[b], true_box)
                best_iou = K.max(iou, axis=-1)
                ignore_mask = ignore_mask.write(b, K.cast(best_iou<ignore_thresh, K.dtype(true_box)))
                return b+1, ignore_mask
            _, ignore_mask = K.control_flow_ops.while_loop(lambda b,*args: b<m, loop_body, [0, ignore_mask])
            ignore_mask = ignore_mask.stack()
            ignore_mask = K.expand_dims(ignore_mask, -1)
    
            # K.binary_crossentropy is helpful to avoid exp overflow.
            xy_loss = object_mask * box_loss_scale * K.binary_crossentropy(raw_true_xy, raw_pred[...,0:2], from_logits=True)
            wh_loss = object_mask * box_loss_scale * 0.5 * K.square(raw_true_wh-raw_pred[...,2:4])
            confidence_loss = object_mask * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True)+ \
                (1-object_mask) * K.binary_crossentropy(object_mask, raw_pred[...,4:5], from_logits=True) * ignore_mask
            class_loss = object_mask * K.binary_crossentropy(true_class_probs, raw_pred[...,5:], from_logits=True)
    
            xy_loss = K.sum(xy_loss) / mf
            wh_loss = K.sum(wh_loss) / mf
            confidence_loss = K.sum(confidence_loss) / mf
            class_loss = K.sum(class_loss) / mf
            loss += xy_loss + wh_loss + confidence_loss + class_loss
            if print_loss:
                loss = tf.Print(loss, [loss, xy_loss, wh_loss, confidence_loss, class_loss, K.sum(ignore_mask)], message='loss: ')
        return loss

### 2.utils.py ###

"""Miscellaneous utility functions."""
    
    from functools import reduce
    
    from PIL import Image
    import numpy as np
    from matplotlib.colors import rgb_to_hsv, hsv_to_rgb
    
    def compose(*funcs):
        """Compose arbitrarily many functions, evaluated left to right.
    
        Reference: https://mathieularose.com/function-composition-in-python/
        """
        # return lambda x: reduce(lambda v, f: f(v), funcs, x)
        if funcs:
            return reduce(lambda f, g: lambda *a, **kw: g(f(*a, **kw)), funcs)
        else:
            raise ValueError('Composition of empty sequence not supported.')
    
    def letterbox_image(image, size):
        '''resize image with unchanged aspect ratio using padding'''
        iw, ih = image.size
        w, h = size
        scale = min(w/iw, h/ih)
        nw = int(iw*scale)
        nh = int(ih*scale)
    
        image = image.resize((nw,nh), Image.BICUBIC)
        new_image = Image.new('RGB', size, (128,128,128))
        new_image.paste(image, ((w-nw)//2, (h-nh)//2))
        return new_image
    
    def rand(a=0, b=1):
        return np.random.rand()*(b-a) + a
    
    def get_random_data(annotation_line, input_shape, random=True, max_boxes=20, jitter=.3, hue=.1, sat=1.5, val=1.5, proc_img=True):
        '''random preprocessing for real-time data augmentation'''
        line = annotation_line.split()
        image = Image.open(line[0])
        iw, ih = image.size
        h, w = input_shape
        box = np.array([np.array(list(map(int,box.split(',')))) for box in line[1:]])
    
        if not random:
            # resize image
            scale = min(w/iw, h/ih)
            nw = int(iw*scale)
            nh = int(ih*scale)
            dx = (w-nw)//2
            dy = (h-nh)//2
            image_data=0
            if proc_img:
                image = image.resize((nw,nh), Image.BICUBIC)
                new_image = Image.new('RGB', (w,h), (128,128,128))
                new_image.paste(image, (dx, dy))
                image_data = np.array(new_image)/255.
    
            # correct boxes
            box_data = np.zeros((max_boxes,5))
            if len(box)>0:
                np.random.shuffle(box)
                if len(box)>max_boxes: box = box[:max_boxes]
                box[:, [0,2]] = box[:, [0,2]]*scale + dx
                box[:, [1,3]] = box[:, [1,3]]*scale + dy
                box_data[:len(box)] = box
    
            return image_data, box_data
    
        # resize image
        new_ar = w/h * rand(1-jitter,1+jitter)/rand(1-jitter,1+jitter)
        scale = rand(.25, 2)
        if new_ar < 1:
            nh = int(scale*h)
            nw = int(nh*new_ar)
        else:
            nw = int(scale*w)
            nh = int(nw/new_ar)
        image = image.resize((nw,nh), Image.BICUBIC)
    
        # place image
        dx = int(rand(0, w-nw))
        dy = int(rand(0, h-nh))
        new_image = Image.new('RGB', (w,h), (128,128,128))
        new_image.paste(image, (dx, dy))
        image = new_image
    
        # flip image or not
        flip = rand()<.5
        if flip: image = image.transpose(Image.FLIP_LEFT_RIGHT)
    
        # distort image
        hue = rand(-hue, hue)
        sat = rand(1, sat) if rand()<.5 else 1/rand(1, sat)
        val = rand(1, val) if rand()<.5 else 1/rand(1, val)
        x = rgb_to_hsv(np.array(image)/255.)
        x[..., 0] += hue
        x[..., 0][x[..., 0]>1] -= 1
        x[..., 0][x[..., 0]<0] += 1
        x[..., 1] *= sat
        x[..., 2] *= val
        x[x>1] = 1
        x[x<0] = 0
        image_data = hsv_to_rgb(x) # numpy array, 0 to 1
    
        # correct boxes
        box_data = np.zeros((max_boxes,5))
        if len(box)>0:
            np.random.shuffle(box)
            box[:, [0,2]] = box[:, [0,2]]*nw/iw + dx
            box[:, [1,3]] = box[:, [1,3]]*nh/ih + dy
            if flip: box[:, [0,2]] = w - box[:, [2,0]]
            box[:, 0:2][box[:, 0:2]<0] = 0
            box[:, 2][box[:, 2]>w] = w
            box[:, 3][box[:, 3]>h] = h
            box_w = box[:, 2] - box[:, 0]
            box_h = box[:, 3] - box[:, 1]
            box = box[np.logical_and(box_w>1, box_h>1)] # discard invalid box
            if len(box)>max_boxes: box = box[:max_boxes]
            box_data[:len(box)] = box
    
        return image_data, box_data

### 3.yolo.py ###

# -*- coding: utf-8 -*-
    """
    Class definition of YOLO_v3 style detection model on image and video
    """
    
    import colorsys
    import os
    from timeit import default_timer as timer
    
    import numpy as np
    from keras import backend as K
    from keras.models import load_model
    from keras.layers import Input
    from PIL import Image, ImageFont, ImageDraw
    
    from yolo3.model import yolo_eval, yolo_body, tiny_yolo_body
    from yolo3.utils import letterbox_image
    import os
    from keras.utils import multi_gpu_model
    
    class YOLO(object):
        _defaults = {
            "model_path": 'logs/000/trained_weights_final.h5', #保存模型路径
            "anchors_path": 'model_data/yolo_anchors.txt',
            "classes_path": 'model_data/voc_classes.txt',
            "score" : 0.3,
            "iou" : 0.45,
            "model_image_size" : (416, 416), #一般设定
            "gpu_num" : 1, #根据自己的设定
        }
    
        @classmethod
        def get_defaults(cls, n):
            if n in cls._defaults:
                return cls._defaults[n]
            else:
                return "Unrecognized attribute name '" + n + "'"
    
        def __init__(self, **kwargs):
            self.__dict__.update(self._defaults) # set up default values
            self.__dict__.update(kwargs) # and update with user overrides
            self.class_names = self._get_class()
            self.anchors = self._get_anchors()
            self.sess = K.get_session()
            self.boxes, self.scores, self.classes = self.generate()
    
        def _get_class(self):
            classes_path = os.path.expanduser(self.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(self):
            anchors_path = os.path.expanduser(self.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 generate(self):
            model_path = os.path.expanduser(self.model_path)
            assert model_path.endswith('.h5'), 'Keras model or weights must be a .h5 file.'
    
            # Load model, or construct model and load weights.
            num_anchors = len(self.anchors)
            num_classes = len(self.class_names)
            is_tiny_version = num_anchors==6 # default setting
            try:
                self.yolo_model = load_model(model_path, compile=False)
            except:
                self.yolo_model = tiny_yolo_body(Input(shape=(None,None,3)), num_anchors//2, num_classes) \
                    if is_tiny_version else yolo_body(Input(shape=(None,None,3)), num_anchors//3, num_classes)
                self.yolo_model.load_weights(self.model_path) # make sure model, anchors and classes match
            else:
                assert self.yolo_model.layers[-1].output_shape[-1] == \
                    num_anchors/len(self.yolo_model.output) * (num_classes + 5), \
                    'Mismatch between model and given anchor and class sizes'
    
            print('{} model, anchors, and classes loaded.'.format(model_path))
    
            # Generate colors for drawing bounding boxes.
            hsv_tuples = [(x / len(self.class_names), 1., 1.)
                          for x in range(len(self.class_names))]
            self.colors = list(map(lambda x: colorsys.hsv_to_rgb(*x), hsv_tuples))
            self.colors = list(
                map(lambda x: (int(x[0] * 255), int(x[1] * 255), int(x[2] * 255)),
                    self.colors))
            np.random.seed(10101)  # Fixed seed for consistent colors across runs.
            np.random.shuffle(self.colors)  # Shuffle colors to decorrelate adjacent classes.
            np.random.seed(None)  # Reset seed to default.
    
            # Generate output tensor targets for filtered bounding boxes.
            self.input_image_shape = K.placeholder(shape=(2, ))
            if self.gpu_num>=2:
                self.yolo_model = multi_gpu_model(self.yolo_model, gpus=self.gpu_num)
            boxes, scores, classes = yolo_eval(self.yolo_model.output, self.anchors,
                    len(self.class_names), self.input_image_shape,
                    score_threshold=self.score, iou_threshold=self.iou)
            return boxes, scores, classes
    
        def detect_image(self, image):
            start = timer()
    
            if self.model_image_size != (None, None):
                assert self.model_image_size[0]%32 == 0, 'Multiples of 32 required'
                assert self.model_image_size[1]%32 == 0, 'Multiples of 32 required'
                boxed_image = letterbox_image(image, tuple(reversed(self.model_image_size)))
            else:
                new_image_size = (image.width - (image.width % 32),
                                  image.height - (image.height % 32))
                boxed_image = letterbox_image(image, new_image_size)
            image_data = np.array(boxed_image, dtype='float32')
    
            print(image_data.shape)
            image_data /= 255.
            image_data = np.expand_dims(image_data, 0)  # Add batch dimension.
    
            out_boxes, out_scores, out_classes = self.sess.run(
                [self.boxes, self.scores, self.classes],
                feed_dict={
                    self.yolo_model.input: image_data,
                    self.input_image_shape: [image.size[1], image.size[0]],
                    K.learning_phase(): 0
                })
            output = [out_boxes, out_scores, out_classes]
            print('Found {} boxes for {}'.format(len(out_boxes), 'img'))
    
            font = ImageFont.truetype(font='font/FiraMono-Medium.otf',
                        size=np.floor(3e-2 * image.size[1] + 0.5).astype('int32'))
            thickness = (image.size[0] + image.size[1]) // 100
    
            for i, c in reversed(list(enumerate(out_classes))):
                predicted_class = self.class_names[c]
                box = out_boxes[i]
                score = out_scores[i]
    
                label = '{} {:.2f}'.format(predicted_class, score)
                draw = ImageDraw.Draw(image)
                label_size = draw.textsize(label, font)
    
                top, left, bottom, right = box
                top = max(0, np.floor(top + 0.5).astype('int32'))
                left = max(0, np.floor(left + 0.5).astype('int32'))
                bottom = min(image.size[1], np.floor(bottom + 0.5).astype('int32'))
                right = min(image.size[0], np.floor(right + 0.5).astype('int32'))
                print(label, (left, top), (right, bottom))
    
                if top - label_size[1] >= 0:
                    text_origin = np.array([left, top - label_size[1]])
                else:
                    text_origin = np.array([left, top + 1])
    
                # My kingdom for a good redistributable image drawing library.
                for i in range(thickness):
                    draw.rectangle(
                        [left + i, top + i, right - i, bottom - i],
                        outline=self.colors[c])
                draw.rectangle(
                    [tuple(text_origin), tuple(text_origin + label_size)],
                    fill=self.colors[c])
                draw.text(text_origin, label, fill=(0, 0, 0), font=font)
                del draw
    
            end = timer()
            print(end - start)
            return image, output
    
        def close_session(self):
            self.sess.close()
    
    def detect_video(yolo, video_path, output_path=""):
        import cv2
        vid = cv2.VideoCapture(video_path)
        if not vid.isOpened():
            raise IOError("Couldn't open webcam or video")
        video_FourCC    = int(vid.get(cv2.CAP_PROP_FOURCC))
        video_fps       = vid.get(cv2.CAP_PROP_FPS)
        video_size      = (int(vid.get(cv2.CAP_PROP_FRAME_WIDTH)),
                            int(vid.get(cv2.CAP_PROP_FRAME_HEIGHT)))
        isOutput = True if output_path != "" else False
        if isOutput:
            print("!!! TYPE:", type(output_path), type(video_FourCC), type(video_fps), type(video_size))
            out = cv2.VideoWriter(output_path, video_FourCC, video_fps, video_size)
        accum_time = 0
        curr_fps = 0
        fps = "FPS: ??"
        prev_time = timer()
        while True:
            return_value, frame = vid.read()
            image = Image.fromarray(frame)
            image,output = yolo.detect_image(image)
            result = np.asarray(image)
            curr_time = timer()
            exec_time = curr_time - prev_time
            prev_time = curr_time
            accum_time = accum_time + exec_time
            curr_fps = curr_fps + 1
            if accum_time > 1:
                accum_time = accum_time - 1
                fps = "FPS: " + str(curr_fps)
                curr_fps = 0
            cv2.putText(result, text=fps, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX,
                        fontScale=0.50, color=(255, 0, 0), thickness=2)
            cv2.namedWindow("result", cv2.WINDOW_NORMAL)
            cv2.imshow("result", result)
            if isOutput:
                out.write(result)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        yolo.close_session()
    
    
    def detect_camera(yolo, camera_id):
        import cv2
        cap = cv2.VideoCapture(0)
        cap.set(3,640)
        cap.set(4,480)
        if cap.isOpened():
            print('camera open successfully!')
        else:
            raise IOError("Couldn't open camera!")
        accum_time = 0
        curr_fps = 0
        fps = "FPS: ??"
        prev_time = timer()
        while True:
            return_value, frame = cap.read()
            image = Image.fromarray(frame)
            image,output = yolo.detect_image(image)
            result = np.asarray(image)
            curr_time = timer()
            exec_time = curr_time - prev_time
            prev_time = curr_time
            accum_time = accum_time + exec_time
            curr_fps = curr_fps + 1
            if accum_time > 1:
                accum_time = accum_time - 1
                fps = "FPS: " + str(curr_fps)
                curr_fps = 0
            cv2.putText(result, text=fps, org=(3, 15), fontFace=cv2.FONT_HERSHEY_SIMPLEX,
                        fontScale=0.50, color=(255, 0, 0), thickness=2)
            cv2.namedWindow("result", cv2.WINDOW_NORMAL)
            cv2.imshow("result", result)
            if cv2.waitKey(1) & 0xFF == ord('q'):
                break
        yolo.close_session()

### 4.训练文件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.optimizers import Adam
    from keras.callbacks import TensorBoard, ModelCheckpoint, ReduceLROnPlateau, 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)
        num_classes = len(class_names)
        anchors = get_anchors(anchors_path)
    
        input_shape = (416,416) # multiple of 32, hw
    
        is_tiny_version = len(anchors)==6 # default setting
        if is_tiny_version:
            model = create_tiny_model(input_shape, anchors, num_classes,
                freeze_body=2, weights_path='model_data/yolo-tiny.h5')
        else:
            model = create_model(input_shape, anchors, num_classes,
                freeze_body=2, weights_path='model_data/yolo.h5') # make sure you know what you freeze
    
        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=3)
        reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.1, patience=3, verbose=1)
        early_stopping = EarlyStopping(monitor='val_loss', min_delta=0, patience=10, verbose=1)
    
        val_split = 0.1
        with open(annotation_path) as f:
            lines = f.readlines()
        np.random.seed(10101)
        np.random.shuffle(lines)
        np.random.seed(None)
        num_val = int(len(lines)*val_split)
        num_train = len(lines) - num_val
    
        # Train with frozen layers first, to get a stable loss.
        # Adjust num epochs to your dataset. This step is enough to obtain a not bad model.
        if True:
            model.compile(optimizer=Adam(lr=1e-3), loss={
                # use custom yolo_loss Lambda layer.
                'yolo_loss': lambda y_true, y_pred: y_pred})
    
            batch_size = 5
            print('Train on {} samples, val on {} samples, with batch size {}.'.format(num_train, num_val, batch_size))
            model.fit_generator(data_generator_wrapper(lines[:num_train], batch_size, input_shape, anchors, num_classes),
                    steps_per_epoch=max(1, num_train//batch_size),
                    validation_data=data_generator_wrapper(lines[num_train:], batch_size, input_shape, anchors, num_classes),
                    validation_steps=max(1, num_val//batch_size),
                    epochs=50,
                    initial_epoch=0,
                    callbacks=[logging, checkpoint])
            model.save_weights(log_dir + 'trained_weights_stage_1.h5')
    
        # Unfreeze and continue training, to fine-tune.
        # Train longer if the result is not good.
        if True:
            for i in range(len(model.layers)):
                model.layers[i].trainable = True
            model.compile(optimizer=Adam(lr=1e-4), loss={'yolo_loss': lambda y_true, y_pred: y_pred}) # recompile to apply the change
            print('Unfreeze all of the layers.')
    
            batch_size = 5 # note that more GPU memory is required after unfreezing the body
            print('Train on {} samples, val on {} samples, with batch size {}.'.format(num_train, num_val, batch_size))
            model.fit_generator(data_generator_wrapper(lines[:num_train], batch_size, input_shape, anchors, num_classes),
                steps_per_epoch=max(1, num_train//batch_size),
                validation_data=data_generator_wrapper(lines[num_train:], batch_size, input_shape, anchors, num_classes),
                validation_steps=max(1, num_val//batch_size),
                epochs=200,
                initial_epoch=50,
                callbacks=[logging, checkpoint, reduce_lr, early_stopping])
            model.save_weights(log_dir + 'trained_weights_final.h5')
    
        # Further training if needed.
    
    
    def get_classes(classes_path):
        '''loads the classes'''
        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):
        '''loads the anchors from a file'''
        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=True, freeze_body=2,
                weights_path='model_data/yolo_weights.h5'):
        '''create the training model'''
        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 in [1, 2]:
                # Freeze darknet53 body or freeze all but 3 output layers.
                num = (185, len(model_body.layers)-3)[freeze_body-1]
                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 create_tiny_model(input_shape, anchors, num_classes, load_pretrained=True, freeze_body=2,
                weights_path='model_data/tiny_yolo_weights.h5'):
        '''create the training model, for Tiny YOLOv3'''
        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}[l], w//{0:32, 1:16}[l], \
            num_anchors//2, num_classes+5)) for l in range(2)]
    
        model_body = tiny_yolo_body(image_input, num_anchors//2, num_classes)
        print('Create Tiny 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 in [1, 2]:
                # Freeze the darknet body or freeze all but 2 output layers.
                num = (20, len(model_body.layers)-2)[freeze_body-1]
                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.7})(
            [*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):
        '''data generator for fit_generator'''
        n = len(annotation_lines)
        i = 0
        while True:
            image_data = []
            box_data = []
            for b in range(batch_size):
                if i==0:
                    np.random.shuffle(annotation_lines)
                image, box = get_random_data(annotation_lines[i], input_shape, random=True)
                image_data.append(image)
                box_data.append(box)
                i = (i+1) % n
            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_wrapper(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()

# 图片测试 #

import sys
    import argparse
    from yolo import YOLO, detect_video, detect_camera
    from PIL import Image
    
    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, output = yolo.detect_image(image)
                r_image.show()
        yolo.close_session()
    
    FLAGS = None
    
    if __name__ == '__main__':
        # class YOLO defines the default value, so suppress any default here
        parser = argparse.ArgumentParser(argument_default=argparse.SUPPRESS)
        '''
        Command line options
        '''
        parser.add_argument(
            '--model', type=str,
            help='path to model weight file, default ' + YOLO.get_defaults("model_path")
        )
    
        parser.add_argument(
            '--anchors', type=str,
            help='path to anchor definitions, default ' + YOLO.get_defaults("anchors_path")
        )
    
        parser.add_argument(
            '--classes', type=str,
            help='path to class definitions, default ' + YOLO.get_defaults("classes_path")
        )
    
        parser.add_argument(
            '--gpu_num', type=int,
            help='Number of GPU to use, default ' + str(YOLO.get_defaults("gpu_num"))
        )
        '''
        Command line positional arguments -- for image detection mode
        '''
        parser.add_argument(
            '--image', default=False, action="store_true",
            help='Image detection mode, will ignore all positional arguments'
        )
        '''
        Command line positional arguments -- for video detection mode
        '''
        parser.add_argument(
            "--video_input", nargs='?', type=str, default=False,
            help = "Video input path"
        )
    
        parser.add_argument(
            "--video_output", nargs='?', type=str, default="",
            help = "[Optional] Video output path"
        )
        '''
        Command line positional arguments -- for camera real-time detection mode
        '''
        parser.add_argument(
            "--camera", type=str, default='0',
            help = "camera id"
        )
    
    
        FLAGS = parser.parse_args()
    
        if FLAGS.image:
            """
            Image detection mode, disregard any remaining command line arguments
            """
            print("Image detection mode")
            if "input" in FLAGS:
                print(" Ignoring remaining command line arguments: " + FLAGS.input + "," + FLAGS.output)
            detect_img(YOLO(**vars(FLAGS)))
        if FLAGS.video_input:
            detect_video(YOLO(**vars(FLAGS)), FLAGS.video_input, FLAGS.video_output)
        if FLAGS.camera:
            detect_camera(YOLO(**vars(FLAGS)), int(FLAGS.camera))
        else:
            print("Must specify at least video_input_path.  See usage with --help.")

# 针对训练集进行验证 #

import os
    from yolo import YOLO, detect_video, detect_camera
    from PIL import Image
    
    def main():
        yolo = YOLO()
        with open('2007_test.txt', 'r') as f:
            lines = f.readlines()   
        pic = [t.strip('\n') for t in lines]
    
        with open('model_data\\voc_classes.txt') as f:
            class_names = f.readlines()
        class_names = [c.strip('\n') for c in class_names]
        for i in range(len(pic)):
            f1 = open('Object-Detection-Metrics-master/groundtruths/2007_'+pic[i].split('.')[0].split('/')[-1]+'.txt' , 'w')
            for j in range(len(pic[i].split(' '))):
                if j>0:
                    class_name = class_names[int(pic[i].split(' ')[j].split(',')[-1])]
                    box = pic[i].split(' ')[j].split(',')[0]+' '+pic[i].split(' ')[j].split(',')[1]+' '+pic[i].split(' ')[j].split(',')[2]+' '+pic[i].split(' ')[j].split(',')[3]+'\n'
                    content = class_name+' '+box
                    f1.write(content)
            f1.close()
    
            image = Image.open(pic[i].split(' ')[0])
            r_image, output = yolo.detect_image(image)
    
            f2 = open('Object-Detection-Metrics-master/detections/2007_'+pic[i].split('.')[0].split('/')[-1]+'.txt' , 'w')
            for i, c in reversed(list(enumerate(output[2]))):
                box = output[0][i]
                score = output[1][i]
                top, left, bottom, right = box
                content = '%s %.5f %d %d %d %d\n'%(class_names[c], score, left, top, right, bottom)
                f2.write(content)
            f2.close()
    
    
    if __name__=='__main__':
        main()

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3pob25nbG9uZ3NoZW4_size_16_color_FFFFFF_t_70]: /images/20221119/b462b16ffc7842ba8fd4d9603b1a917c.png