Upload 2 files

Voc--yolo.py

@@ -0,0 +1,182 @@
+import xml.etree.ElementTree as ET
+import pickle
+import os
+from os import listdir, getcwd
+from os.path import join
+import random
+from shutil import copyfile
+
+
+classes = ["pig"]
+# Set the ratio of training data and validation data, with the remainder being used as test data.
+TRAIN_RATIO = 80
+VAL_RATIO = 10
+
+
+def clear_hidden_files(path):
+    dir_list = os.listdir(path)
+    for i in dir_list:
+        abspath = os.path.join(os.path.abspath(path), i)
+        if os.path.isfile(abspath):
+            if i.startswith("._"):
+                os.remove(abspath)
+        else:
+            clear_hidden_files(abspath)
+
+
+def convert(size, box):
+    dw = 1. / size[0]
+    dh = 1. / size[1]
+    x = (box[0] + box[1]) / 2.0
+    y = (box[2] + box[3]) / 2.0
+    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)
+
+
+def convert_annotation(image_id):
+    in_file = open('VOCdevkit/VOC2007/Annotations/%s.xml' % image_id)
+    out_file = open('VOCdevkit/VOC2007/YOLOLabels/%s.txt' % image_id, 'w')
+    tree = ET.parse(in_file)
+    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)
+        out_file.write(str(cls_id) + " " + " ".join([str(a) for a in bb]) + '\n')
+    in_file.close()
+    out_file.close()
+
+
+wd = os.getcwd()
+data_base_dir = os.path.join(wd, "VOCdevkit/")
+if not os.path.isdir(data_base_dir):
+    os.mkdir(data_base_dir)
+
+work_sapce_dir = os.path.join(data_base_dir, "VOC2007/")
+if not os.path.isdir(work_sapce_dir):
+    os.mkdir(work_sapce_dir)
+
+annotation_dir = os.path.join(work_sapce_dir, "Annotations/")
+if not os.path.isdir(annotation_dir):
+    os.mkdir(annotation_dir)
+clear_hidden_files(annotation_dir)
+
+image_dir = os.path.join(work_sapce_dir, "JPEGImages/")
+if not os.path.isdir(image_dir):
+    os.mkdir(image_dir)
+clear_hidden_files(image_dir)
+
+yolo_labels_dir = os.path.join(work_sapce_dir, "YOLOLabels/")
+if not os.path.isdir(yolo_labels_dir):
+    os.mkdir(yolo_labels_dir)
+clear_hidden_files(yolo_labels_dir)
+
+yolov5_images_dir = os.path.join(data_base_dir, "images/")
+if not os.path.isdir(yolov5_images_dir):
+    os.mkdir(yolov5_images_dir)
+clear_hidden_files(yolov5_images_dir)
+
+yolov5_labels_dir = os.path.join(data_base_dir, "YOLOLabels/")
+if not os.path.isdir(yolov5_labels_dir):
+    os.mkdir(yolov5_labels_dir)
+clear_hidden_files(yolov5_labels_dir)
+
+
+yolov5_images_train_dir = os.path.join(yolov5_images_dir, "train2007/")
+if not os.path.isdir(yolov5_images_train_dir):
+    os.mkdir(yolov5_images_train_dir)
+clear_hidden_files(yolov5_images_train_dir)
+
+yolov5_images_val_dir = os.path.join(yolov5_images_dir, "val2007/")
+if not os.path.isdir(yolov5_images_val_dir):
+    os.mkdir(yolov5_images_val_dir)
+clear_hidden_files(yolov5_images_val_dir)
+
+yolov5_images_test_dir = os.path.join(yolov5_images_dir, "val2007/")
+if not os.path.isdir(yolov5_images_test_dir):
+    os.mkdir(yolov5_images_test_dir)
+clear_hidden_files(yolov5_images_test_dir)
+
+
+yolov5_labels_train_dir = os.path.join(yolov5_labels_dir, "train2007/")
+if not os.path.isdir(yolov5_labels_train_dir):
+    os.mkdir(yolov5_labels_train_dir)
+clear_hidden_files(yolov5_labels_train_dir)
+
+yolov5_labels_val_dir = os.path.join(yolov5_images_dir, "val2007/")
+if not os.path.isdir(yolov5_labels_val_dir):
+    os.mkdir(yolov5_labels_val_dir)
+clear_hidden_files(yolov5_labels_val_dir)
+
+yolov5_labels_test_dir = os.path.join(yolov5_labels_dir, "val2007/")
+if not os.path.isdir(yolov5_labels_test_dir):
+    os.mkdir(yolov5_labels_test_dir)
+clear_hidden_files(yolov5_labels_test_dir)
+
+train_file = open(os.path.join(wd, "train.txt"), 'w')
+val_file = open(os.path.join(wd, "val.txt"), 'w')
+test_file = open(os.path.join(wd, "test.txt"), 'w')
+train_file.close()
+val_file.close()
+test_file.close()
+
+train_file = open(os.path.join(wd, "train.txt"), 'a')
+val_file = open(os.path.join(wd, "val.txt"), 'a')
+test_file = open(os.path.join(wd, "test.txt"), 'a')
+
+list_imgs = os.listdir(image_dir)  # list image files
+prob = random.randint(1, 100)
+print("Probability: %d" % prob)
+for i in range(0, len(list_imgs)):
+    path = os.path.join(image_dir, list_imgs[i])
+    if os.path.isfile(path):
+        image_path = image_dir + list_imgs[i]
+        voc_path = list_imgs[i]
+        (nameWithoutExtention, extention) = os.path.splitext(os.path.basename(image_path))
+        (voc_nameWithoutExtention, voc_extention) = os.path.splitext(os.path.basename(voc_path))
+        annotation_name = nameWithoutExtention + '.xml'
+        annotation_path = os.path.join(annotation_dir, annotation_name)
+        label_name = nameWithoutExtention + '.txt'
+        label_path = os.path.join(yolo_labels_dir, label_name)
+    prob = random.randint(1, 100)
+    print("Probability: %d" % prob)
+
+    if (prob < TRAIN_RATIO):  # train dataset
+        if os.path.exists(annotation_path):
+            train_file.write(image_path + '\n')
+            convert_annotation(nameWithoutExtention)  # convert label
+            copyfile(image_path, yolov5_images_train_dir + voc_path)
+            copyfile(label_path, yolov5_labels_train_dir + label_name)
+
+    elif(prob < TRAIN_RATIO + VAL_RATIO):  # test dataset
+        if os.path.exists(annotation_path):
+            val_file.write(image_path + '\n')
+            convert_annotation(nameWithoutExtention)  # convert label
+            copyfile(image_path, yolov5_images_test_dir + voc_path)
+            copyfile(label_path, yolov5_labels_test_dir + label_name)
+
+    else:
+        if os.path.exists(annotation_path):
+            test_file.write(image_path + '\n')
+            convert_annotation(nameWithoutExtention)  # convert label
+            copyfile(image_path, yolov5_images_test_dir + voc_path)
+            copyfile(label_path, yolov5_labels_test_dir + label_name)
+
+train_file.close()
+test_file.close()
+val_file.close()

Voc.py

@@ -0,0 +1,150 @@
+import os
+import random
+import xml.etree.ElementTree as ET
+
+import numpy as np
+
+from utils.utils import get_classes
+
+# annotation_mode is used to specify what is computed during the runtime of this file.(defult : 0)
+# annotation_mode 0 represents the entire label processing process, including obtaining the txt files inside VOCdevkit/VOC2007/ImageSets
+# and the training files 2007_train.txt and 2007_val.txt.
+# annotation_mode 1 represents obtaining the txt files inside VOCdevkit/VOC2007/ImageSets.
+# annotation_mode 2 represents obtaining the training files 2007_train.txt and 2007_val.txt.
+annotation_mode = 0
+
+# classes
+classes = 'pig'
+
+# trainval_percent is used to specify the ratio of (training set + validation set) to the test set.
+# train_percent is used to specify the ratio of the training set to the validation set within (training set + validation set).
+trainval_percent = 0.8
+train_percent = 0.75
+
+# Points to the folder containing the VOC dataset.
+# It defaults to the VOC dataset in the root directory.
+
+VOCdevkit_path = 'VOCdevkit'
+VOCdevkit_sets = [('2007', 'train'), ('2007', 'val')]
+
+# Counting the number of labels
+photo_nums = np.zeros(len(VOCdevkit_sets))
+nums = np.zeros(len(classes))
+
+
+def convert_annotation(year, image_id, list_file):
+    in_file = open(os.path.join(VOCdevkit_path, 'VOC%s/Annotations/%s.xml' % (year, image_id)), encoding='utf-8')
+    tree = ET.parse(in_file)
+    root = tree.getroot()
+
+    for obj in root.iter('object'):
+        difficult = 0
+        if obj.find('difficult') != None:
+            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(float(xmlbox.find('xmin').text)), int(float(xmlbox.find('ymin').text)),
+             int(float(xmlbox.find('xmax').text)), int(float(xmlbox.find('ymax').text)))
+        list_file.write(" " + ",".join([str(a) for a in b]) + ',' + str(cls_id))
+
+        nums[classes.index(cls)] = nums[classes.index(cls)] + 1
+
+
+if __name__ == "__main__":
+    random.seed(0)
+    if " " in os.path.abspath(VOCdevkit_path):
+        raise ValueError(
+            "There should be no spaces in the folder path where the dataset is stored and in the image names, as it can affect the model training. Please make sure to make the necessary corrections.")
+
+    if annotation_mode == 0 or annotation_mode == 1:
+        print("Generate txt in ImageSets.")
+        xmlfilepath = os.path.join(VOCdevkit_path, 'VOC2007/Annotations')
+        saveBasePath = os.path.join(VOCdevkit_path, 'VOC2007/ImageSets/Main')
+        temp_xml = os.listdir(xmlfilepath)
+        total_xml = []
+        for xml in temp_xml:
+            if xml.endswith(".xml"):
+                total_xml.append(xml)
+
+        num = len(total_xml)
+        list = range(num)
+        tv = int(num * trainval_percent)
+        tr = int(tv * train_percent)
+        trainval = random.sample(list, tv)
+        train = random.sample(trainval, tr)
+
+        print("train and val size", tv)
+        print("train size", tr)
+        ftrainval = open(os.path.join(saveBasePath, 'trainval.txt'), 'w')
+        ftest = open(os.path.join(saveBasePath, 'test.txt'), 'w')
+        ftrain = open(os.path.join(saveBasePath, 'train.txt'), 'w')
+        fval = open(os.path.join(saveBasePath, 'val.txt'), 'w')
+
+        for i in list:
+            name = total_xml[i][:-4] + '\n'
+            if i in trainval:
+                ftrainval.write(name)
+                if i in train:
+                    ftrain.write(name)
+                else:
+                    fval.write(name)
+            else:
+                ftest.write(name)
+
+        ftrainval.close()
+        ftrain.close()
+        fval.close()
+        ftest.close()
+        print("Generate txt in ImageSets done.")
+
+    if annotation_mode == 0 or annotation_mode == 2:
+        print("Generate 2007_train.txt and 2007_val.txt for train.")
+        type_index = 0
+        for year, image_set in VOCdevkit_sets:
+            image_ids = open(os.path.join(VOCdevkit_path, 'VOC%s/ImageSets/Main/%s.txt' % (year, image_set)),
+                             encoding='utf-8').read().strip().split()
+            list_file = open('%s_%s.txt' % (year, image_set), 'w', encoding='utf-8')
+            for image_id in image_ids:
+                list_file.write('%s/VOC%s/JPEGImages/%s.jpg' % (os.path.abspath(VOCdevkit_path), year, image_id))
+
+                convert_annotation(year, image_id, list_file)
+                list_file.write('\n')
+            photo_nums[type_index] = len(image_ids)
+            type_index += 1
+            list_file.close()
+        print("Generate 2007_train.txt and 2007_val.txt for train done.")
+
+
+        def printTable(List1, List2):
+            for i in range(len(List1[0])):
+                print("|", end=' ')
+                for j in range(len(List1)):
+                    print(List1[j][i].rjust(int(List2[j])), end=' ')
+                    print("|", end=' ')
+                print()
+
+
+        str_nums = [str(int(x)) for x in nums]
+        tableData = [
+            classes, str_nums
+        ]
+        colWidths = [0] * len(tableData)
+        len1 = 0
+        for i in range(len(tableData)):
+            for j in range(len(tableData[i])):
+                if len(tableData[i][j]) > colWidths[i]:
+                    colWidths[i] = len(tableData[i][j])
+        printTable(tableData, colWidths)
+
+        if photo_nums[0] <= 500:
+            print("The number of training samples is less than 500, which is a small dataset. Please consider setting a larger number of training epochs (Epochs) to ensure an adequate number of gradient descent steps.")
+
+        if np.sum(nums) == 0:
+            print("No objects have been detected in the dataset. Please make sure to update the 'classes_path' to match your dataset and ensure that the class labels are correct; otherwise, the training will be ineffective!")
+            print("No objects have been detected in the dataset. Please make sure to update the 'classes_path' to match your dataset and ensure that the class labels are correct; otherwise, the training will be ineffective!")
+            print("No objects have been detected in the dataset. Please make sure to update the 'classes_path' to match your dataset and ensure that the class labels are correct; otherwise, the training will be ineffective!")
+            print("(Important information repeated three times).")
+