Práctico CenterNet, entrena y prueba el conjunto de datos de detección de puntos clave de caras de gatos

Aquí, principalmente sobre el registro, CenterNet de depuración utilizado para entrenar el proceso de detección de puntos críticos de cara de gato . Debido a que la mayor parte de Internet ahora usa CenterNet para la detección de objetivos, creo que CenterNet obviamente no es el mejor para la detección de objetivos. Para la detección de objetivos, puede ver el marco de detección de objetivos. Puede consultar mi blog:
mmdetection real combat, training playing conjunto de datos de la tarjeta (formato VOC) y probar y calcular mAP para
intentar seguir este blog, ¡todo puede ejecutarse correctamente!
Dirección de papel: Objetos como puntos [ Duplicación nacional ]
Dirección de código: https://github.com/xingyizhou/CenterNet
Referencia del blog: ¡ deshazte del ancla! Real CenterNet: documento de interpretación de objetos como puntos

Uno, configuración local

ubuntu18.04.3 + cuda10.0 + cudnn7.4.2 + PyTorch1.2 + torchvision0.4 + python3.6

Dos, construcción ambiental

1. De hecho, el documento oficial INSTALL.md ya lo ha dicho en detalle, aunque el autor usa pytorch0.4, se puede ejecutar en pytorch1.x.
2. También está muy detallado en los números / 7. Básicamente me refiero a este problema para la instalación. Después de instalar el entorno, puede consultar la sección de prueba en el interior para probar la demostración.
3. Solo hay una cosa a la que debe prestar atención, es decir, al compilar DCNv2, debe descargarlo de este árbol y luego prestar atención a no copiar para CenterNet/src/lib/models/networksreemplazar, sino eliminar toda la carpeta DCNv2 rm -rf DCNv2y luego copiar el archivo descargado en él, de lo contrario, la compilación fallará.
4. Los siguientes archivos de código modificados y usados, el modelo oficial de preentrenamiento están empaquetados aquí , no es necesario descargar el código ganador de la competencia.
5. Si tiene alguna pregunta, bienvenido al área de comentarios, pero no presentaré más aquí.

Tres, preparación de datos

De hecho, esta es una competencia de un club de investigación de IA . La introducción y el conjunto de datos se pueden descargar y descargar. El código ganador se usa aquí , pero no escribió ninguna introducción y dio un modelo entrenado, y no hay un registro de registro (solo un punto que ejecuta El contenido que copié y el archivo de formato json que dejé en ese momento me hizo morder la bala y leerlo durante varios días, así que lo grabaré aquí, solo sígueme a continuación):

1. El conjunto de datos solo se descomprime train，test，train.csv, debe train.csvcolocarse en el entorno recién creado CenterNet/data, ejecutar generate_train_val_txt.py(también ubicado debajo de los datos) para generar train.txt，test.txt, aquí está el código: generate_train_val_txt.py

import csv
import random

with open('train.csv','r') as csvfile:
    reader = csv.reader(csvfile)
    column = [row[0] for row in reader]

total_file = column[1:]

train_percent = 0.85
num = len(total_file)
print("total images numbers:", num)  # 10548

list = range(num)
tr = int(num * train_percent)
train = random.sample(list, tr)
print("train size:", tr)

ftrain = open('train.txt', 'w')
fval = open('val.txt', 'w')

for i in list:
    name = total_file[i] + '\n'
    if i in train:
        ftrain.write(name)
    else:
        fval.write(name)

ftrain.close()
fval.close()
print("write finished!")

2. Luego, ejecute generate_coco_json.pyel conjunto de datos de entrenamiento para generar un archivo de formato COCO train.json，test.json. El código se refiere a cómo convertir su propio conjunto de datos al formato coco en las tareas de detección de objetivos y de puntos clave. Si desea comprender el formato COCO, puede consultar el formato de etiqueta del conjunto de datos COCO . También coloque el código aquí: generate_coco_json.py

# *_* : coding: utf-8 *_*

'''
datasets process for object detection project.
for convert customer dataset format to coco data format,
'''

import traceback
import argparse
import json
import cv2
import csv
import os

__CLASS__ = ['__background__', 'CatFace']   # class dictionary, background must be in first index.

def argparser():
    parser = argparse.ArgumentParser("define argument parser for pycococreator!")
    parser.add_argument("-r", "--image_root", default='D:\\catface\\train\\', help="path of root directory")
    parser.add_argument("-p", "--phase_folder", default=["train", "val"], help="datasets split")

    return parser.parse_args()

def MainProcessing(args):
    '''main process source code.'''
    annotations = {
    
    }    # annotations dictionary, which will dump to json format file.
    image_root = args.image_root
    phase_folder = args.phase_folder
    with open('train.csv', 'r') as f:
        reader = csv.reader(f)
        result = list(reader)
        result = result[1:]

    # coco annotations info.
    annotations["info"] = {
    
    
        "description": "customer dataset format convert to COCO format",
        "url": "http://cocodataset.org",
        "version": "1.0",
        "year": 2020,
        "contributor": "ezra",
        "date_created": "2020/03/15"
    }
    # coco annotations licenses.
    annotations["licenses"] = [{
    
    
        "url": "https://www.apache.org/licenses/LICENSE-2.0.html",
        "id": 1,
        "name": "Apache License 2.0"
    }]
    # coco annotations categories.
    annotations["categories"] = []
    for cls, clsname in enumerate(__CLASS__):
        if clsname == '__background__':
            continue
        annotations["categories"].append(
            {
    
    
                "id": cls,
                "name": clsname,
                "supercategory": "Cat",
            }
        )
        for catdict in annotations["categories"]:
            if "CatFace" == catdict["name"]:
                catdict["keypoints"] = [0, 1, 2, 3, 4, 5, 6, 7, 8]
                catdict["skeleton"] = [[0,1],[1,2],[0,2],[3,4],[4,5],[5,6],[6,7],[7,8],[8,3]]

    for phase in phase_folder:
        annotations["images"] = []
        annotations["annotations"] = []
        fphase = open(phase + '.txt', 'r')
        step = 0
        for id, line in enumerate(fphase.readlines()):
            line = line.strip("\n")
            file_name = line + '.jpg'
            images_id = int(line)
            height, width, _ = cv2.imread(image_root + file_name).shape
            v = [2, 2, 2, 2, 2, 2, 2, 2, 2]
            point_str = result[images_id][1:]
            point = [int(k) for k in point_str]
            for j in range(9):
                if min(point[2*j:2*j+2]) < 0:
                    v[j] = 1
            keypoint = [point[0],  point[1],  v[0], point[2],  point[3],  v[1],
                        point[4],  point[5],  v[2], point[6],  point[7],  v[3],
                        point[8],  point[9],  v[4], point[10], point[11], v[5],
                        point[12], point[13], v[6], point[14], point[15], v[7],
                        point[16], point[17], v[8]]
            bw = max(point[0::2]) - min(point[0::2]) + 10
            bh = max(point[1::2]) - min(point[1::2]) + 10
            if (min(point[0::2]) - 5) < 0:
                x1 = 0
            else:
                x1 = (min(point[0::2]) - 5)
            if (min(point[1::2]) - 5) < 0:
                y1 = 0
            else:
                y1 = (min(point[1::2]) - 5)
            annotations["images"].append(
                {
    
    
                    "file_name": file_name,
                    "height": height,
                    "width": width,
                    "id": images_id
                }
            )
            # coco annotations annotations.
            annotations["annotations"].append(
                {
    
    
                    "id": id + 1,
                    "num_keypoints": 9,
                    "keypoints": keypoint,
                    "area": bw * bh,
                    "iscrowd": 0,
                    "image_id": images_id,
                    "bbox": [x1, y1, bw, bh],
                    "category_id": 1,
                    "segmentation": [],
                }
            )
            step += 1
            if step % 100 == 0:
                print("processing {} ...".format(step))

        json_path = phase+".json"
        with open(json_path, "w") as f:
            json.dump(annotations, f)


if __name__ == "__main__":
    print("begining to convert customer format to coco format!")
    args = argparser()
    try:
        MainProcessing(args)
    except Exception as e:
        traceback.print_exc()
    print("successful to convert customer format to coco format")

Presta atención, no me preguntes cómo se calculan el bbox y el área de esta manera, solo veo que sus datos obtienen la ley, el método de cálculo preciso es usar cocoapi , porque las siguientes tareas no requieren estos dos atributos, así que está bien .
3. luego se datacrea en cocola carpeta en la que crea dos carpetas: annotationsy images, el generado train.jsony se val.jsoncoloca annotationsdebajo del extracto de la carpeta de datos anterior trainy testse coloca imagesen el directorio de archivos por tanto tiempo para hacer esto:

├── CenterNet/data
│   ├── coco
│   │   ├── annotations
│   │   │   ├── train.json
│   │   │   ├── val.json
│   │   ├── images
│   │   │   ├── train
│   │   │   ├── test

Cuarto, empieza a entrenar

Aquí, simplemente reemplace la coco_hp.pysuma en el archivo del paquete con la suma opts.pycorrespondiente , y luego puede ejecutar el siguiente comando [Windows también puede necesitar establecer -num_workers 0, batch_size depende de su propio hardware]:CenterNet/src/lib/datasets/dataset/coco_hp.pyCenterNet/src/lib/opts.py

python main.py multi_pose --exp_id dla_1x_catface --dataset coco_hp --lr 5e-4 --lr_step '17,27' --num_epochs 37 --batch_size 16 --gpus 0  --load_model ../models/multi_pose_dla_3x.pth

Cinco, prueba

1. Aquí simplemente reemplace la post_process.pysuma multi_pose.pyy la suma en el archivo del paquete con la suma y la suma demo.pycorrespondientesCenterNet/src/lib/utils/post_process.pyCenterNet/src/lib/detectors/multi_pose.pyCenterNet/src/demo.py
2. Cambie el coco_hp.pynúmero 31行a:

self.img_dir = os.path.join(self.data_dir, 'images/test')

3. Ejecute el siguiente comando:

python demo.py multi_pose --demo '/home/lsm/文档/CenterNet/data/coco/images/test' --exp_id dla_1x_catfacetest --dataset coco_hp --load_model /home/lsm/文档/CenterNet/exp/multi_pose/dla_1x_catface/model_best.pth

Habrá en /home/lsm/文档/CenterNet/exp/multi_pose/dla_1x_catfacetestla próxima generación un archivo result.csv , enviado después de las sesiones de práctica en el que puede ver los resultados:

este resultado que la carrera del premio por el primer lugar antes, pero también el proveedor de este código todavía es un poco alto, que yo también entrenar mejor:

4. CenterNet/src/lib/utils/debugger.pyCambie las siguientes dos propiedades en el interior:

self.num_joints = 9
self.edges = [[0, 1], [1, 2], [0, 2], [3, 4],
              [4, 5], [5, 6], [6, 7],[7, 8], [8, 3]]

Luego ejecute el siguiente comando:

python demo.py multi_pose --demo /home/lsm/文档/CenterNet/data/coco/images/test/54.jpg --load_model /home/lsm/文档/CenterNet/exp/multi_pose/dla_1x_catface/model_best.pth --debug 4

Obtendrá la siguiente imagen:

六 、 referencias

La sensación después de terminarlo es que realmente me admiro amargamente mirando el código. No he depurado el código de CenterNet antes , ¡pero lo hice basado en el código del pequeño compañero de caza de cometas !
Mi propio artículo es casi el mismo, el código solo se ejecutará, no particularmente en profundidad, gracias por la orientación del siguiente blog, también puede ir a ellos para ver algunos dibujos de curvas de pérdida y otras funciones:
Cómo se entrena CenterNet su propio conjunto de datos
(la última versión) ¿Entrenar su propio conjunto de datos en CenterNet?
Conjunto de datos propios de entrenamiento detallado de Centernet (win10 + cuda10 + pytorch1.0.1)