Desentrañando el Poder Visual: Redes Neuronales Convolucionales en Acción

-

Redes Neuronales Convolucionales (Imágenes):


En esta oportinidad, exploraremos un avance crucial en el aprendizaje profundo: las Redes Neuronales Convolucionales (CNN). Diseñadas específicamente para procesar datos visuales, las CNN han transformado la manera en que abordamos problemas de reconocimiento de imágenes.

Entenderemos cómo las capas convolucionales detectan patrones visuales como bordes y texturas y cómo las capas de agrupación reducen la dimensionalidad para extraer características relevantes. Nos sumergiremos en ejemplos prácticos, incluyendo la clasificación de dígitos escritos a mano (MNIST dataset), para apreciar la eficacia de las CNN en la visión por computadora.

Conceptos claves:

  • Redes neuronales convolucionales (CNNs): Un tipo de red neuronal artificial que se utiliza para procesar imágenes y datos espaciales.
  • Convolución: Una operación matemática que se utiliza para detectar patrones en imágenes.
  • Pooling: Una operación matemática que se utiliza para reducir la dimensionalidad de una imagen.
  • Capas completamente conectadas: Capas que se utilizan al final de una CNN para realizar la clasificación o la regresión.

Para mejor comprensión:

 

Aplicación práctica:

Trabajaremos en un código que pueda identificar números de manera gráfica, para facilitar el proceso te sugiero que tengas a mano un archivo de tipo imagen y que su contenido sea un número de entre el 0 y el 9.

# Modelo para el reconocimiento de imágenes

import tensorflow as tf
from tensorflow.keras import datasets, layers, models
import matplotlib.pyplot as plt

(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data()

# Normalizar los píxeles de las imágenes a valores entre 0 y 1
train_images, test_images = train_images / 255.0, test_images / 255.0

model = models.Sequential()
model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))
model.add(layers.MaxPooling2D((2, 2)))
model.add(layers.Conv2D(64, (3, 3), activation='relu'))

# Agregar la parte de clasificación del modelo
model.add(layers.Flatten())
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10))

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

history = model.fit(train_images, train_labels, epochs=10,
                    validation_data=(test_images, test_labels))

test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
print('\nTest accuracy:', test_acc)

Ejecutando este código, entrenamos al modelo agregando la parte de clasificación y el resultado de la precisión de la prueba es la siguiente:

Epoch 1/10
1875/1875 [=] - 12s 4ms/step - loss: 0.1460 - accuracy: 0.9565 - val_loss: 0.0485 - val_accuracy: 0.9841
Epoch 2/10
1875/1875 [=] - 8s 4ms/step - loss: 0.0438 - accuracy: 0.9861 - val_loss: 0.0350 - val_accuracy: 0.9889
Epoch 3/10
1875/1875 [=] - 7s 4ms/step - loss: 0.0307 - accuracy: 0.9906 - val_loss: 0.0261 - val_accuracy: 0.9921
Epoch 4/10
1875/1875 [=] - 8s 4ms/step - loss: 0.0240 - accuracy: 0.9929 - val_loss: 0.0313 - val_accuracy: 0.9905
Epoch 5/10
1875/1875 [=] - 8s 4ms/step - loss: 0.0185 - accuracy: 0.9941 - val_loss: 0.0327 - val_accuracy: 0.9892
Epoch 6/10
1875/1875 [=] - 8s 4ms/step - loss: 0.0150 - accuracy: 0.9951 - val_loss: 0.0383 - val_accuracy: 0.9886
Epoch 7/10
1875/1875 [=] - 8s 4ms/step - loss: 0.0129 - accuracy: 0.9957 - val_loss: 0.0247 - val_accuracy: 0.9938
Epoch 8/10
1875/1875 [=] - 8s 4ms/step - loss: 0.0103 - accuracy: 0.9966 - val_loss: 0.0398 - val_accuracy: 0.9909
Epoch 9/10
1875/1875 [=] - 8s 4ms/step - loss: 0.0101 - accuracy: 0.9966 - val_loss: 0.0284 - val_accuracy: 0.9919
Epoch 10/10
1875/1875 [=] - 8s 4ms/step - loss: 0.0080 - accuracy: 0.9973 - val_loss: 0.0433 - val_accuracy: 0.9904
313/313 - 1s - loss: 0.0433 - accuracy: 0.9904 - 612ms/epoch - 2ms/step

Test accuracy: 0.9904000163078308

Al 99% de efectividad, para probar el modelo, crearemos una función para cargar una imagen y que esta pueda ser leída por el programa, estea es:

from tensorflow.keras.preprocessing import image
import numpy as np

def cargar_imagen(archivo_imagen):
    img = image.load_img(archivo_imagen, target_size=(28, 28), color_mode = "grayscale")
    img = image.img_to_array(img)
    img = np.expand_dims(img, axis=0)
    img /= 255.0
    return img

Ahora solo ejecutamos el modelo con la predicción de la imagen cargada que desde luego debe ser un número.

archivo_imagen = 'cero.jpg'  # Reemplaza con la ruta de tu imagen
img = cargar_imagen(archivo_imagen)

# Suponiendo que 'model' es tu modelo entrenado
predicciones = model.predict(img)
numero_predicho = np.argmax(predicciones)
print("Número predicho:", numero_predicho)

Si el número a predecir lo cargamos y ejecutamos el modelo el resultado es:

1/1 [==============================] - 0s 17ms/step
Número predicho: 0


Desde luego si trabajas desde GoogleColab, debes cargar la imagen del número a predecir como lo siguiente:

Puedes probar con todos los números, la idea es probar el modelo y ajustar si es necesario. También puedes practicar en el siguiente enlace: https://ringa-tech.com/cnn/numeros/.

Conclusión

Al finalizar, reflexionaremos sobre cómo las CNN han revolucionado la visión por computadora, permitiendo a las máquinas "ver" e interpretar el mundo visual de manera similar a los humanos. Destacaremos la importancia de las CNN en campos como el reconocimiento de objetos, segmentación de imágenes y más.

Fomentaremos una actitud de aprecio por la capacidad de las redes neuronales convolucionales para capturar y comprender patrones visuales, impulsando aplicaciones desde la clasificación de dígitos hasta la creación de tecnologías innovadoras como vehículos autónomos y diagnósticos médicos basados en imágenes.

  • Las CNNs son una herramienta poderosa para el procesamiento de imágenes.
  • Las CNNs se pueden utilizar para una amplia gama de tareas, como la clasificación de imágenes, la detección de objetos y la segmentación de imágenes.
  • Es importante comprender los fundamentos de las CNNs para poder utilizarlas de forma efectiva.

 

 

 

 

 

 

 

Comentarios

Publicar un comentario

Entradas más populares de este blog

Perceptrón Simple (Not, AND, OR):

-
Imagen
 El Perceptrón Un perceptrón simple es un tipo de red neuronal artificial que tiene una sola capa de nodos. Cada nodo representa una neurona, y las conexiones entre los nodos representan las sinapsis.   La función de activación de un perceptrón simple es generalmente una función lineal, como la función escalón o la función sigmoidea. Los perceptrones simples se pueden utilizar para implementar funciones booleanas simples, como la negación (NOT), la conjunción (AND) y la disyunción (OR). Daremos un paso más profundo al introducir el Perceptrón Simple y su aplicación en operadores lógicos NOT, AND y OR. Exploraremos cómo un solo perceptrón puede realizar tareas simples pero fundamentales. Comprenderemos la importancia de los pesos y umbrales en la toma de decisiones y cómo estas unidades básicas son el punto de partida para estructuras más complejas.  Operador NOT El modelo tiene una sola capa de neuronas con una sola unidad de salida. La función de activación de la ne...
Leer más

Descifrando la Magia del Perceptrón Multicapa: Desafíos XOR y la Elegancia de Backpropagation

-
Imagen
Perceptrón Multicapa (XOR, Backpropagation): En esta entrega, nos sumergiremos en el mundo más complejo del Perceptrón Multicapa (MLP), una estructura que permite abordar problemas que el Perceptrón Simple no puede resolver, como el famoso problema XOR. Exploraremos cómo el MLP organiza capas de neuronas para aprender patrones más abstractos y realizar operaciones lógicas más avanzadas. Además, introduciremos el algoritmo de Backpropagation, una técnica fundamental en el aprendizaje profundo. Comprenderemos cómo este algoritmo ajusta los pesos de manera inteligente, permitiendo que la red aprenda de sus errores y mejore sus predicciones con cada iteración. Perceptrón multicapa:   Es un tipo de red neuronal artificial con dos o más capas de neuronas, de tal manera que tiene capacidad para resolver problemas que no son linealmente separables, lo cual es la principal limitación del perpectrón simple.  El perceptrón multicapa puede estar totalmente o localmente conectado. En el ...
Leer más