YoloV1

Keras框架实现

下载原始darknet的权重

  1. http://pjreddie.com/media/files/yolov1/tiny-yolov1.weights

将darknet模型转为keras模型

  1. """
  2. Reads Darknet config and weights and creates Keras models with TF backend.
  3. Currently only supports layers in Yolov1-tiny config.
  4. """
  6. import argparse
  7. import configparser
  8. import io
  9. import os
  10. from collections import defaultdict
  12. import numpy as np
  13. import tensorflow.keras.backend as K
  14. from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Dense, Flatten, Dropout, Reshape, LeakyReLU, ReLU, BatchNormalization
  15. from tensorflow.keras import Model
  16. from tensorflow.keras.regularizers import l2
  19. def unique_config_sections(config_file):
  20.     """
  21.     将配置文件所有的节点生成独一无二的名字，添加到每一个节点后边
  22.     """
  23.     section_counters = defaultdict(int)
  24.     output_stream = io.StringIO()
  25.     with open(config_file) as fin:
  26.         for line in fin:
  27.             if line.startswith('['):
  28.                 section = line.strip().strip('[]')
  29.                 # 添加新的后缀
  30.                 _section = section + '_' + str(section_counters[section])
  31.                 # 同一前缀的后缀加1
  32.                 section_counters[section] += 1
  33.                 # 用新的节点名字替换原有的节点名字
  34.                 line = line.replace(section, _section)
  35.             output_stream.write(line)
  36.     output_stream.seek(0)
  37.     return output_stream
  40. def main(args):
  41.     config_path = os.path.expanduser(args.config_path)
  42.     weights_path = os.path.expanduser(args.weights_path)
  43.     output_path = os.path.expanduser(args.output_path)
  44.     assert config_path.endswith('.cfg'), '{} is not a .cfg file'.format(config_path)
  45.     assert weights_path.endswith('.weights'), '{} is not a .weights file'.format(weights_path)
  46.     assert output_path.endswith('.hdf5'), 'output path {} is not a .hdf5 file'.format(output_path)
  48.     # Load weights and config.
  49.     print('加载darknet的权重...')
  50.     weights_file = open(weights_path, 'rb')
  51.     # 读取darknet网络权重的头部信息
  52.     weights_header = np.ndarray(shape=(4,), dtype='int32', buffer=weights_file.read(16))
  53.     print('darknet网络权重的头部信息：', weights_header)
  55.     print('解析Darknet配置文件')
  56.     unique_config_file = unique_config_sections(config_path)
  57.     cfg_parser = configparser.ConfigParser()
  58.     cfg_parser.read_file(unique_config_file)
  60.     print('开始生成Keras网络模型...')
  61.     try:
  62.         image_height = int(cfg_parser['crop_0']['crop_height'])
  63.         image_width = int(cfg_parser['crop_0']['crop_width'])
  64.     except KeyError:
  65.         image_height = int(cfg_parser['net_0']['height'])
  66.         image_width = int(cfg_parser['net_0']['width'])
  68.     # 定义输入层
  69.     prev_layer = Input(shape=(image_height, image_width, 3))
  70.     all_layers = [prev_layer]
  71.     # 权重衰减（目的不是为了提高精度或者提高速度，而是防止过拟合）
  72.     weight_decay = float(cfg_parser['net_0']['decay']) if 'net_0' in cfg_parser.sections() else 5e-4
  74.     count = 0
  75.     fc_flag = False
  76.     for section in cfg_parser.sections():
  77.         print('正在解析节点： {}'.format(section))
  78.         # 解析卷积相关
  79.         if section.startswith('convolutional'):
  80.             filters = int(cfg_parser[section]['filters'])
  81.             size = int(cfg_parser[section]['size'])
  82.             stride = int(cfg_parser[section]['stride'])
  83.             pad = int(cfg_parser[section]['pad'])
  84.             activation = cfg_parser[section]['activation']
  85.             batch_normalize = 'batch_normalize' in cfg_parser[section]
  87.             # padding='same' is equivalent to Darknet pad=1
  88.             padding = 'same' if pad == 1 else 'valid'
  90.             # Setting weights.
  91.             # Darknet serializes convolutional weights as:
  92.             # [bias/beta, [gamma, mean, variance], conv_weights]
  93.             # 获取上一层的形状
  94.             prev_layer_shape = K.int_shape(prev_layer)
  96.             # TODO: This assumes channel last dim_ordering.
  97.             # keras设计成channel last,而darknet是channel first
  98.             weights_shape = (size, size, prev_layer_shape[-1], filters)
  99.             darknet_w_shape = (filters, weights_shape[2], size, size)
  100.             # 参数个数
  101.             weights_size = np.product(weights_shape)
  103.             print('conv2d', 'bn' if batch_normalize else '  ', activation, weights_shape)
  105.             conv_bias = np.ndarray(shape=(filters,), dtype='float32', buffer=weights_file.read(filters * 4))
  106.             count += filters
  108.             bn_weight_list = []
  109.             if batch_normalize:
  110.                 bn_weights = np.ndarray(shape=(3, filters), dtype='float32', buffer=weights_file.read(filters * 12))
  111.                 count += 3 * filters
  113.                 # TODO: Keras BatchNormalization mistakenly refers to var
  114.                 # as std.
  115.                 bn_weight_list = [
  116.                     bn_weights[0],  # scale gamma
  117.                     conv_bias,  # shift beta
  118.                     bn_weights[1],  # running mean
  119.                     bn_weights[2]  # running var
  120.                 ]
  122.             conv_weights = np.ndarray(
  123.                 shape=darknet_w_shape,
  124.                 dtype='float32',
  125.                 buffer=weights_file.read(weights_size * 4))
  126.             count += weights_size
  128.             # DarkNet conv_weights are serialized Caffe-style:
  129.             # (out_dim, in_dim, height, width)
  130.             # We would like to set these to Tensorflow order:
  131.             # (height, width, in_dim, out_dim)
  132.             # TODO: Add check for Theano dim ordering.
  133.             conv_weights = np.transpose(conv_weights, [2, 3, 1, 0])
  134.             conv_weights = [conv_weights] if batch_normalize \
  135.                 else [conv_weights, conv_bias]
  137.             # Handle activation.
  138.             act_fn = None
  139.             if activation == 'leaky':
  140.                 pass  # Add advanced activation later.
  141.             elif activation == 'relu':
  142.                 pass
  143.             elif activation != 'linear':
  144.                 raise ValueError(
  145.                     'Unknown activation function `{}` in section {}'.format(
  146.                         activation, section))
  148.             # Create Conv2D layer
  149.             conv_layer = Conv2D(
  150.                 filters, (size, size),
  151.                 strides=(stride, stride),
  152.                 kernel_regularizer=l2(weight_decay),
  153.                 use_bias=not batch_normalize,
  154.                 weights=conv_weights,
  155.                 activation=act_fn,
  156.                 padding=padding,
  157.                 name=format(section))(prev_layer)
  159.             if batch_normalize:
  160.                 conv_layer = BatchNormalization(
  161.                     weights=bn_weight_list,
  162.                     name='bn' + format(section))(conv_layer)
  164.             prev_layer = conv_layer
  166.             if activation == 'linear':
  167.                 all_layers.append(prev_layer)
  168.             elif activation == 'leaky':
  169.                 act_layer = LeakyReLU(alpha=0.1)(prev_layer)
  170.                 prev_layer = act_layer
  171.                 all_layers.append(act_layer)
  172.             elif activation == 'relu':
  173.                 act_layer = ReLU()(prev_layer)
  174.                 prev_layer = act_layer
  175.                 all_layers.append(act_layer)
  176.         # 解析池化相关
  177.         elif section.startswith('maxpool'):
  178.             size = int(cfg_parser[section]['size'])
  179.             stride = int(cfg_parser[section]['stride'])
  180.             all_layers.append(
  181.                 MaxPooling2D(
  182.                     padding='same',
  183.                     pool_size=(size, size),
  184.                     strides=(stride, stride))(prev_layer))
  185.             prev_layer = all_layers[-1]
  186.         # 解析连接相关
  187.         elif section.startswith('connected'):
  188.             output_size = int(cfg_parser[section]['output'])
  189.             activation = cfg_parser[section]['activation']
  191.             prev_layer_shape = K.int_shape(prev_layer)
  193.             # TODO: This assumes channel last dim_ordering.
  194.             weights_shape = (np.prod(prev_layer_shape[1:]), output_size)
  195.             darknet_w_shape = (output_size, weights_shape[0])
  196.             weights_size = np.product(weights_shape)
  198.             print('full-connected', activation, weights_shape)
  200.             fc_bias = np.ndarray(
  201.                 shape=(output_size,),
  202.                 dtype='float32',
  203.                 buffer=weights_file.read(output_size * 4))
  204.             count += output_size
  206.             fc_weights = np.ndarray(
  207.                 shape=darknet_w_shape,
  208.                 dtype='float32',
  209.                 buffer=weights_file.read(weights_size * 4))
  210.             count += weights_size
  212.             # DarkNet fc_weights are serialized Caffe-style:
  213.             # (out_dim, in_dim)
  214.             # We would like to set these to Tensorflow order:
  215.             # (in_dim, out_dim)
  216.             # TODO: Add check for Theano dim ordering.
  217.             fc_weights = np.transpose(fc_weights, [1, 0])
  218.             fc_weights = [fc_weights, fc_bias]
  220.             # Handle activation.
  221.             act_fn = None
  222.             if activation == 'leaky':
  223.                 pass  # Add advanced activation later.
  224.             elif activation == 'relu':
  225.                 pass
  226.             elif activation != 'linear':
  227.                 raise ValueError(
  228.                     'Unknown activation function `{}` in section {}'.format(
  229.                         activation, section))
  231.             if not fc_flag:
  232.                 prev_layer = Flatten()(prev_layer)
  233.                 fc_flag = True
  235.             # Create Full-Connect layer
  236.             fc_layer = Dense(
  237.                 output_size,
  238.                 kernel_regularizer=l2(weight_decay),
  239.                 weights=fc_weights,
  240.                 activation=act_fn,
  241.                 name=format(section))(prev_layer)
  243.             prev_layer = fc_layer
  245.             if activation == 'linear':
  246.                 all_layers.append(prev_layer)
  247.             elif activation == 'leaky':
  248.                 act_layer = LeakyReLU(alpha=0.1)(prev_layer)
  249.                 prev_layer = act_layer
  250.                 all_layers.append(act_layer)
  251.             elif activation == 'relu':
  252.                 act_layer = ReLU()(prev_layer)
  253.                 prev_layer = act_layer
  254.                 all_layers.append(act_layer)
  255.         # 解析dropout相关
  256.         elif section.startswith('dropout'):
  257.             probability = float(cfg_parser[section]['probability'])
  258.             dropout_layer = Dropout(probability)(prev_layer)
  259.             prev_layer = dropout_layer
  260.             all_layers.append(prev_layer)
  261.         # 解析目标检测相关
  262.         elif section.startswith('detection'):
  263.             classes = int(cfg_parser[section]['classes'])
  264.             coords = int(cfg_parser[section]['coords'])
  265.             rescore = int(cfg_parser[section]['rescore'])
  266.             side = int(cfg_parser[section]['side'])
  267.             num = int(cfg_parser[section]['num'])
  268.             reshape_layer = Reshape(
  269.                 (side, side, classes + num * (coords + rescore))
  270.             )(prev_layer)
  271.             prev_layer = reshape_layer
  272.             all_layers.append(prev_layer)
  273.         # net、crop、detection、softmax不解析
  274.         elif (section.startswith('net') or
  275.               section.startswith('crop') or
  276.               section.startswith('detection') or
  277.               section.startswith('softmax')):
  278.             pass  # Configs not currently handled during models definition.
  279.         # 异常节点抛出
  280.         else:
  281.             raise ValueError('不支持节点类型: {}'.format(section))
  283.     # 创建keras的model
  284.     model = Model(inputs=all_layers[0], outputs=all_layers[-1])
  285.     print("keras的model简要内容：")
  286.     model.summary()
  288.     # 保存model的权值
  289.     model.save_weights('{}'.format(output_path))
  290.     print('Saved Keras models to {}'.format(output_path))
  292.     # 读取darknet剩余的权值
  293.     remaining_weights = len(weights_file.read()) / 4
  294.     # 关闭流
  295.     weights_file.close()
  296.     print('Read {} of {} from Darknet weights.'.format(count, count + remaining_weights))
  297.     if remaining_weights > 0:
  298.         print('Warning: {} unused weights'.format(remaining_weights))
  301. if __name__ == '__main__':
  302.     parser = argparse.ArgumentParser(description='Darknet Yolov1-tiny To Keras Converter.')
  303.     parser.add_argument('config_path', help='Path to Darknet cfg file.')
  304.     parser.add_argument('weights_path', help='Path to Darknet weights file.')
  305.     parser.add_argument('output_path', help='Path to output Keras models file.')
  307.     # main(parser.parse_args())
  308.     main(parser.parse_args(['cfg/yolov1-tiny.cfg', 'weights/tiny-yolov1.weights', 'weights/tiny-yolov1.hdf5']))

Voc数据集转为Keras适用的形式

  1. import argparse
  2. import xml.etree.ElementTree as ElTr
  3. import os
  5. # 数据集
  6. sets = [('2007', 'train'), ('2007', 'val'), ('2007', 'test')]
  8. classes_num = {
  9.     'aeroplane': 0,
  10.     'bicycle': 1,
  11.     'bird': 2,
  12.     'boat': 3,
  13.     'bottle': 4,
  14.     'bus': 5,
  15.     'car': 6,
  16.     'cat': 7,
  17.     'chair': 8,
  18.     'cow': 9,
  19.     'diningtable': 10,
  20.     'dog': 11,
  21.     'horse': 12,
  22.     'motorbike': 13,
  23.     'person': 14,
  24.     'pottedplant': 15,
  25.     'sheep': 16,
  26.     'sofa': 17,
  27.     'train': 18,
  28.     'tvmonitor': 19
  29. }
  32. def convert_annotation(annotation_dir, year, image_id, f):
  33.     # 获取文件的标注内容
  34.     in_file = os.path.join(annotation_dir, 'VOC%s/Annotations/%s.xml' % (year, image_id))
  36.     tree = ElTr.parse(in_file)
  37.     root = tree.getroot()
  39.     # 获取标注xml文件中所有的object节点
  40.     for obj in root.iter('object'):
  41.         # 目标识别难度
  42.         difficult = obj.find('difficult').text
  43.         # 类别名称
  44.         cls = obj.find('name').text
  45.         # 全部的类别
  46.         classes = list(classes_num.keys())
  47.         # 如果object不在分类类比中或者识别难度等于1，则不用于训练
  48.         if cls not in classes or int(difficult) == 1:
  49.             continue
  50.         # 类别映射号码
  51.         cls_id = classes.index(cls)
  52.         # 获取object的边界
  53.         xml_box = obj.find('bndbox')
  54.         b = (int(xml_box.find('xmin').text), int(xml_box.find('ymin').text),
  55.              int(xml_box.find('xmax').text), int(xml_box.find('ymax').text))
  56.         f.write(' ' + ','.join([str(a) for a in b]) + ',' + str(cls_id))
  59. def main(args):
  60.     data_dir = os.path.expanduser(args.dir)
  62.     for year, image_set in sets:
  63.         # 读取训练集的文件编号
  64.         with open(os.path.join(data_dir, 'VOC%s/ImageSets/Main/%s.txt' % (year, image_set)), 'r') as f:
  65.             image_ids = f.read().strip().split()
  66.         # 获取训练数据的具体路径
  67.         with open(os.path.join(data_dir, '%s_%s.txt' % (year, image_set)), 'w') as f:
  68.             for image_id in image_ids:
  69.                 f.write('%s/VOC%s/JPEGImages/%s.jpg' % (data_dir, year, image_id))
  70.                 convert_annotation(data_dir, year, image_id, f)
  71.                 f.write('\n')
  74. if __name__ == '__main__':
  75.     parser = argparse.ArgumentParser(description='Build Annotations.')
  76.     parser.add_argument('dir', default='..', help='Annotations.')
  77.     main(parser.parse_args(['data/VOCdevkit']))