YoloV3-生成anchors 和制作数据集

利用以下代码生成YOLOV3的anchors

# -*- coding: utf-8 -*-
import numpy as np
import random
import argparse
import os
#参数名称
parser = argparse.ArgumentParser(description='使用该脚本生成YOLO-V3的anchor boxes\n')
parser.add_argument('--input_annotation_txt_dir',required=True,type=str,help='输入存储图片的标注txt文件(注意不要有中文)')
parser.add_argument('--output_anchors_txt',required=True,type=str,help='输出的存储Anchor boxes的文本文件')
parser.add_argument('--input_num_anchors',required=True,default=6,type=int,help='输入要计算的聚类（Anchor boxes的个数）')
parser.add_argument('--input_cfg_width',required=True,type=int,help="配置文件中width")
parser.add_argument('--input_cfg_height',required=True,type=int,help="配置文件中height")
args = parser.parse_args()
'''
centroids 聚类点 尺寸是 numx2,类型是ndarray
annotation_array 其中之一的标注框
'''
def IOU(annotation_array,centroids):
    #
    similarities = []
    #其中一个标注框
    w,h = annotation_array
    for centroid in centroids:
        c_w,c_h = centroid
        if c_w >=w and c_h >= h:#第1中情况
            similarity = w*h/(c_w*c_h)
        elif c_w >= w and c_h <= h:#第2中情况
            similarity = w*c_h/(w*h + (c_w - w)*c_h)
        elif c_w <= w and c_h >= h:#第3种情况
            similarity = c_w*h/(w*h +(c_h - h)*c_w)
        else:#第3种情况
            similarity = (c_w*c_h)/(w*h)
        similarities.append(similarity)
    #将列表转换为ndarray
    return np.array(similarities,np.float32) #返回的是一维数组，尺寸为(num,)

'''
k_means:k均值聚类
annotations_array 所有的标注框的宽高，N个标注框，尺寸是Nx2,类型是ndarray
centroids 聚类点 尺寸是 numx2,类型是ndarray
'''
def k_means(annotations_array,centroids,eps=0.00005,iterations=200000):
    #
    N = annotations_array.shape[0]#C=2
    num = centroids.shape[0]
    #损失函数
    distance_sum_pre = -1
    assignments_pre = -1*np.ones(N,dtype=np.int64)
    #
    iteration = 0
    #循环处理
    while(True):
        #
        iteration += 1
        #
        distances = []
        #循环计算每一个标注框与所有的聚类点的距离（IOU）
        for i in range(N):
            distance = 1 - IOU(annotations_array[i],centroids)
            distances.append(distance)
        #列表转换成ndarray
        distances_array = np.array(distances,np.float32)#该ndarray的尺寸为 Nxnum
        #找出每一个标注框到当前聚类点最近的点
        assignments = np.argmin(distances_array,axis=1)#计算每一行的最小值的位置索引
        #计算距离的总和，相当于k均值聚类的损失函数
        distances_sum = np.sum(distances_array)
        #计算新的聚类点
        centroid_sums = np.zeros(centroids.shape,np.float32)
        for i in range(N):
            centroid_sums[assignments[i]] += annotations_array[i]#计算属于每一聚类类别的和
        for j in range(num):
            centroids[j] = centroid_sums[j]/(np.sum(assignments==j))
        #前后两次的距离变化
        diff = abs(distances_sum-distance_sum_pre)
        #打印结果
        print("iteration: {},distance: {}, diff: {}, avg_IOU: {}\n".format(iteration,distances_sum,diff,np.sum(1-distances_array)/(N*num)))
        #三种情况跳出while循环：1：循环20000次，2：eps计算平均的距离很小 3：以上的情况
        if (assignments==assignments_pre).all():
            print("按照前后两次的得到的聚类结果是否相同结束循环\n")
            break
        if diff < eps:
            print("按照eps结束循环\n")
            break
        if iteration > iterations:
            print("按照迭代次数结束循环\n")
            break
        #记录上一次迭代
        distance_sum_pre = distances_sum
        assignments_pre = assignments.copy()
if __name__=='__main__':
    #聚类点的个数，anchor boxes的个数
    num_clusters = args.input_num_anchors
    #索引出文件夹中的每一个标注文件的名字(.txt)
    names = os.listdir(args.input_annotation_txt_dir)
    #标注的框的宽和高
    annotations_w_h = []
    for name in names:
        txt_path = os.path.join(args.input_annotation_txt_dir,name)
        #读取txt文件中的每一行
        f = open(txt_path,'r')
        for line in f.readlines():
            line = line.rstrip('\n')
            w,h = line.split(' ')[3:]#这时读到的w,h是字符串类型
            #eval()函数用来将字符串转换为数值型
            annotations_w_h.append((eval(w),eval(h)))
        f.close()
        #将列表annotations_w_h转换为numpy中的array,尺寸是(N,2),N代表多少框
        annotations_array = np.array(annotations_w_h,dtype=np.float32)
    N = annotations_array.shape[0]
    #对于k-means聚类，随机初始化聚类点
    random_indices = [random.randrange(N) for i in range(num_clusters)]#产生随机数
    centroids = annotations_array[random_indices]
    #k-means聚类
    k_means(annotations_array,centroids,0.00005,200000)
    #对centroids按照宽排序，并写入文件
    widths = centroids[:,0]
    sorted_indices = np.argsort(widths)
    anchors = centroids[sorted_indices]
    #将anchor写入文件并保存
    f_anchors = open(args.output_anchors_txt,'w')
    #
    for anchor in  anchors:
        f_anchors.write('%d,%d'%(int(anchor[0]*args.input_cfg_width),int(anchor[1]*args.input_cfg_height)))
        f_anchors.write('\n')

 对于以上生成anchors的具体理论，稍后添加

制作YoloV3的训练数据集

#!/usr/bin/env python3
# -*- coding: utf-8 -*-
import os
import argparse
import xml.etree.ElementTree as ET
#转换
def convert(size, box):
    dw = 1./(size[0])
    dh = 1./(size[1])
    x = (box[0] + box[1])/2.0 - 1
    y = (box[2] + box[3])/2.0 - 1
    w = box[1] - box[0]
    h = box[3] - box[2]
    x = x*dw
    w = w*dw
    y = y*dh
    h = h*dh
    return (x,y,w,h)
if __name__ == '__main__':
    #
    parser = argparse.ArgumentParser(description='利用该脚本文件: 1)将xml格式的标注文件转换为txt文件; 2)将图片的路径存储到txt文件中;3)根据实际情况修改脚本文件中的 classes')
    parser.add_argument('--input_images_dir',required = True,help = '输入存储图片的文件夹,darkNet是从文件夹名为images的文件夹中寻找图片,如/home/images')
    parser.add_argument('--input_annotations_dir',required = True,help='输入存储xml格式标注文件的文件夹,如/home/xml')
    parser.add_argument('--output_txt_dir',required = True,help='输出的存储txt文件的文件夹,darkNet是从文件夹名为labels的文件夹中寻找txt文件,而且文件夹images和labels位于同一级目录下,如/home/labels')
    parser.add_argument('--output_imagesdir_txt',required = True,help='输出的存储图片路径和图片名的txt文件名')
    args = parser.parse_args()
    #类别名
    classes = ['c1','c2']
    #索引出标注文件夹下的xml文件
    names = os.listdir(args.input_annotations_dir)
    #打开输出的txt文件
    output_imagesdir_txt = open(args.output_imagesdir_txt,'w')
    #创建存储xml转换为txt文件的文件夹
    output_txt_dir = args.output_txt_dir
    if not os.path.exists(output_txt_dir):
        os.makedirs(output_txt_dir)
    #循环处理
    for name in names:
        fileName,fileNameExtrend = os.path.splitext(name)
        #写入对应的图片文件路径
        output_imagesdir_txt.write(os.path.join(args.input_images_dir,fileName+'.jpg')+'\n')
        #读取xml文件
        xml_path = os.path.join(args.input_annotations_dir,name)
        #对应的输出的txt文件
        output_txt = open(os.path.join(output_txt_dir,fileName)+'.txt','w')
        #输出xml文件
        tree=ET.parse(xml_path)
        root = tree.getroot()
        size = root.find('size')
        w = int(size.find('width').text)
        h = int(size.find('height').text) 
        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 = (float(xmlbox.find('xmin').text), float(xmlbox.find('xmax').text), 
                 float(xmlbox.find('ymin').text), float(xmlbox.find('ymax').text))
            bb = convert((w,h), b)
            #写入txt文件，如'0 0.2 0.3 0.4 0.5'
            output_txt.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
        output_txt.close()
    output_imagesdir_txt.close()
        

用DarkNet训练数据集，在准备数据集时，有2种方式：

第1种：

darkNet训练网络时，
准备数据：
1：将图片存放在images文件夹下，
2：将txt文件存放在labels文件夹下
3：images和labels在同一目录下

darkNet会寻找images（或者JPEGimages）文件夹， 然后在统一目录下，寻找名称是labels的文件夹，该文件夹存放标注文件txt文件，如下图所示：

 

第2种方式：

如果没有images或者JPEGImages文件夹，那么每一张图片和对应的标注文件txt文件，要在同一目录下，如下图所示：

 其中trainImage文件夹中的文件如下所示，每一张图片对应相应的标注文件：