Clasificación de imágenes mediante CNN: implementación de Python

Contenidos

Este artículo fue publicado como parte del Blogatón de ciencia de datos

¡Hola chicos! En este blog, voy a discutir todo sobre la clasificación de imágenes.

En los últimos años, Deep Learning ha demostrado que es una herramienta muy poderosa debido a su capacidad para manejar grandes cantidades de datos. El uso de capas ocultas supera las técnicas tradicionales, especialmente para el reconocimiento de patrones. Una de las redes neuronales profundas más populares son las redes neuronales convolucionales (CNN).

46151deep_learning_software_de_1380x735px_1150x_-8179956

Una red neuronal convolucional (CNN) es un tipo de Red neuronal artificial (ANN) utilizado en el reconocimiento y procesamiento de imágenes, que está especialmente diseñado para procesar datos (píxeles).

87612082918_1325_convnetconv1-3625425

Fuente de la imagen: Google.com

Antes de seguir adelante, debemos comprender qué es la red neuronal. Vamos…

Red neuronal:

Una red neuronal se construye a partir de varios nodos interconectados llamados «Neuronas». Las neuronas están dispuestas en capa de entrada, capa oculta y capa de salida. La capa de entrada corresponde a nuestros predictores / características y la capa de salida a nuestras variables de respuesta.

27250neural-network-1719512

Fuente de la imagen: Google.com

Perceptrón multicapa (MLP):

La red neuronal con una capa de entrada, una o más capas ocultas y una capa de salida se llama perceptrón multicapa (MLP). MLP es inventado por Frank Rosenblatt en el año de 1957. MLP que se muestra a continuación tiene 5 nodos de entrada, 5 nodos ocultos con dos capas ocultas y un nodo de salida

49705nn-7229061

Fuente de la imagen: Google.com

¿Cómo funciona esta red neuronal?

– Las neuronas de la capa de entrada reciben información entrante de los datos que procesan y distribuyen al capas ocultas.

– Esa información, a su vez, es procesada por capas ocultas y se pasa a la salida. neuronas.

– La información de esta red neuronal artificial (ANN) se procesa en términos de una función de activación. Esta función en realidad imita a las neuronas del cerebro.

– Cada neurona contiene un valor de funciones de activación y un valor umbral.

– Los valor umbral es el valor mínimo que debe poseer la entrada para que pueda ser activada.

– La tarea de la neurona es realizar una suma ponderada de todas las señales de entrada y aplicar la función de activación sobre la suma antes de pasarla a la siguiente capa (oculta o de salida).

Entendamos qué es la suma de ponderación.

Digamos que tenemos valores 𝑎1, 𝑎2, 𝑎3, 𝑎4 para la entrada y pesos como 𝑤1, 𝑤2, 𝑤3, 𝑤4 como la entrada a una de las neuronas de la capa oculta, digamos 𝑛𝑗, entonces la suma ponderada se representa como

𝑆𝑗 = σ 𝑖 = 1to4 𝑤𝑖 * 𝑎𝑖 + 𝑏𝑗

donde 𝑏𝑗: sesgo debido al nodo

33975ws-2271857

Fuente de la imagen: Google.com

¿Cuáles son las funciones de activación?

Estas funciones son necesarias para introducir una no linealidad en la red. Se aplica la función de activación y esa salida se pasa a la siguiente capa.

* Posibles funciones *

• Sigmoide: la función sigmoidea es diferenciable. Produce una salida entre 0 y 1.

• Tangente hiperbólica: La tangente hiperbólica también es diferenciable. Esto produce una salida entre -1 y 1.

ReLU: ReLU es la función más popular. ReLU se usa ampliamente en el aprendizaje profundo.

• Softmax: la función softmax se utiliza para problemas de clasificación de clases múltiples. Es una generalización de la función sigmoidea. También produce una salida entre 0 y 1

Ahora, vayamos con nuestro tema CNN …

CNN:

Ahora imagina que hay una imagen de un pájaro, y quieres identificarlo si realmente es un pájaro u otra cosa. Lo primero que debe hacer es alimentar los píxeles de la imagen en forma de matrices a la capa de entrada de la red neuronal (las redes MLP se utilizan para clasificar tales cosas). Las capas ocultas llevan la extracción de características mediante la realización de varios cálculos y operaciones. Hay varias capas ocultas como la convolución, el ReLU y la capa de agrupación que realiza la extracción de características de su imagen. Entonces, finalmente, hay una capa completamente conectada que puede ver que identifica el objeto exacto en la imagen. Puede comprender muy fácilmente en la siguiente figura:

20451cnn3-7880418

Fuente de la imagen: Google.com

Circunvolución:-

La operación de convolución implica operaciones aritméticas matriciales y cada imagen se representa en forma de una matriz de valores (píxeles).

Entendamos el ejemplo:

a = [2,5,8,4,7,9]

b = [1,2,3]

En la operación de convolución, las matrices se multiplican uno por uno en cuanto a elementos, y el producto se agrupa o suma para crear una nueva matriz que representa a * b.

Los primeros tres elementos de la matriz a ahora se multiplican por los elementos de la matriz B. El producto se suma para obtener el resultado y se almacena en una nueva matriz de a * b.

Este proceso permanece continuo hasta que se completa la operación.

29760cnn-2359666

Fuente de la imagen: Google.com

Agrupación:

Después de la convolución, hay otra operación llamada agrupación. Entonces, en la cadena, la convolución y la agrupación se aplican secuencialmente en los datos con el fin de extraer algunas características de los datos. Después de las capas convolucionales y agrupadas secuenciales, los datos se aplanan
en una red neuronal de retroalimentación que también se llama perceptrón multicapa.

80513understanding20convolutional20neural20networks20through20visualizations20pytorch20image20classifier-9877439

Fuente de la imagen: Google.com

Hasta este punto, hemos visto conceptos que son importantes para nuestro modelo de construcción de CNN.

Ahora avanzaremos para ver un estudio de caso de CNN.

1) Aquí vamos a importar las bibliotecas necesarias que se requieren para realizar tareas de CNN.

import NumPy as np
%matplotlib inline
import matplotlib.image as mpimg
import matplotlib.pyplot as plt
import TensorFlow as tf
tf.compat.v1.set_random_seed(2019)

2) Aquí requerimos el siguiente código para formar el modelo CNN

model = tf.keras.models.Sequential([
    tf.keras.layers.Conv2D(16,(3,3),activation = "relu" , input_shape = (180,180,3)) ,
    tf.keras.layers.MaxPooling2D(2,2),
    tf.keras.layers.Conv2D(32,(3,3),activation = "relu") ,  
    tf.keras.layers.MaxPooling2D(2,2),
    tf.keras.layers.Conv2D(64,(3,3),activation = "relu") ,  
    tf.keras.layers.MaxPooling2D(2,2),
    tf.keras.layers.Conv2D(128,(3,3),activation = "relu"),  
    tf.keras.layers.MaxPooling2D(2,2),
    tf.keras.layers.Flatten(), 
    tf.keras.layers.Dense(550,activation="relu"),      #Adding the Hidden layer
    tf.keras.layers.Dropout(0.1,seed = 2019),
    tf.keras.layers.Dense(400,activation ="relu"),
    tf.keras.layers.Dropout(0.3,seed = 2019),
    tf.keras.layers.Dense(300,activation="relu"),
    tf.keras.layers.Dropout(0.4,seed = 2019),
    tf.keras.layers.Dense(200,activation ="relu"),
    tf.keras.layers.Dropout(0.2,seed = 2019),
    tf.keras.layers.Dense(5,activation = "softmax")   #Adding the Output Layer
])

Una imagen enrevesada puede ser demasiado grande y, por lo tanto, se reduce sin perder características o patrones, por lo que se realiza la agrupación.

Aquí, Crear una red neuronal es inicializar la red utilizando el modelo secuencial de Keras.

Aplanar (): el aplanamiento transforma una matriz bidimensional de características en un vector de características.

3) Ahora veamos un resumen del modelo de CNN

model.summary()

Imprimirá la siguiente salida

Model: "sequential"
_________________________________________________________________
Layer (type)                 Output Shape              Param #   
=================================================================
conv2d (Conv2D)              (None, 178, 178, 16)      448       
_________________________________________________________________
max_pooling2d (MaxPooling2D) (None, 89, 89, 16)        0         
_________________________________________________________________
conv2d_1 (Conv2D)            (None, 87, 87, 32)        4640      
_________________________________________________________________
max_pooling2d_1 (MaxPooling2 (None, 43, 43, 32)        0         
_________________________________________________________________
conv2d_2 (Conv2D)            (None, 41, 41, 64)        18496     
_________________________________________________________________
max_pooling2d_2 (MaxPooling2 (None, 20, 20, 64)        0         
_________________________________________________________________
conv2d_3 (Conv2D)            (None, 18, 18, 128)       73856     
_________________________________________________________________
max_pooling2d_3 (MaxPooling2 (None, 9, 9, 128)         0         
_________________________________________________________________
flatten (Flatten)            (None, 10368)             0         
_________________________________________________________________
dense (Dense)                (None, 550)               5702950   
_________________________________________________________________
dropout (Dropout)            (None, 550)               0         
_________________________________________________________________
dense_1 (Dense)              (None, 400)               220400    
_________________________________________________________________
dropout_1 (Dropout)          (None, 400)               0         
_________________________________________________________________
dense_2 (Dense)              (None, 300)               120300    
_________________________________________________________________
dropout_2 (Dropout)          (None, 300)               0         
_________________________________________________________________
dense_3 (Dense)              (None, 200)               60200     
_________________________________________________________________
dropout_3 (Dropout)          (None, 200)               0         
_________________________________________________________________
dense_4 (Dense)              (None, 5)                 1005      
=================================================================
Total params: 6,202,295
Trainable params: 6,202,295
Non-trainable params: 0

4) Así que ahora estamos obligados a especificar optimizadores.

from tensorflow.keras.optimizers import RMSprop,SGD,Adam
adam=Adam(lr=0.001)
model.compile(optimizer="adam", loss="categorical_crossentropy", metrics = ['acc'])

El optimizador se usa para reducir el costo calculado por entropía cruzada

La función de pérdida se utiliza para calcular el error.

El término métricas se utiliza para representar la eficiencia del modelo.

5) En este paso, veremos cómo configurar el directorio de datos y generar datos de imagen.

bs=30         #Setting batch size
train_dir = "D:/Data Science/Image Datasets/FastFood/train/"   #Setting training directory
validation_dir = "D:/Data Science/Image Datasets/FastFood/test/"   #Setting testing directory
from tensorflow.keras.preprocessing.image import ImageDataGenerator 
# All images will be rescaled by 1./255.
train_datagen = ImageDataGenerator( rescale = 1.0/255. )
test_datagen  = ImageDataGenerator( rescale = 1.0/255. )
# Flow training images in batches of 20 using train_datagen generator
#Flow_from_directory function lets the classifier directly identify the labels from the name of the directories the image lies in
train_generator=train_datagen.flow_from_directory(train_dir,batch_size=bs,class_mode="categorical",target_size=(180,180))
# Flow validation images in batches of 20 using test_datagen generator
validation_generator =  test_datagen.flow_from_directory(validation_dir,
                                                         batch_size=bs,
                                                         class_mode="categorical",
                                                         target_size=(180,180))

La salida será:

Found 1465 images belonging to 5 classes.
Found 893 images belonging to 5 classes.

6) Paso final del modelo de ajuste.

history = model.fit(train_generator,
                    validation_data=validation_generator,
                    steps_per_epoch=150 // bs,
                    epochs=30,
                    validation_steps=50 // bs,
                    verbose=2)

La salida será:

Epoch 1/30
5/5 - 4s - loss: 0.8625 - acc: 0.6933 - val_loss: 1.1741 - val_acc: 0.5000
Epoch 2/30
5/5 - 3s - loss: 0.7539 - acc: 0.7467 - val_loss: 1.2036 - val_acc: 0.5333
Epoch 3/30
5/5 - 3s - loss: 0.7829 - acc: 0.7400 - val_loss: 1.2483 - val_acc: 0.5667
Epoch 4/30
5/5 - 3s - loss: 0.6823 - acc: 0.7867 - val_loss: 1.3290 - val_acc: 0.4333
Epoch 5/30
5/5 - 3s - loss: 0.6892 - acc: 0.7800 - val_loss: 1.6482 - val_acc: 0.4333
Epoch 6/30
5/5 - 3s - loss: 0.7903 - acc: 0.7467 - val_loss: 1.0440 - val_acc: 0.6333
Epoch 7/30
5/5 - 3s - loss: 0.5731 - acc: 0.8267 - val_loss: 1.5226 - val_acc: 0.5000
Epoch 8/30
5/5 - 3s - loss: 0.5949 - acc: 0.8333 - val_loss: 0.9984 - val_acc: 0.6667
Epoch 9/30
5/5 - 3s - loss: 0.6162 - acc: 0.8069 - val_loss: 1.1490 - val_acc: 0.5667
Epoch 10/30
5/5 - 3s - loss: 0.7509 - acc: 0.7600 - val_loss: 1.3168 - val_acc: 0.5000
Epoch 11/30
5/5 - 4s - loss: 0.6180 - acc: 0.7862 - val_loss: 1.1918 - val_acc: 0.7000
Epoch 12/30
5/5 - 3s - loss: 0.4936 - acc: 0.8467 - val_loss: 1.0488 - val_acc: 0.6333
Epoch 13/30
5/5 - 3s - loss: 0.4290 - acc: 0.8400 - val_loss: 0.9400 - val_acc: 0.6667
Epoch 14/30
5/5 - 3s - loss: 0.4205 - acc: 0.8533 - val_loss: 1.0716 - val_acc: 0.7000
Epoch 15/30
5/5 - 4s - loss: 0.5750 - acc: 0.8067 - val_loss: 1.2055 - val_acc: 0.6000
Epoch 16/30
5/5 - 4s - loss: 0.4080 - acc: 0.8533 - val_loss: 1.5014 - val_acc: 0.6667
Epoch 17/30
5/5 - 3s - loss: 0.3686 - acc: 0.8467 - val_loss: 1.0441 - val_acc: 0.5667
Epoch 18/30
5/5 - 3s - loss: 0.5474 - acc: 0.8067 - val_loss: 0.9662 - val_acc: 0.7333
Epoch 19/30
5/5 - 3s - loss: 0.5646 - acc: 0.8138 - val_loss: 0.9151 - val_acc: 0.7000
Epoch 20/30
5/5 - 4s - loss: 0.3579 - acc: 0.8800 - val_loss: 1.4184 - val_acc: 0.5667
Epoch 21/30
5/5 - 3s - loss: 0.3714 - acc: 0.8800 - val_loss: 2.0762 - val_acc: 0.6333
Epoch 22/30
5/5 - 3s - loss: 0.3654 - acc: 0.8933 - val_loss: 1.8273 - val_acc: 0.5667
Epoch 23/30
5/5 - 3s - loss: 0.3845 - acc: 0.8933 - val_loss: 1.0199 - val_acc: 0.7333
Epoch 24/30
5/5 - 3s - loss: 0.3356 - acc: 0.9000 - val_loss: 0.5168 - val_acc: 0.8333
Epoch 25/30
5/5 - 3s - loss: 0.3612 - acc: 0.8667 - val_loss: 1.7924 - val_acc: 0.5667
Epoch 26/30
5/5 - 3s - loss: 0.3075 - acc: 0.8867 - val_loss: 1.0720 - val_acc: 0.6667
Epoch 27/30
5/5 - 3s - loss: 0.2820 - acc: 0.9400 - val_loss: 2.2798 - val_acc: 0.5667
Epoch 28/30
5/5 - 3s - loss: 0.3606 - acc: 0.8621 - val_loss: 1.2423 - val_acc: 0.8000
Epoch 29/30
5/5 - 3s - loss: 0.2630 - acc: 0.9000 - val_loss: 1.4235 - val_acc: 0.6333
Epoch 30/30
5/5 - 3s - loss: 0.3790 - acc: 0.9000 - val_loss: 0.6173 - val_acc: 0.8000

La función anterior entrena la red neuronal utilizando el conjunto de entrenamiento y evalúa su rendimiento en el conjunto de prueba. Las funciones devuelven dos métricas para cada época ‘acc’ y ‘val_acc’ que son la precisión de las predicciones obtenidas en el conjunto de entrenamiento y la precisión alcanzada en el conjunto de prueba, respectivamente.

Conclusión:

Por tanto, vemos que se ha cumplido con la precisión suficiente. Sin embargo, cualquiera puede ejecutar este modelo aumentando el número de épocas o cualquier otro parámetro.

Espero les haya gustado mi artículo. Comparta con sus amigos, colegas.

Los medios que se muestran en este artículo no son propiedad de DataPeaker y se utilizan a discreción del autor.

Suscribite a nuestro Newsletter

No te enviaremos correo SPAM. Lo odiamos tanto como tú.