CÓMO CARGAR Y UTILIZAR UN MODELO DE RECONOCIMIENTO DE OBJETOS PRECONFIGURADO
Las redes neuronales convolucionales son ahora capaces de superar a los humanos en algunas tareas de visión por computador, como la clasificación de imágenes. Es decir, si se le da una fotografía de un objeto, responda a la pregunta de cuál de los 1.000 objetos específicos que muestra la fotografía. Un modelo ganador de la competencia para esta tarea es el modelo VGG de los investigadores de Oxford. Lo importante de este modelo, además de su capacidad de clasificar objetos en fotografías, es que los pesos de los modelos están disponibles libremente y pueden ser cargados y utilizados en sus propios modelos y aplicaciones. En este tutorial, descubrirá los modelos de red neural convolucional VGG para la clasificación de imágenes. Después de completar este tutorial, usted sabrá:
Objetivo del 7º tutorial y clase 3/6 del Curso de Natural Language Processing con Deep Learning
- Sobre el conjunto de datos de ImageNet y el concurso y los modelos ganadores de VGG.
- Cómo cargar el modelo VGG en Keras y resumir su estructura.
- Cómo utilizar el modelo VGG cargado para clasificar objetos en fotografías ad hoc.
Vamos a empezar.
Resumen del Tutorial
Este tutorial se divide en las siguientes partes:
- ImageNet
- Los modelos Oxford VGG
- Cargar el modelo VGG en Keras
- Desarrolle un clasificador fotográfico sencillo
📝 Nota
Keras utiliza la biblioteca de imágenes Python o la biblioteca PIL para manipular imágenes. La instalación en su sistema puede variar.
ImageNet
ImageNet es un proyecto de investigación para desarrollar una gran base de datos de imágenes con anotaciones, por ejemplo, imágenes y sus descripciones. Las imágenes y sus anotaciones han sido la base de un reto de clasificación de imágenes llamado ImageNet Large Scale Visual Recognition Challenge o ILSVRC desde 2010. El resultado es que las organizaciones de investigación luchan en cdatasets predefinidos para ver quién tiene el mejor modelo para clasificar los objetos en imágenes.
Para la tarea de clasificación, las imágenes deben clasificarse en una de las 1.000 categorías diferentes. Durante los últimos años se han utilizado modelos de redes neuronales convolucionales muy profundos para ganar estos desafíos y los resultados en las tareas han superado el rendimiento humano.
Los modelos Oxford VGG
Investigadores del Oxford Visual Geometry Group, o VGG para abreviar, participan en el desafío del ILSVRC. En 2014, los modelos de redes neurales convolucionales (CNN) desarrollados por la VGG ganaron las tareas de clasificación de imágenes.
Después de la competencia, los participantes escribieron sus hallazgos en el artículo Very Deep Convolutional Networks for Large-Scale Image Recognition, 2014. También hicieron sus modelos y pesas aprendidas disponibles en línea. Esto permitió a otros investigadores y desarrolladores utilizar un modelo de clasificación de imágenes de última generación en sus propios trabajos y programas. Esto ayudó a alimentar un aluvión de trabajo de aprendizaje de transferencia en el que se utilizan modelos pre-entrenados con modificaciones menores en tareas de modelado predictivo totalmente nuevas, aprovechando las capacidades de extracción de características de última generación de los modelos probados.
VGG lanzó dos modelos diferentes de CNN, específicamente un modelo de 16 capas y un modelo de 19 capas. Consulte el documento para obtener todos los detalles de estos modelos. Los modelos VGG ya no son de última generación en unos pocos puntos porcentuales. Sin embargo, son modelos muy potentes y útiles tanto como clasificadores de imágenes como base para nuevos modelos que utilizan entradas de imágenes. En la siguiente sección veremos cómo podemos usar el modelo VGG directamente en Keras.
Cargar el modelo VGG en Keras
El modelo VGG puede ser cargado y utilizado en la biblioteca de aprendizaje profundo de Keras. Keras proporciona una interfaz de aplicaciones para la carga y el uso de modelos ya entrenados. Usando esta interfaz, usted puede crear un modelo VGG usando los pesos pre-entrenados proporcionados por el grupo Oxford y usarlo como punto de partida en su propio modelo, o usarlo como modelo directamente para clasificar imágenes. En este tutorial, nos centraremos en el caso de uso de la clasificación de nuevas imágenes utilizando el modelo VGG. Keras proporciona las versiones de 16 y 19 capas a través de las clases VGG16 y VGG19. Centrémonos en el modelo VGG16. El modelo se puede crear como se indica a continuación:
from keras.applications.vgg16 import VGG16 model = VGG16()
Eso es todo. La primera vez que ejecute este ejemplo, Keras descargará los archivos de peso de Internet y los almacenará en el directorio/.keras/models.
📝 Nota
Los pesos son de unos 528 megabytes, por lo que la descarga puede tardar unos minutos dependiendo de la velocidad de su conexión a Internet.
from keras.applications.vgg16 import VGG16 model = VGG16() model.summary()
Puedes ver que el modelo es enorme. También se puede ver que, por defecto, el modelo espera imágenes como entrada con un tamaño de 224 x 224 píxeles con 3 canales (por ejemplo, color).
____________________________________________________ Layer (type) Output Shape Param # ================================================================= input_1 (InputLayer) (None, 224, 224, 3) 0 _________________________________________________________________ block1_conv1 (Conv2D) (None, 224, 224, 64) 1792 _________________________________________________________________ block1_conv2 (Conv2D) (None, 224, 224, 64) 36928 _________________________________________________________________ block1_pool (MaxPooling2D) (None, 112, 112, 64) 0 _________________________________________________________________ block2_conv1 (Conv2D) (None, 112, 112, 128) 73856 _________________________________________________________________ block2_conv2 (Conv2D) (None, 112, 112, 128) 147584 _________________________________________________________________ block2_pool (MaxPooling2D) (None, 56, 56, 128) 0 _________________________________________________________________ block3_conv1 (Conv2D) (None, 56, 56, 256) 295168 _________________________________________________________________ block3_conv2 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ block3_conv3 (Conv2D) (None, 56, 56, 256) 590080 _________________________________________________________________ block3_pool (MaxPooling2D) (None, 28, 28, 256) 0 _________________________________________________________________ block4_conv1 (Conv2D) (None, 28, 28, 512) 1180160 _________________________________________________________________ 23.4. Load the VGG Model in Keras 260 block4_conv2 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ block4_conv3 (Conv2D) (None, 28, 28, 512) 2359808 _________________________________________________________________ block4_pool (MaxPooling2D) (None, 14, 14, 512) 0 _________________________________________________________________ block5_conv1 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ block5_conv2 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ block5_conv3 (Conv2D) (None, 14, 14, 512) 2359808 _________________________________________________________________ block5_pool (MaxPooling2D) (None, 7, 7, 512) 0 _________________________________________________________________ flatten (Flatten) (None, 25088) 0 _________________________________________________________________ fc1 (Dense) (None, 4096) 102764544 _________________________________________________________________ fc2 (Dense) (None, 4096) 16781312 _________________________________________________________________ predictions (Dense) (None, 1000) 4097000 ================================================================= Total params: 138,357,544 Trainable params: 138,357,544 Non-trainable params: 0 _________________________________________________________________
También podemos crear un gráfico de las capas en el modelo VGG, de la siguiente manera:
from keras.applications.vgg16 import VGG16 from keras.utils.vis_utils import plot_model model = VGG16() plot_model(model, to_file='vgg.png')
Una vez más, debido a que el modelo es grande, la trama es un poco demasiado grande y tal vez ilegible.
La clase VGG() toma algunos argumentos que pueden interesarle sólo si está buscando utilizar el modelo en su propio proyecto, por ejemplo, para el aprendizaje transferido. Por ejemplo:
- include_top(True): Si se deben incluir o no las capas de salida para el modelo. No los necesita si está ajustando el modelo a su propio problema.
- weights(‘imagenet’): Qué pesos cargar. Puede especificar Ninguno para no cargar pesas preentrenadas si está interesado en entrenar el modelo usted mismo desde cero.
- input_tensor(Ninguno): Una nueva capa de entrada si desea ajustar el modelo a nuevos datos de un tamaño diferente.
- input_shape(None): El tamaño de las imágenes que se espera que tome el modelo si cambia la capa de entrada.
- pooling (Ninguno): El tipo de pool a utilizar cuando entrena un nuevo conjunto de capas de salida.
- class(1000): El número de clases (por ejemplo, tamaño del vector de salida) para el modelo.
A continuación, veamos el uso del modelo VGG cargado para clasificar fotografías ad hoc.
Desarrollar un clasificador fotográfico sencillo
Vamos a desarrollar un sencillo script de clasificación de imágenes.
Obtener una imagen de muestra
Primero, necesitamos una imagen que podamos clasificar. Puedes descargar una foto al azar de una taza de café de Flickr.
Descargue la imagen y guárdela en su directorio de trabajo actual con el nombre de archivo mug.jpg.
Cargar el modelo VGG
Cargue los pesos para el modelo VGG-16, como hicimos en la sección anterior.
from keras.applications.vgg16 import VGG16 # cargar el modelo model = VGG16()
Cargar y preparar la imagen
A continuación, podemos cargar la imagen como datos de píxeles y prepararla para ser presentada a la red. Keras proporciona algunas herramientas para ayudar en este paso. Primero, podemos usar la función load_img() para cargar la imagen y redimensionarla al tamaño requerido de 224 x 224 píxeles.
from keras.preprocessing.image import load_img
# cargar una imagen desde un archivo
image = load_img('mug.jpg', target_size=(224, 224))
A continuación, podemos convertir los píxeles a una matriz NumPy para que podamos trabajar con ella en Keras. Podemos usar la función img_to_array() para esto
from keras.preprocessing.image import load_img
# cargar una imagen desde un archivo
image = load_img('mug.jpg', target_size=(224, 224))
La red espera una o más imágenes como entrada; esto significa que la matriz de entrada tendrá que ser de 4 dimensiones: muestras, filas, columnas y canales. Sólo tenemos una muestra (una imagen). Podemos remodelar el array llamando a reshape() y añadiendo la dimensión extra.
#remodelar los datos para el modelo image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
A continuación, los píxeles de imagen deben prepararse de la misma manera que se prepararon los datos de formación de ImageNet. Específicamente, del periódico:
Keras proporciona una función llamada preprocess_input() para preparar nuevas entradas para la red.
from keras.applications.vgg16 import preprocess_input # preparar la imagen para el modelo VGG image = preprocess_input(image)
A continuación, podemos convertir los píxeles a una matriz NumPy para que podamos trabajar con ella en Keras. Podemos usar la función img_to_array() para esto.
from keras.preprocessing.image import img_to_array # convierte los píxeles de la imagen en una matriz NumPy image = img_to_array(image)
La red espera una o más imágenes como entrada; esto significa que la matriz de entrada tendrá que ser de 4 dimensiones: muestras, filas, columnas y canales. Sólo tenemos una muestra (una imagen). Podemos remodelar el array llamando a reshape() y añadiendo la dimensión extra.
# remodelar los datos para el modelo image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
A continuación, los píxeles de imagen deben prepararse de la misma manera que se prepararon los datos de formación de ImageNet. Específicamente, del periódico:
Keras proporciona una función llamada preprocess_input() para preparar nuevas entradas para la red.
from keras.applications.vgg16 import preprocess_input # preparar la imagen para el modelo VGG image = preprocess_input(image)
Ahora estamos listos para hacer una predicción para nuestra imagen cargada y preparada.
Haga una predicción
Podemos llamar a la función predict() en el modelo para obtener una predicción de la probabilidad de que la imagen pertenezca a cada uno de los 1.000 tipos de objetos conocidos.
# predecir la probabilidad en todas las clases de salida yhat = model.predict(image)
Interpretar Predicción
Keras proporciona una función para interpretar las probabilidades llamada decodificar predicciones(). Puede devolver una lista de clases y sus probabilidades en caso de que desee presentar los 3 objetos principales que pueden estar en la foto. Sólo reportaremos el primer objeto más probable.
from keras.applications.vgg16 import decode_predictions
# convertir las probabilidades en etiquetas de clase
label = decode_predictions(yhat)
# recuperar el resultado más probable, por ejemplo, la probabilidad más alta
label = label[0][0]
# imprimir la clasificación
print('%s (%.2f%%)'% (label[1], label[2]*100))
Ejemplo completo
Enlazando todo esto, el ejemplo completo se muestra a continuación:
from keras.preprocessing.image import load_img
from keras.preprocessing.image import img_to_array
from keras.applications.vgg16 import preprocess_input
from keras.applications.vgg16 import decode_predictions
from keras.applications.vgg16 import VGG16
# cargar el modelo
model = VGG16()
# cargar imagen desde el archivo
image = load_img('mug.jpg', target_size=(224, 224))
# remodelar los datos para el modelo
image = img_to_array(image)
# preparar la imagen para el modelo VGG
image = image.reshape((1, image.shape[0], image.shape[1], image.shape[2]))
# predecir la probabilidad en todas las clases de salida
image = preprocess_input(image)
# convertir las probabilidades en etiquetas de clase
yhat = model.predict(image)
# convert the probabilities to class labels
label = decode_predictions(yhat)
# recuperar el resultado más probable, por ejemplo, el más alto
label = label[0][0]
# imprimir la clasificación
print('%s (%.2f%%)'% (label[1], label[2]*100))
Al ejecutar el ejemplo, podemos ver que la imagen está correctamente clasificada como una taza de café con un 75% de probabilidad.
📝 Nota
Dada la naturaleza estocástica de las redes neuronales, sus resultados específicos pueden variar. Considere la posibilidad de ejecutar el ejemplo unas cuantas veces.
coffee_mug (75.27%)
➡ Aprende mucho mas con nuestro curso:
No hay comentarios:
Publicar un comentario