Predicción con redes neuronales convolucionales (CNN)

por | Nov 24, 2019

Una de las aplicaciones mas importantes de redes neuronales es la clasificación de imágenes. La razón para utilizar una red neuronal (en vez de otros algoritmos) es muy sencilla; al tratarse de imágenes, red convucional (CNN por sus siglas en inglés) funcionan mejor que cualquier otro algoritmo.

En este artículo, vamos a ver la siguiente lista de puntos:

  1. Repaso rápido de CNN.
  2. Datos e implementación de CNN.
  3. Entrenamiento de CNN.
  4. Evaluación de CNN.
  5. Próximos pasos.

Antes de continuar, asegúrate de que tienes claros los conceptos de machine learning y deep learning, además del funcionamiento de los pasos previos a entrenar un algoritmo.

Repaso rápido de redes neuronales

A grandes rasgos, existen tres tipos (más utilizados) de redes neuronales, a saber:

  • redes neuronales estándares (SNN ó DNN).
  • redes neuronales convolucionales (CNN).
  • redes neuronales recurrentes (RNN).

Las redes neuronales convolucionales son una ampliación de las redes neuronales estándares. Ojo a esto, decimos que es una ampliación y no una modificación. La siguiente imagen representa una red neuronal estándar.

red neuronal estándar

La ampliación consiste en añadir más capas al principio de la red, que se encargarán de manipular los píxeles de las imágenes. En dicha ampliación, existen dos tipos de capas:

  • capas de convolución (convolutional layers).
  • capas de pooling (pooling layers).

La siguiente imagen representa una red neuronal convolucional:

red convolucional

La capa de convolución tiene como objetivo extraer los rasgos característicos de una imagen. Dichos rasgos se extraen aplicando filtros (kernels) para cada capa convolucional. La siguiente animación representa el funcionamiento de una capa convolucional.

convolución

donde el kernel es la siguiente matriz:

kernel

Por otro lado, la capa de pooling se encarga extraer los píxeles más representativos de una franja delimitada de una imagen. La siguiente animación representa el funcionamiento de una capa de max pooling.

max pooling

Datos e implementación de CNN

Asegúrate antes de continuar que tienes instaladas las siguientes dependencias:

  • Navegador Anaconda
  • librería tensorflow: lo puedes instalar ejecutando el comando conda install tensorflow en la consola
  • librería keras: lo puedes instalar ejecutando el comando conda install keras en la consola

En esta ocasión, vamos a utilizar el dataset llamado CIFAR10 que contiene 60000 imágenes de 10 categorías.

cifar

Tanto el dataset como la red neuronal la implementaremos utilizando la librería keras. Por lo tanto, con las siguientes líneas de código importamos tanto el dataset como todas las herramientas.

from keras.datasets import cifar10
from keras.models import Sequential
from keras.layers import Dense, Conv2D, MaxPooling2D, Dropout, Flatten
import matplotlib.pyplot as plt

(X_train, y_train), (X_test, y_test) = cifar10.load_data()

#normalizamos tanto X_train como X_test
X_train = X_train/255
X_test = X_test/255

donde además, hemos normalizado X_train y X_test diviéndolo entre el valor máximo de los píxeles 255. Las siguientes líneas de código definen tanto las capas como todas las propiedades de la red neuronal.

#iniciamos el modelo
model = Sequential()
#añadimos una capa convolucional con 32 filtros de 3x3
model.add(Conv2D(32, (3, 3), padding='same', activation='relu', input_shape = x_train.shape[1:]))
#añadimos otra capa convolucional con 32 filtros de 3x3
model.add(Conv2D(32, (3, 3), activation='relu'))
#añadimos una capa de pooling de 2x2
model.add(MaxPooling2D(pool_size=(2, 2)))
#este dropout desactiva el 25% de las conexiones entre las neuronas, lo cual mejora los resultados
model.add(Dropout(0.25))

#repetimos todas las capas otra vez
model.add(Conv2D(64, (3, 3), padding='same', activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

#repetimos todas las capas otra vez
model.add(Conv2D(64, (3, 3), padding='same', activation='relu'))
model.add(Conv2D(64, (3, 3), activation='relu'))
model.add(MaxPooling2D(pool_size=(2, 2)))
model.add(Dropout(0.25))

#añadimos una capa para convertir las matrices en un vector
model.add(Flatten())
#añadimos una capa con 512 neuronas
model.add(Dense(512, activation='relu'))
model.add(Dropout(0.5))
#en la última capa tiene que hacer tantas neuronas como clases haya, en este caso 10
model.add(Dense(10, activation='softmax'))



#compilamos el modelo
model.compile(loss='sparse_categorical_crossentropy',
              optimizer='adam',
              metrics=['accuracy'])

Entrenamiento de CNN

Ahora que hemos compilado la CNN, podemos ponerla en marcha para que empiece a aprender.

size_batch = 256
epocas = 100
history = model.fit(X_train, y_train, batch_size= size_batch, epochs=epocas, verbose=1)

donde le hemos indicado que queremos procesar las imágenes en lotes de 256 (para no cargar las 50000 imágenes de golpe) y queremos que la red recorra la fase de entrenamiento (epocas100 veces. Si ejecutamos el anterior código obtendremos el siguiente output.

Epoch 1/100
50000/50000 [==============================] - 5s 96us/step - loss: 0.7472 - acc: 0.7369
Epoch 2/100
50000/50000 [==============================] - 5s 95us/step - loss: 0.7129 - acc: 0.7511
...
...
...
...
...
Epoch 99/100
50000/50000 [==============================] - 5s 93us/step - loss: 0.3189 - acc: 0.8858
Epoch 100/100
50000/50000 [==============================] - 5s 94us/step - loss: 0.3209 - acc: 0.8872

Como vemos, en la primera ronda (época, mejor dicho) la accuracy era de 73.69%, pero al completar las cien rondas ha alcanzado un máximo de 88.72%. No olvidemos que esto era solo el entrenamiento, ahora tenemos que pasar a la fase de clasificación (o la fase de testing).

Evaluación de CNN

Ahora que nuestra red convolucional está entrenada y ha obtenido un máximo de 88.72% se accuracy, pasémonos a la fase de evaluación. Para ello, vamos a decirle a la red que nos clasifique X_test y, la clasificación que nos ha hecho la CNN la compararemos con nuestro y_test (que son las clasificaciones reales) para ver el grado de aciertos que ha tenido la red.

model.evaluate(X_test, y_test)


10000/10000 [==============================] - 1s 109us/step
[0.5471649462819099, 0.8328]

Es decir, una accuracy de un 83.28%, lo cual no está nada mal.

Próximos pasos

Sabemos que tienes miles de dudas ahora mismo. Te sugerimos la siguiente lista de libros para que puedas seguir aprendiendo sobre las redes neuronales por tu cuenta.

  1. Practical Machine Learning and Image Processing
  2. TensorFlow for Deep Learning
  3. Deep Learning with Python

Además, en Nebulova te ofrecemos tanto masters como cursos avanzados para que te conviertas en un auténtico experto en redes neuronales y algoritmos aún más sofisticados. Contamos con profesores que son unos ‘frikis’ del tema y llevan muchos años activos tanto en sector comercial como académico.

0 comentarios

Enviar un comentario

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *