Aprendizaje profundo con Python OpenCV

Opencv 3.3 viene con un módulo ( dnn ) muy mejorado y eficiente que lo hace ideal para usar el aprendizaje profundo con OpenCV. Todavía no puede entrenar modelos en OpenCV, y probablemente no tengan ninguna intención de hacer algo así, pero ahora puede usar fácilmente el procesamiento de imágenes y usar los modelos pre-entrenados para hacer predicciones usando el módulo dnn .

Esta nueva versión es compatible con una serie de grandes marcos que incluyen: 

1. tensorflow 
2. Antorcha
3. café

Objetivo 

En este artículo, lo guiaremos a través de todo el proceso de usar un modelo previamente entrenado, cargarlo usando el módulo dnn , preprocesar imágenes usando el método blobfromImage en OpenCV y finalmente hacer predicciones.

Hay dos formas de cargar modelos desde marcos en OpenCV: 

1. Si desea importar el modelo directamente, use cv2.dnn.createCaffeImporter o cambie el caffe a Torch o Tensorflow, según el marco que esté usando.
2. Si desea cargar desde el disco, use cv2.dnn.readNetFromCaffe 

 

Tomaremos el modelo de café Mobile_net_ssd para la detección de objetos como ejemplo para comprender cómo funciona el módulo dnn. Y usaremos el segundo enfoque, es decir, descargando los archivos del modelo y cargando el modelo usando el módulo dnn .

Descargue los archivos del modelo e instale las dependencias

Puede descargar el modelo mobile_net_ssd aquí: https://github.com/chuanqi305/MobileNet-SSD/

pip install opencv-python dlib imutils

Cargue el modelo: 

Como estamos usando el modelo caffe , usaremos el módulo cv2.dnn.readNetFromCaffe para cargar nuestro modelo. Necesitará estos dos tipos de archivos para trabajar con cualquier modelo previamente entrenado usando el módulo dnn: 

1. Archivo .prototxt : básicamente contienen una lista de las capas de red en el modelo que está utilizando.
2. Archivo caffemodel (en su caso puede que no sea un modelo Caffe): Este archivo contiene los pesos del modelo.

Necesita ambos archivos para crear el modelo, pasaremos estos dos archivos como argumentos al módulo cv2.dnn.readNetFromCaffe para crear nuestro modelo.

#—–Rutas de los archivos del modelo——–#

proto_file = ‘Modelo/MobileNetSSD_deploy.prototxt.txt’

model_file = ‘Modelo/MobileNetSSD_deploy.caffemodel’

Ahora que tenemos las rutas de nuestros archivos, cargaremos nuestro modelo: 

#———Cargar el modelo——–#

net = cv2.dnn.readNetFromCaffe(proto_file,model_file)

Antes de usar este modelo para la predicción, debemos preprocesar nuestra imagen para configurarla según los requisitos de la entrada de nuestro modelo, y esto difiere de un modelo a otro.

Preprocesamiento de imágenes 

Así que definiremos algunas variables para el preprocesamiento de imágenes.

#——Etiquetas de clase del modelo——–#

classNames = { 0: ‘fondo’,

    1: ‘avión’, 2: ‘bicicleta’, 3: ‘pájaro’, 4: ‘barco’,

    5: ‘botella’, 6: ‘autobús’, 7: ‘coche’, 8: ‘gato’, 9: ‘silla’,

    10: ‘vaca’, 11: ‘mesa de comedor’, 12: ‘perro’, 13: ‘caballo’,

    14: ‘moto’, 15: ‘persona’, 16: ‘planta en maceta’,

    17: ‘oveja’, 18: ‘sofá’, 19: ‘tren’, 20: ‘tvmonitor’ }

#——–Parámetros de escala——#

input_shape=(300,300) #la forma requerida para que la imagen de entrada pase a nuestro modelo

mean = (127.5,127.5,127.5) #tendremos que normalizar los píxeles de la imagen y usaremos este valor medio para hacerlo

scale = 0.007843 # luego finalmente escalaremos la imagen para cumplir con los criterios de entrada del modelo

El módulo dnn nos proporciona el método blobFromImage (o blobFromImages si está usando varias imágenes) para los pasos de preprocesamiento y solo tenemos que pasar los parámetros de escala que definimos anteriormente para completar el paso de preprocesamiento y obtener el blob requerido, es decir imagen de entrada

#——preprocesamiento de imagen—-#

blob = cv2.dnn.blobFromImage(img,

                             factor de escala = escala,

                             tamaño=entrada_forma,

                             medio = medio,

                             swapRB=True) #dado que nuestra imagen ya está en formato BGR porque opencv por defecto la lee en formato BGR

Hacer predicciones usando el modelo

Ahora que tenemos nuestra entrada lista, tenemos que configurarla explícitamente como entrada usando el método setInput() y luego pasarla a nuestro modelo y usar el método de avance para generar predicciones.

#——configuración de entrada—–#

net.setInput(blob)

#—–utilizando el modelo para hacer predicciones

resultados = net.forward()

El método directo nos devuelve una lista de 4 dimensiones: 

La tercera dimensión tiene nuestras predicciones, y cada predicción es una lista de 7 valores flotantes. En el índice 1 tenemos el class_id, en el índice 2 tenemos la confianza/probabilidad y del índice 3 al 6 tenemos las coordenadas del objeto detectado.

Veamos directamente cómo se usan en nuestra implementación final.

A continuación se muestra la implementación completa

import cv2
import dlib
from imutils import face_utils
 
img = cv2.imread('object (1).png')
 
#--------Model Path---------#
proto_file = 'SSD_MobileNet_prototxt.txt'
model_file = 'SSD_MobileNet.caffemodel'
 
#------Variables for the Model ---------#
classNames = {0: 'background',
              1: 'aeroplane', 2: 'bicycle',
              3: 'bird', 4: 'boat',
              5: 'bottle', 6: 'bus', 7: 'car',
              8: 'cat', 9: 'chair',
              10: 'cow', 11: 'diningtable',
              12: 'dog', 13: 'horse',
              14: 'motorbike', 15: 'person',
              16: 'pottedplant',
              17: 'sheep', 18: 'sofa',
              19: 'train', 20: 'tvmonitor'}
 
input_shape = (300, 300)
mean = (127.5, 127.5, 127.5)
scale = 0.007843
 
#---------Load The Model--------#
net = cv2.dnn.readNetFromCaffe(proto_file, model_file)
 
#------image preprocessing----#
blob = cv2.dnn.blobFromImage(img,
                             scalefactor=scale,
                             size=input_shape,
                             mean=mean,
                             swapRB=True) 
# since our image is already in the BGR form
 
net.setInput(blob)
results = net.forward()
for i in range(results.shape[2]):
   
      # confidence
    confidence = round(results[0, 0, i, 2],2)
    if confidence > 0.7:
       
          # class id
        id = int(results[0, 0, i, 1]) 
         
        # 3-6 contains the coordinate
        x1, y1, x2, y2 = results[0, 0, i, 3:7] 
         
        # print(x1,y1,x2,y2)
        # scale these coordinates to out image pixel
        ih, iw, ic = img.shape
        x1, x2 = int(x1*iw), int(x2*iw)
        y1, y2 = int(y1 * ih), int(y2 * ih)
        cv2.rectangle(img,
                      (x1, y1),
                      (x2, y2),
                      (0, 200, 0), 2)
        cv2.putText(img, f'{classNames[id]}:{confidence*100}',
                    (x1+30, y1-30),
                    cv2.FONT_HERSHEY_DUPLEX,
                    1, (255, 0, 0), 1)
    # print(results[0,0,i,:])
 
img = cv2.resize(img, (640, 720))
cv2.imshow('Image', img)
# cv2.imwrite('output1.jpg',img) # Uncomment this line to save the output
cv2.waitKey()

Producción:

 

¿Qué sigue? 

Ahora que sabe cómo usar modelos preentrenados, intente usar varios modelos preentrenados de diferentes marcos y cree diferentes aplicaciones como traducción de idiomas, segmentación de imágenes, transferencia de estilo, etc.