YoloV3-生成anchors 和制作数据集

川长思鸟来 2022-04-08 10:59 147阅读 0赞

# 利用以下代码生成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文件，如下图所示：

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d4Y2R6aGFuZ3Bpbmc_size_16_color_FFFFFF_t_70][]

第2种方式：

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

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d4Y2R6aGFuZ3Bpbmc_size_16_color_FFFFFF_t_70 1][]

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

![20181211095507400.png][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d4Y2R6aGFuZ3Bpbmc_size_16_color_FFFFFF_t_70]: /images/20220406/102796196598483285dae0eb8d37cb65.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3d4Y2R6aGFuZ3Bpbmc_size_16_color_FFFFFF_t_70 1]: /images/20220406/ce9cd2837d9947859bf9f1a851a6ecd1.png
[20181211095507400.png]: /images/20220406/653cb4c4d1014d4a93a206b25a27fd18.png