{"componentChunkName":"component---src-templates-post-template-js","path":"/posts/finding-waldo-with-ai","result":{"data":{"markdownRemark":{"id":"b59dd238-f189-5a35-ad2b-f375e8d43efd","html":"

Visión computacional y deep learning

\n

El campo de la visión computacional es un gran beneficiario del deep learnig, ya que los método basados en esta rama de la inteligencia artificial han superado los métodos estadísticos clásicos llegando a superar de manera sustancial a los métodos tradicionales.

\n
\n\t\n\t
http://www.cs.toronto.edu/~urtasun/courses/CSC2541_Winter17/detection.pdf
\n
\n

Existen algunos algoritmos en la actualidad desempeñando una competencia de precisión, por lo cual actualmente estos son los principales:

\n\n

Darknet YOLO

\n

Para este ejemplo se usará YOLO que presenta una gran capacidad predicativa y rapidez en las predicciones catalogado para uso en tiempo real.

\n
\n\t\n\t
https://pjreddie.com/darknet/yolo/
\n
\n

Se enseñara al algoritmo de detección de objetos a buscar a Waldo mediante ejemplos obtenidos de Google Images y entrenando el algoritmo de YOLO en su versión 2 y 3. Para esto es necesario tener las librerías darknet para ejecutar la red neuronal convolucional. El código fuente del framework darknet se lo encuentra en la siguiente dirección:

\n

(https://github.com/pjreddie/darknet)

\n

Se compila para el sistema operativo respectivo, adicionalmente tener en cuenta el poder las GPU, un entrenamiento sin estas puede demorar hasta semanas dependiendo de la cantidad de clases e imágenes es por eso que es muy recomendable tener GPU con CUDA. Para este ejemplo se usa nodos en Linux con 4 GPU Tesla K80.

\n

Manos a la obra

\n

Inicialmente se procede a clonar el repositorio con el código de este articulo, con los scripts para aumentar el conjunto de imágenes mediante transformaciones y generar los archivos de configuración para la red YOLO v2 y v3:

\n

(https://github.com/FabianBG/finding_waldo_yolo)

\n

En este repositorio se encuentran los siguientes scripts e imágenes usadas para el entrenamiento del buscador de Waldo:

\n\n

Lo primero que necesitamos son los pesos de la red pre-entrenados:

\n\n

El segundo paso es opcional ya que consiste en generar mas imágenes mediante transformaciones, para esto se ejecuta la siguiente linea:

\n
# finding_waldo_yolo/\npython ./image_augmentation.py
\n

Lo que genera las imágenes en la carpeta aug dentro de data. Si se desea aplicar diferentes transformaciones referirse al manual de imgaug (https://imgaug.readthedocs.io/en/latest/)

\n
\n\t\n
\n

Ahora se configura las conjuntos de entrenamiento:

\n
# finding_waldo_yolo/\npython ./proccess_dataset.py [images_location_dir] [darknet_search_path]
\n

Lo que generará dos archivos de texto train.txt y test.txt que contienen las rutas de las imágenes separadas en conjuntos de entrenamiento y pruebas.

\n
\n\t\n
\n

Bien ahora se tiene los datos, se realiza la configuración e la meta-data de la red mediante al archivo waldo.data

\n
# finding_waldo_yolo/waldo.data\n\nclasses = 1 # Número de clases\ntrain  = ./train.txt # Path de el archivo train.txt\nvalid  = ./test.txt # Path de el archivo test.txt\nnames = ./waldo.names # Path del archivo waldo.names\nbackup = ./backup/ # Directorio donde se almacenaran los pesos del entrenamiento
\n

Finalmente se empieza el entrenamiento ejecutando el siguiente comando:

\n
# finding_waldo_yolo\n# YOLOv3\ndarknet detector train ./waldo.data ./yolov3-waldo.cfg ./darknet53.conv.74\n\n# YOLOv2\ndarknet detector train ./waldo.data ./yolov2-waldo.cfg ./darknet19_448.conv.23
\n

Cada versión imprime un salida diferente, pero cada una imprime una salida después da cada epoch iteración similar, en este caso se filtro la salida para solo mostrar el resultado de cada iteración mediante

\n

[comando] | grep images:

\n
\n\t\n
\n
# Salida de entrenamiento\n\n11203: 0.097249, 0.100165 avg, 0.004000 rate, 25.083207 seconds, 2867968 images
\n

En donde los 3 primeros números especifican:

\n\n

Entre menor la perdida mayor precisión, pero tener en cuenta posibles sobre ajustes de la red por esto probar con diferentes pesos generados automáticamente, YOLO genera por defecto pesos para 400, 800 y de ahí en adelante de 10000 en 10000 y el archivo de backup donde esta en la iteración actual. Con esto es posible detener el entrenamiento y empezarlo nuevamente haciendo uso de este archivo de backup.

\n
\n\t\n
\n

Se obtendrá una serie de archivos de pesos con los cuales podremos probar cuales son los mejores y mas estables sin sobre ajuste mediante pruebas con las imágenes en a carpeta de validate/ para probar los pesos simplemente se ejecuta el siguiente comando:

\n
# Darknet instalation folder\n./darknet detector test cfg/waldo.data \\ \n                        cfg/yolov2-waldo.cfg \\\n                        [path_weights]/yolov2-waldo_10000.weights \\\n                        [path_finding_waldo_yolo]/validate/1.jpg
\n
\n\t\n
\n

Se mostrará en una ventana la imagen con la predicción, mediante esta prueba se puede saber que pesos son los mas adecuados para generalizar mejor la búsqueda. Peor existe un problema YOLO no tiene mucha capacidad predictiva sobre objetos pequeños ya que se re dimensiona la imagen de entrada a predecir por lo que se pierden detalles en imágenes sumamente grandes por lo que se genero un script que genera una ventana de recorrido y genera predicciones por cada ventana mostrando los resultados finales.

\n
# finding_waldo.py\nimport os\nimport sys\nimport cv2 as cv\nimport python.darknet as dn\nimport pdb\n\nsys.path.append(os.path.join('/home/mbastidas/git/darknet/python/'))\n\nweigths = sys.argv[2]\nconfig = sys.argv[3]\nfile_dir = sys.argv[1]\nparts = int(sys.argv[4])\n\ndef convert_axis(size, box):\n    dw = 1./size[0]\n    dh = 1./size[1]\n    x = box[0]/dw\n    w = box[2]/dw\n    y = box[1]/dh\n    h = box[3]/dh\n\n    b1 = x + (w/2)\n    b3 = y + (h/2)\n    b0 = x + (w/2) - w\n    b2 = y + (h/2) - h\n\n    return (b0, b1, b2, b3)\n\ndef divide_image(file_dir, parts):\n    padding = 50\n    names = []\n    image = cv.imread(file_dir)\n    shape = image.shape\n    partes = int(int(parts / 2))\n    print("Dividiendo imagen", file_dir, shape, "en", partes*2)\n    for i in range(0, partes):\n        w = int(shape[1] / partes)\n        x = int(i * w)\n        w = x + w + padding\n        for j in range(0, partes):\n            h = int(shape[0] / partes)\n            y = int(j * h)\n            h = y + h + padding\n            print(x, w, y, h)\n            if i == partes and j == partes:\n                part = image[y:shape[0], x:shape[1]]\n            else:\n                part = image[y:h, x:w]\n            name = "./" + str(x) + "_" + str(y) + ".jpg"\n            cv.imwrite(name, part)\n            names.append(name)\n    return image, names, (int(shape[1] / partes), int(shape[0] / partes))\n\ndef draw_box(image, points, part_shape, acc, color=(0, 0, 255)):\n      x = int(points[0] + part_shape[0] - (points[2]/2))\n      y = int(points[1] + part_shape[1] - (points[3]/2))\n      x1 = int(points[2] + x)\n      y1 = int(points[3] + y)\n      print((x,y), (x1,y1))\n      cv.rectangle(image, (x,y), (x1,y - 25), color, -1)\n      cv.putText(image,"%.2f" % round(acc,2),(x,y-15), cv.FONT_HERSHEY_SIMPLEX,\n      1,(255,255,255),2,cv.LINE_AA)\n      cv.rectangle(image, (x,y), (x1,y1), color, 3)\n      print("save on find_waldo_" + file_dir.split("/")[-1])\n      cv.imwrite("./find_waldo_" + file_dir.split("/")[-1], image)\n\n\nimage, names, part_shape = divide_image(file_dir, parts)\nprint(names)\nnet = dn.load_net(config.encode('utf-8'), weigths.encode('utf-8'), 0)\nmeta = dn.load_meta("cfg/waldo.data".encode('utf-8'))\ninsight = None\nboxes = []\npart = None\nfor name in names:\n    #[class, prob, (x,y, w,h)]\n    predictions = dn.detect(net, meta, name.encode('utf-8'))\n    print("Parte", name)\n    os.remove(name)\n    print("Pred", str(len(predictions)))\n    if len(predictions) > 0:\n        if insight == None:\n            insight = predictions[0] \n            part = name[2:].split(".")[0].split("_")\n        for pred in predictions:\n            print(pred)\n            boxes.append({\n            "part": name[2:].split(".")[0].split("_"),\n            "insight": pred\n            })\n            if pred[1] > insight[1]:\n                insight = pred\n                part = name[2:].split(".")[0].split("_")\nprint("Best result", insight, part_shape)\nif insight != None:\n    for box in boxes:\n        draw_box(image, box["insight"][2], (int(box["part"][0]), int(box["part"][1])),\n        box["insight"][1], color=(255, 0, 0))\n    draw_box(image, insight[2], (int(part[0]), int(part[1])), insight[2])\nelse:\n    print("No se encontro nada.")
\n

El script debe estar sobre la carpeta de instalación de darknet ya que hace uso de el wrapper de python para darknet. Este corta una imagen en 4 u 8 secciones y las analiza una por una, graficando todas las predicciones en azul y la mas alta con verde. Este script es especialmente eficaz en imágenes grandes.

\n

Pruebas finales

\n

Se ejecuta el siguiente comando para ejecutar el script anterior sobre las imágenes en la carpeta de validación

\n
# Darknet folder\n#! bin/sh\nfor filename in /home/mbastidas/git/yolo-models/waldo/validate/*\ndo\n        python find_waldo.py $filename results/yolov3-waldo_10000.weights cfg/yolov3-waldo.cfg 4\ndone
\n

Este comando ejecuta el script de python de segmentación y genera un imagen con los resultados marcando con verde la mejor predicción y con azul otras predicciones, cada archivo generado se marca con el prefijo

\n

find_waldo_[nombre_imagen_validacion].jpg

\n

El resultado se lo puede ver por YOUTUBE (https://www.youtube.com/watch?v=6NKX1Bk8TJg)

\n

Conclusiones

\n

YOLO es una forma relativamente simple de generar detectores de objectos con una buena tasa de precisión y de forma rápida (GPU required). YOLOv2 es mas rápido pero tiende a tener menor precisión al contrario que YOLOv3 que presenta una mejoría de precisión pero a su ver aumenta la complejidad de la red lo cual aumenta los tiempos de predicción y entrenamiento.

\n
\n\t\n
\n

Existen casos en los que que erra completamente en la búsqueda porque generalmente para el entrenamiento de algoritmos de deep learning siempre es necesario grandes cantidades de datos, entre mas imágenes se tenga mejor sera la precisión del mismo, como mejoría la trabajo actual se propone aumentar el conjunto de imágenes y probar con mas datos.

\n

Finalmente no solo YOLO existe actualmente, hay algoritmos que están compitiendo constantemente por mejorar su tasa de precisión por lo que vale estar al día en la evolución e las arquitecturas y mejoras de todos.

","fields":{"slug":"/posts/finding-waldo-with-ai","tagSlugs":["/tag/tutorial/","/tag/yolo/","/tag/ai/","/tag/image-detection/"]},"frontmatter":{"date":"2018-09-21T10:40:32.169Z","description":"Tutorial para reconocer placas mediante inteligencia artificial","tags":["Tutorial","YOLO","AI","Image detection"],"title":"Buscando a Waldo con Deep Learning","socialImage":"https://media-exp1.licdn.com/dms/image/C5612AQGIlCs485VfeA/article-cover_image-shrink_600_2000/0?e=1587600000&v=beta&t=OVpDTxmesVpY1bXQ53hAcxmaCtTG3r1CMz4eiHJ-c4s"}}},"pageContext":{"slug":"/posts/finding-waldo-with-ai"}}}