ML | Clasificador de imágenes de entrenamiento con la API de detección de objetos de Tensorflow

Este artículo tiene como objetivo aprender cómo construir un detector de objetos utilizando la API de detección de objetos de Tensorflow.

Requisito:

• Programación Python
• Conceptos básicos del aprendizaje automático
• Fundamentos de redes neuronales (No Obligatorio)
• Un entusiasmo para construir un proyecto Cool (Obligatorio) :p

Aunque si no tienes los primeros tres elementos esenciales, eres bienvenido a la aventura. ¡No te preocupes por perderte, te guiaré adecuadamente a lo largo del viaje!

¿Qué es la detección de objetos?
La detección de objetos es el proceso de encontrar instancias de objetos del mundo real, como rostros, edificios y bicicletas en imágenes o videos. Los algoritmos de detección de objetos suelen utilizar características extraídas y algoritmos de aprendizaje para reconocer instancias de una categoría de objetos. Se usa comúnmente en aplicaciones como recuperación de imágenes, seguridad, vigilancia y sistemas avanzados de asistencia al conductor (automóviles autónomos). Personalmente, he utilizado la detección de objetos para crear un prototipo de motor de búsqueda basado en imágenes.

¿Qué es la API de detección de objetos de Tensorflow?
Tensorflow es un marco de aprendizaje profundo de código abierto creado por Google Brain. La API de detección de objetos de Tensorflow es una herramienta poderosa que permite a todos crear sus propios clasificadores de imágenes potentes. No se necesitan conocimientos de codificación o programación para usar la API de detección de objetos de Tensorflow. Pero para comprender que funciona, es útil conocer la programación de Python y los conceptos básicos del aprendizaje automático.

Antes de comenzar la aventura, asegurémonos de que Python 3 esté instalado en su sistema

Para instalar python y pip, consulte este sitio

¡Lo primero es lo primero! Asegúrese de que los paquetes indicados a continuación estén instalados en su sistema. Estos son esenciales en tu aventura.

       pip install protobuf
       pip install pillow
       pip install lxml
       pip install Cython
       pip install jupyter
       pip install matplotlib
       pip install pandas
       pip install opencv-python 
       pip install tensorflow

Para poder iniciar la aventura, deberemos hacernos con el vehículo y realizarle las configuraciones necesarias.
API de detección de objetos de Tensorflow

1. Podemos obtener la API de detección de objetos de Tensorflow desde github
2. Visite el enlace proporcionado: Descargar aquí

Después de descargar la carpeta de modelos, extráigala al directorio del proyecto. Podemos encontrar el directorio object_detection dentro

 models-master/research/ 

• Creación de una variable PYTHONPATH:
  se debe crear una variable PYTHONPATH que apunte a los directorios \models, \models\research y \models\research\slim. Emita el comando de la siguiente manera desde cualquier directorio. En mi caso,

     set PYTHONPATH=F:\Programming\geeksforgeeks_project\models-master;F:\Programming\geeksforgeeks_project\models-master\research;F:\Programming\geeksforgeeks_project\models-master\research\slim

Compilación de archivos protobuf y ejecución de setup.py:
la necesidad de compilar los archivos Protobuf, que TensorFlow usa para configurar el modelo y los parámetros de entrenamiento.
Para compilar archivos protoc primero necesitamos obtener el compilador protobuf. Puedes descargarlo aquí . Descargue el archivo protoc-3.8-win64.zip para el sistema operativo Windows y para otros sistemas operativos, descargue el archivo zip relacionado. Extraiga la carpeta bin al directorio de investigación.
Copie el código proporcionado a continuación y guárdelo como use_protobuf.py en su directorio de investigación.

  import os 
  import sys 
  args = sys.argv 
  directory = args[1] 
  protoc_path = args[2] 
  for file in os.listdir(directory):
     if file.endswith(".proto"):
         os.system(protoc_path+" "+directory+"/"+file+" --python_out=.")

Vaya al directorio de investigación en el símbolo del sistema y use el comando que se indica a continuación.

python use_protobuf.py  .\object_detection\protos\ .\bin\protoc

Esto compila todos los archivos protobuf y crea un archivo name_pb2.py de cada archivo name.proto en la carpeta \object_detection\protos.
Finalmente, ejecute los siguientes comandos desde el directorio models-master\research:

  python setup.py build
  python setup.py install

Con esto, la instalación finaliza y se instala un paquete llamado detección de objetos .

jupyter notebook object_detection_tutorial.ipynb

Con esto hemos configurado con éxito nuestro vehículo.

¡Comencemos nuestro viaje!

Para llegar a nuestro destino necesitamos cruzar 6 puntos de control:

1. Preparación del conjunto de datos
2. Etiquetado del conjunto de datos
3. Generación de registros para capacitación
4. Configuración de la formación
5. Entrenando al modelo
6. Exportación de gráfico de inferencia

Planifica qué objetos quieres detectar usando el clasificador.

• Punto de verificación 1: preparación del conjunto de datos:

  En esta aventura, voy a construir un clasificador que detecte zapatos y botellas de agua. Recuerde, el conjunto de datos es lo más importante en la construcción de un clasificador. Esta será la base de su clasificador en el que se realiza la detección de objetos. Recoge tantas imágenes diferentes y variadas que contengan los objetos. Cree un directorio llamado imágenes dentro del directorio de investigación. Almacene el 80% de las imágenes en el directorio de tren y el 20% de las imágenes en el directorio de prueba dentro del directorio de imágenes. He recopilado 50 imágenes en el directorio de trenes y 10 imágenes en el directorio de prueba. Cuanto mayor sea el número de imágenes, mejor será la precisión de su clasificador.

  Imágenes en directorio de trenes

  

  Imágenes en el directorio de prueba

  

• Punto de control 2: etiquetar el conjunto de datos:
  para cruzar este punto de control, necesitamos tener una herramienta llamada labelimg . Puede obtenerlo desde: descarga de labelimg

  Abra la aplicación labelimg y comience a dibujar los cuadros rectos en la imagen donde esté presente el objeto. Y etiquételos con un nombre apropiado como se muestra en la figura:
  
  

  Guarde cada imagen después de etiquetarla, lo que genera un archivo xml con el nombre de la imagen respectiva, como se muestra en la imagen a continuación.
  

• Punto de control 3: Generación de registros para el entrenamiento:
  Para cruzar este punto de control, necesitamos crear TFRecords que puedan servir como datos de entrada para el entrenamiento del detector de objetos. Para crear los TFRecords, utilizaremos dos scripts del Racoon Detector de Dat Tran . A saber, los archivos xml_to_csv.py y generate_tfrecord.py . Descárguelos y guárdelos en la carpeta object_detection.

  reemplace el método main() de xml_to_csv.py con el siguiente código:

  def main():
      for folder in ['train', 'test']:
          image_path = os.path.join(os.getcwd(), ('images/' + folder))
          xml_df = xml_to_csv(image_path)
          xml_df.to_csv(('images/'+folder+'_labels.csv'), index=None)
          print('Successfully converted xml to csv.')

  Y también, agregue las siguientes líneas de código en el método xml_to_csv() antes de la declaración de devolución como se muestra en la figura a continuación.

  names=[]
      for i in xml_df['filename']:
          names.append(i+'.jpg')
      xml_df['filename']=names

  
  Primero, convirtamos todos los archivos XML en archivos CSV ejecutando el archivo xml_to_csv.py con el siguiente comando en el directorio object_detection:

  python xml_to_csv.py

  Esto crea archivos test.csv y train.csv en la carpeta de imágenes.

  Luego, abra el archivo generate_tfrecord.py en un editor de texto y edite el método class_text_to_int() que se puede encontrar en la línea 30 como se muestra en la imagen a continuación.

  

  Luego, genere los archivos TFRecord emitiendo estos comandos desde la carpeta \object_detection:

  python generar_tfrecord.py --csv_input=images\train_labels.csv --image_dir=images\train --output_path=train.record
  python generar_tfrecord.py --csv_input=images\test_labels.csv --image_dir=images\test --output_path=test.record

  Esto crea archivos test.record y train.record en el directorio object_detection.

• Punto de verificación 4: Configuración de la capacitación:

  Para cruzar este punto de control, primero debemos crear un mapa de etiquetas.

  Cree un nuevo directorio llamado entrenamiento dentro del directorio object_detection.

  Use un editor de texto para crear un nuevo archivo y guárdelo como labelmap.pbtxt en el directorio de capacitación. El mapa de etiquetas le dice al entrenador qué es cada objeto al definir un mapeo de nombres de clase a números de ID de clase.
  Ahora, agregue contenido en el archivo labelmap.pbtxt en el siguiente formato para crear un mapa de etiquetas para su clasificador.

  item {
    id: 1
    name: 'shoe'
  }
  
  item {
    id: 2
    name: 'bottle'
  }

  Los números de identificación del mapa de etiquetas deben ser los mismos que los definidos en el archivo generate_tfrecord.py .

  ¡Ahora comencemos a configurar el entrenamiento!

  Necesitamos un modelo, es decir, un algoritmo para entrenar nuestro clasificador. En este proyecto vamos a utilizar el modelo más rápido_rcnn_inception . La API de detección de objetos de Tensorflow viene con una gran cantidad de modelos. Navegue hasta object_detection\samples\configs .
  En esta ubicación puede encontrar una gran cantidad de archivos de configuración para todos los modelos proporcionados por la API. Puedes descargar el modelo a través de este enlace . Descarga el archivo más rápido_rcnn_inception_v2_coco . Una vez finalizada la descarga, extraiga la carpeta más rápido_rcnn_inception_v2_coco_2018_01_28 al directorio de detección de objetos. Para comprender el funcionamiento del modelo, consulte este artículo .

  Como estamos usando el modelo más rápido_rcnn_inception_v2_coco en este proyecto, copie el archivo más rápido_rcnn_inception_v2_coco.config de object_detection\samples\configs y péguelo en el directorio de entrenamiento creado anteriormente.
  Use un editor de texto para abrir el archivo de configuración y realice los siguientes cambios en el archivo fast_rcnn_inception_v2_pets.config.
  Nota: Las rutas deben ingresarse con barras diagonales simples (NO barras diagonales inversas), o TensorFlow generará un error de ruta de archivo al intentar entrenar el modelo. Además, las rutas deben estar entre comillas dobles ( ” ), no entre comillas simples ( ‘ ).

  • Línea 10: establezca el valor num_classes en la cantidad de objetos que clasifica su clasificador. En mi caso, como estoy clasificando zapatos y botellas sería num_classes: 2.
  • En la línea 107: Proporcione la ruta absoluta del archivo model.ckpt al parámetro file_tuning_checkpoint . El archivo model.ckpt está presente en la ubicación. En mi caso,

    fine_tune_checkpoint: «F:/Programación/geeksforgeeks_project/models-master/research/object_detection/faster_rcnn_inception_v2_coco_2018_01_28/model.ckpt»

  • Sección train_input_reader: puede encontrar esta sección en la línea 120. En esta sección, establezca el parámetro input_path en su archivo train.record. En mi caso es
    input_path: “F:/Programming/geeksforgeeks_project/models-master/research/object_detection/train.record”.

    Establezca el parámetro label_map_path en el archivo labelmap.pbtxt. En mi caso es:
    label_map_path: “F:/Programming/geeksforgeeks_project/models-master/research/object_detection/training/labelmap.pbtxt”

  • Sección eval config: puede encontrar esta sección en la línea 128. Establezca el parámetro num_examples en el número de imágenes presentes en el directorio de prueba. En mi caso,
    num_examples: 10
  • Sección eval_input_reader: puede encontrar esta sección en la línea 134. Similar a la sección train_input_reader, establezca las rutas a los archivos test.record y labelmap.pbtxt. En mi caso,
    input_path: “F:/Programming/geeksforgeeks_project/models-master/research/object_detection/train.record”

    label_map_path: “F:/Programación/geeksforgeeks_project/models-master/research/object_detection/training/labelmap.pbtxt”

  Con esto todas las configuraciones están hechas y vamos a llegar a nuestro último punto de control.

• Punto de verificación 5: Entrenamiento del modelo:
  Finalmente ha llegado el momento de entrenar nuestro modelo. Puede encontrar un archivo llamado train.py en la ubicación object_detection/legacy/.

  Copie el archivo train.py y péguelo en el directorio object_detection.
  ¡Navegue al directorio object_detection y ejecute el siguiente comando para comenzar a entrenar su modelo!

  python train.py --logtostderr --train_dir=training/ --pipeline_config_path=training/faster_rcnn_inception_v2_coco.config
  

  Se tarda alrededor de 1 minuto en inicializar la configuración antes de que comience el entrenamiento. Cuando comienza el entrenamiento, se ve así:
  

  Tensorflow crea un punto de control cada 5 minutos y lo almacena. Puede ver que todos los puntos de control se guardan en el directorio de entrenamiento.
  
  Puede ver el progreso del trabajo de entrenamiento usando TensorBoard. Para hacer esto, abra un nuevo símbolo del sistema y navegue hasta el directorio object_detection, y emita el siguiente comando:

  tensorboard --logdir=training

  Tensorboard se parece a:
  

  Continuar el proceso de entrenamiento hasta que la pérdida sea menor o igual a 0,1.

• Punto de control 6: Exportar gráfico de inferencia:
  este es el último punto de control que se cruzará para llegar al destino.
  Ahora que tenemos un modelo entrenado, necesitamos generar un gráfico de inferencia, que se puede usar para ejecutar el modelo. Para hacerlo, primero debemos averiguar el número de paso guardado más alto. Para esto, necesitamos navegar al directorio de entrenamiento y buscar el archivo model.ckpt con el índice más grande.

  Luego podemos crear el gráfico de inferencia escribiendo el siguiente comando en la línea de comando.

  python export_inference_graph.py --input_type image_tensor --pipeline_config_path training/faster_rcnn_inception_v2_coco.config --trained_checkpoint_prefix training/model.ckpt-XXXX --output_directory inference_graph

  XXXX debe llenarse con el número de punto de control más alto.
  Esto crea un archivo frozen_inference_graph.pb en la carpeta \object_detection\inference_graph. El archivo .pb contiene el clasificador de detección de objetos.

Con esto, hemos terminado de construir nuestro clasificador. Lo único que queda para terminar nuestra aventura es usar nuestro modelo para detectar objetos.

cree un archivo python en el directorio object_detection con el siguiente código:

# Write Python3 code here
import os
import cv2
import numpy as np
import tensorflow as tf
import sys
  
# This is needed since the notebook is stored in the object_detection folder.
sys.path.append("..")
  
# Import utilites
from utils import label_map_util
from utils import visualization_utils as vis_util
  
# Name of the directory containing the object detection module we're using
MODEL_NAME = 'inference_graph' # The path to the directory where frozen_inference_graph is stored.
IMAGE_NAME = '11man.jpg'  # The path to the image in which the object has to be detected.
  
# Grab path to current working directory
CWD_PATH = os.getcwd()
  
# Path to frozen detection graph .pb file, which contains the model that is used
# for object detection.
PATH_TO_CKPT = os.path.join(CWD_PATH, MODEL_NAME, 'frozen_inference_graph.pb')
  
# Path to label map file
PATH_TO_LABELS = os.path.join(CWD_PATH, 'training', 'labelmap.pbtxt')
  
# Path to image
PATH_TO_IMAGE = os.path.join(CWD_PATH, IMAGE_NAME)
  
# Number of classes the object detector can identify
NUM_CLASSES = 2
  
# Load the label map.
# Label maps map indices to category names, so that when our convolution
# network predicts `5`, we know that this corresponds to `king`.
# Here we use internal utility functions, but anything that returns a
# dictionary mapping integers to appropriate string labels would be fine
label_map = label_map_util.load_labelmap(PATH_TO_LABELS)
categories = label_map_util.convert_label_map_to_categories(
        label_map, max_num_classes = NUM_CLASSES, use_display_name = True)
category_index = label_map_util.create_category_index(categories)
  
# Load the Tensorflow model into memory.
detection_graph = tf.Graph()
with detection_graph.as_default():
    od_graph_def = tf.GraphDef()
    with tf.gfile.GFile(PATH_TO_CKPT, 'rb') as fid:
        serialized_graph = fid.read()
        od_graph_def.ParseFromString(serialized_graph)
        tf.import_graph_def(od_graph_def, name ='')
  
    sess = tf.Session(graph = detection_graph)
  
# Define input and output tensors (i.e. data) for the object detection classifier
  
# Input tensor is the image
image_tensor = detection_graph.get_tensor_by_name('image_tensor:0')
  
# Output tensors are the detection boxes, scores, and classes
# Each box represents a part of the image where a particular object was detected
detection_boxes = detection_graph.get_tensor_by_name('detection_boxes:0')
  
# Each score represents level of confidence for each of the objects.
# The score is shown on the result image, together with the class label.
detection_scores = detection_graph.get_tensor_by_name('detection_scores:0')
detection_classes = detection_graph.get_tensor_by_name('detection_classes:0')
  
# Number of objects detected
num_detections = detection_graph.get_tensor_by_name('num_detections:0')
  
# Load image using OpenCV and
# expand image dimensions to have shape: [1, None, None, 3]
# i.e. a single-column array, where each item in the column has the pixel RGB value
image = cv2.imread(PATH_TO_IMAGE)
image_expanded = np.expand_dims(image, axis = 0)
  
# Perform the actual detection by running the model with the image as input
(boxes, scores, classes, num) = sess.run(
    [detection_boxes, detection_scores, detection_classes, num_detections],
    feed_dict ={image_tensor: image_expanded})
  
# Draw the results of the detection (aka 'visualize the results')
  
vis_util.visualize_boxes_and_labels_on_image_array(
    image,
    np.squeeze(boxes),
    np.squeeze(classes).astype(np.int32),
    np.squeeze(scores),
    category_index,
    use_normalized_coordinates = True,
    line_thickness = 8,
    min_score_thresh = 0.60)
  
# All the results have been drawn on the image. Now display the image.
cv2.imshow('Object detector', image)
  
# Press any key to close the image
cv2.waitKey(0)
  
# Clean up
cv2.destroyAllWindows()

Dé la ruta a la imagen en la que se detectará el objeto en la línea 17.

A continuación se muestran algunos de los resultados de mi modelo.

Así que finalmente nuestro modelo está listo. Este modelo también se ha utilizado para construir un motor de búsqueda basado en imágenes, que busca utilizando entradas de imágenes detectando objetos en la imagen.