Maestría de Anotación Integración perfecta de Detectron con LabelImg

Anotación maestra Integración perfecta de Detectron con LabelImg

Introducción

Etiquetar la imagen o anotar la foto en el contexto de la visión por computadora fue un desafío. Nuestra exploración se adentra en el trabajo en equipo de LabelImg y Detectron, un dúo poderoso que combina la anotación precisa con una construcción eficiente del modelo. LabelImg, que es fácil de usar y preciso, lidera la anotación cuidadosa, sentando una base sólida para la detección clara de objetos.

A medida que exploramos LabelImg y mejoramos en dibujar cuadros delimitadores, nos movemos sin problemas hacia Detectron. Este robusto marco organiza nuestros datos marcados, lo que resulta útil en el entrenamiento de modelos avanzados. LabelImg y Detectron juntos hacen que la detección de objetos sea fácil para todos, ya sean principiantes o expertos. Únete, donde cada imagen marcada nos ayuda a desbloquear todo el poder de la información visual.

Objetivos de aprendizaje

• Empezar con LabelImg.
• Configuración del entorno e instalación de LabelImg.
• Comprender LabelImg y su funcionalidad.
• Convertir datos VOC o Pascal a formato COCO para la detección de objetos.

Este artículo se publicó como parte del Data Science Blogathon.

• ¿Qué es MLOps?
• ¿Cómo supera Bing Chat a ChatGPT en proporcionar conocimiento en tiempo real actualizado? Conoce la Generación con Recuperación Mejorada (RAG)
• Explorando alternativas de código abierto a los modelos de OpenAI

Diagrama de flujo

Configurando tu entorno

1. Crea un entorno virtual:

conda create -p ./venv python=3.8 -y

Este comando crea un entorno virtual llamado “venv” utilizando la versión 3.8 de Python.

2. Activa el entorno virtual:

conda activate venv

Activa el entorno virtual para aislar la instalación de LabelImg.

Instalación y uso de LabelImg

1. Instala LabelImg:

pip install labelImg

Instala LabelImg dentro del entorno virtual activado.

2. Inicia LabelImg:

labelImg

Solución de problemas: si encuentras errores al ejecutar el script

Si encuentras errores al ejecutar el script, he preparado un archivo zip que contiene el entorno virtual (venv) para tu comodidad.

1. Descarga el archivo zip:

• Descarga el archivo zip venv desde el enlace.

2. Crea una carpeta para LabelImg:

• Crea una nueva carpeta llamada LabelImg en tu máquina local.

3. Extrae la carpeta venv:

• Extrae el contenido del archivo zip venv en la carpeta LabelImg.

4. Activa el entorno virtual:

• Abre tu línea de comandos o terminal.
• Navega hasta la carpeta LabelImg.
• Ejecuta el siguiente comando para activar el entorno virtual:

conda activate ./venv

Este proceso garantiza que tengas un entorno virtual preconfigurado listo para usar con LabelImg. El archivo zip proporcionado encapsula las dependencias necesarias, lo que permite una experiencia más fluida sin preocuparte por posibles instalaciones.

Ahora, continúa con los pasos anteriores para instalar y usar LabelImg dentro de este entorno virtual activado.

Flujo de trabajo de anotación con LabelImg

1. Anota imágenes en formato PascalVOC:

• Construye e inicia LabelImg.
• Haz clic en ‘Cambiar carpeta de anotaciones guardadas por defecto’ en Menú/Archivo.
• Haz clic en ‘Abrir carpeta’ para seleccionar el directorio de imágenes.
• Usa ‘Crear RectBox’ para anotar objetos en la imagen.
• Guarda las anotaciones en la carpeta especificada.

dentro del archivo .xml

<annotation> <folder>train</folder>  <filename>0a8a68ee-f587-4dea-beec-79d02e7d3fa4___RS_Early.B 8461.JPG</filename> <path>/home/suyodhan/Documents/Blog /label/train/0a8a68ee-f587-4dea-beec-79d02e7d3fa4___RS_Early.B 8461.JPG</path>  <source>      <database>Desconocida</database>    </source> <size>        <width>256</width>      <height>256</height>        <depth>3</depth>    </size>   <segmented>0</segmented>    <object>      <name>Papa___Tizón_temprano</name>      <pose>No especificada</pose>        <truncated>0</truncated>        <difficult>0</difficult>        <bndbox>          <xmin>12</xmin>         <ymin>18</ymin>         <xmax>252</xmax>            <ymax>250</ymax>        </bndbox> </object></annotation>

Esta estructura XML sigue el formato de anotación Pascal VOC, comúnmente utilizado en conjuntos de datos de detección de objetos. Este formato proporciona una representación estandarizada de datos anotados para entrenar modelos de visión por computadora. Si tienes imágenes adicionales con anotaciones, puedes continuar generando archivos XML similares para cada objeto anotado en las respectivas imágenes.

Convirtiendo Anotaciones Pascal VOC a Formato COCO: Un Script en Python

Los modelos de detección de objetos a menudo requieren anotaciones en formatos específicos para entrenar y evaluar de manera efectiva. Si bien Pascal VOC es un formato ampliamente utilizado, marcos específicos como Detectron prefieren las anotaciones COCO. Para cerrar esta brecha, presentamos un versátil script en Python, voc2coco.py, diseñado para convertir las anotaciones Pascal VOC al formato COCO de manera fluida.

#!/usr/bin/python# pip install lxmlimport sysimport osimport jsonimport xml.etree.ElementTree as ETimport globSTART_BOUNDING_BOX_ID = 1PRE_DEFINE_CATEGORIES = None# Si es necesario, define previamente la categoría y su id#  PRE_DEFINE_CATEGORIES = {"aeroplano": 1, "bicicleta": 2, "pájaro": 3, "barco": 4,#  "botella":5, "autobús": 6, "coche": 7, "gato": 8, "silla": 9,#  "vaca": 10, "mesa": 11, "perro": 12, "caballo": 13,#  "motocicleta": 14, "persona": 15, "planta en maceta": 16,#  "oveja": 17, "sofá": 18, "tren": 19, "monitor de TV": 20}def get(root, name):    vars = root.findall(name)    return varsdef get_and_check(root, name, length):    vars = root.findall(name)    if len(vars) == 0:        raise ValueError("No se puede encontrar %s en %s." % (name, root.tag))    if length > 0 and len(vars) != length:        raise ValueError(            "El tamaño de %s debe ser %d, pero es %d."            % (name, length, len(vars))        )    if length == 1:        vars = vars[0]    return varsdef get_filename_as_int(filename):    try:        filename = filename.replace("\\", "/")        filename = os.path.splitext(os.path.basename(filename))[0]        return str(filename)    except:        raise ValueError("El nombre de archivo %s debe ser un número entero." % (filename))def get_categories(xml_files):    """Genera un mapeo del nombre de categoría con su id a partir de una lista de archivos xml.        Argumentos:        xml_files {lista} -- Una lista de rutas de archivos xml.        Devuelve:        dict -- mapeo del nombre de categoría con su id.    """    nombres_clases = []    for xml_file in xml_files:        tree = ET.parse(xml_file)        root = tree.getroot()        for member in root.findall("object"):            nombres_clases.append(member[0].text)    nombres_clases = list(set(nombres_clases))    nombres_clases.sort()    return {nombre: i for i, nombre in enumerate(nombres_clases)}def convert(xml_files, json_file):    json_dict = {"images": [], "type": "instances", "annotations": [], "categories": []}    if PRE_DEFINE_CATEGORIES is not None:        categorias = PRE_DEFINE_CATEGORIES    else:        categorias = get_categories(xml_files)    bnd_id = START_BOUNDING_BOX_ID    for xml_file in xml_files:        tree = ET.parse(xml_file)        root = tree.getroot()        path = get(root, "path")        if len(path) == 1:            filename = os.path.basename(path[0].text)        elif len(path) == 0:            filename = get_and_check(root, "filename", 1).text        else:            raise ValueError("%d rutas encontradas en %s" % (len(path), xml_file))        ## El nombre de archivo debe ser un número        image_id = get_filename_as_int(filename)        size = get_and_check(root, "size", 1)        width = int(get_and_check(size, "width", 1).text)        height = int(get_and_check(size, "height", 1).text)        image = {            "file_name": filename,            "height": height,            "width": width,            "id": image_id,        }        json_dict["images"].append(image)        ## Actualmente no admitimos segmentación.        #  segmented = get_and_check(root, 'segmented', 1).text        #  assert segmented == '0'        for obj in get(root, "object"):            category = get_and_check(obj, "name", 1).text            if category not in categorias:                new_id = len(categorias)                categorias[category] = new_id            category_id = categorias[category]            bndbox = get_and_check(obj, "bndbox", 1)            xmin = int(get_and_check(bndbox, "xmin", 1).text) - 1            ymin = int(get_and_check(bndbox, "ymin", 1).text) - 1            xmax = int(get_and_check(bndbox, "xmax", 1).text)            ymax = int(get_and_check(bndbox, "ymax", 1).text)            assert xmax > xmin            assert ymax > ymin            o_width = abs(xmax - xmin)            o_height = abs(ymax - ymin)            ann = {                "area": o_width * o_height,                "iscrowd": 0,                "image_id": image_id,                "bbox": [xmin, ymin, o_width, o_height],                "category_id": category_id,                "id": bnd_id,                "ignore": 0,                "segmentation": [],            }            json_dict["annotations"].append(ann)            bnd_id = bnd_id + 1    for cate, cid in categorias.items():        cat = {"supercategory": "ninguno", "id": cid, "name": cate}        json_dict["categories"].append(cat)    #os.makedirs(os.path.dirname(json_file), exist_ok=True)    json_fp = open(json_file, "w")    json_str = json.dumps(json_dict)    json_fp.write(json_str)    json_fp.close()if __name__ == "__main__":    import argparse    parser = argparse.ArgumentParser(        description="Convertir anotación Pascal VOC a formato COCO."    )    parser.add_argument("xml_dir", help="Ruta del directorio de archivos xml.", type=str)    parser.add_argument("json_file", help="Archivo de salida en formato COCO json.", type=str)    args = parser.parse_args()    xml_files = glob.glob(os.path.join(args.xml_dir, "*.xml"))    # Si quieres hacer una división de entrenamiento/prueba, puedes pasar un subconjunto de archivos xml a la función convert.    print("Número de archivos xml: {}".format(len(xml_files)))    convert(xml_files, args.json_file)    print("Éxito: {}".format(args.json_file))

Resumen del Script

El script voc2coco.py simplifica el proceso de conversión utilizando la biblioteca lxml. Antes de adentrarnos en su uso, exploremos sus componentes clave:

1. Dependencias:

• Asegúrate de tener instalada la biblioteca lxml utilizando pip install lxml.

2. Configuración:

• De forma opcional, puedes predefinir categorías utilizando la variable PRE_DEFINE_CATEGORIES. Descomenta y modifica esta sección de acuerdo a tu conjunto de datos.

3. Funciones:

• get, get_and_check, get_filename_as_int: Funciones auxiliares para el análisis de XML.
• get_categories: Genera una asignación de nombres de categorías a ID a partir de una lista de archivos XML.
• convert: La función principal de conversión procesa archivos XML y genera un archivo JSON en formato COCO.

Cómo utilizarlo

Ejecutar el script es sencillo: ejecútalo desde la línea de comandos, proporcionando la ruta a tus archivos XML de Pascal VOC y especificando la ruta de salida deseada para el archivo JSON en formato COCO. Aquí tienes un ejemplo:

python voc2coco.py /ruta/a/los/archivos/xml /ruta/de/salida/salida.json

Salida:

El script genera un archivo JSON en formato COCO bien estructurado que contiene información esencial sobre imágenes, anotaciones y categorías.

Conclusión

En conclusión, al finalizar nuestro recorrido por la detección de objetos con LabelImg y Detectron, es crucial reconocer la variedad de herramientas de anotación disponibles para entusiastas y profesionales. LabelImg, como una joya de código abierto, ofrece versatilidad y accesibilidad, convirtiéndola en una opción destacada.

Más allá de las herramientas gratuitas, soluciones de pago como VGG Image Annotator (VIA), RectLabel y Labelbox se presentan para tareas complejas y proyectos grandes. Estas plataformas ofrecen funciones avanzadas y escalabilidad, aunque requieren una inversión económica, garantizando eficiencia en esfuerzos de alto nivel.

Nuestra exploración enfatiza la importancia de elegir la herramienta de anotación adecuada basándose en los detalles del proyecto, el presupuesto y el nivel de sofisticación deseado. En el campo en constante evolución de la visión por computadora, las herramientas de anotación continúan diversificándose, brindando opciones para proyectos de todos los tamaños y complejidades.

Lo más importante

• La interfaz intuitiva y las características avanzadas de LabelImg la convierten en una herramienta de código abierto versátil para la anotación precisa de imágenes, ideal para aquellos que se inician en la detección de objetos.
• Herramientas de pago como VIA, RectLabel y Labelbox se adaptan a tareas de anotación complejas y proyectos a gran escala, ofreciendo funciones avanzadas y escalabilidad.
• El punto clave es elegir la herramienta de anotación adecuada en función de las necesidades del proyecto, el presupuesto y el nivel de sofisticación deseado, asegurando eficiencia y éxito en los esfuerzos de detección de objetos.

Recursos para seguir aprendiendo:

1. Documentación de LabelImg:

• Explora la documentación oficial de LabelImg para obtener información detallada sobre sus características y funcionalidades.
• Documentación de LabelImg

2. Documentación del framework Detectron:

• Sumérgete en la documentación de Detectron, el potente framework de detección de objetos, para comprender sus capacidades y uso.
• Documentación de Detectron

3. Guía de VGG Image Annotator (VIA):

• Si estás interesado en explorar VIA, el VGG Image Annotator, consulta la guía completa para obtener instrucciones detalladas.
• Guía de usuario de VIA

4. Documentación de RectLabel:

• Aprende más sobre RectLabel, una herramienta de anotación de pago, consultando su documentación oficial para obtener orientación sobre su uso y características.
• Documentación de RectLabel

5. Centro de aprendizaje de Labelbox:

• Descubre recursos educativos y tutoriales en el Centro de aprendizaje de Labelbox para mejorar tu comprensión de esta plataforma de anotación.
• Centro de aprendizaje de Labelbox

Preguntas frecuentes

El material visual mostrado en este artículo no pertenece a Analytics Vidhya y se utiliza a discreción del autor.

We will continue to update Zepes; if you have any questions or suggestions, please contact us!