El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
HOME Mis cursos Finalizados
◄ Anterior
◄

Aplicaciones de CNN en Reconocimiento de Imágenes

Siguiente ►
►

Introducción

Las Redes Neuronales Convolucionales (CNN) han revolucionado el campo del reconocimiento de imágenes debido a su capacidad para aprender características jerárquicas y complejas directamente a partir de los datos de imagen. En esta sección, exploraremos diversas aplicaciones de las CNN en el reconocimiento de imágenes, desde la clasificación de imágenes hasta la detección de objetos y la segmentación semántica.

Aplicaciones Principales

  1. Clasificación de Imágenes

La clasificación de imágenes es una de las aplicaciones más comunes de las CNN. En esta tarea, el objetivo es asignar una etiqueta a una imagen de un conjunto predefinido de categorías.

Ejemplo: Clasificación de Imágenes con CNN

import tensorflow as tf
from tensorflow.keras import datasets, layers, models

# Cargar y preprocesar el conjunto de datos CIFAR-10
(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()
train_images, test_images = train_images / 255.0, test_images / 255.0

# Definir la arquitectura de la CNN
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10)
])

# Compilar y entrenar el modelo
model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=10, 
          validation_data=(test_images, test_labels))

  1. Detección de Objetos

La detección de objetos va un paso más allá de la clasificación de imágenes, ya que no solo identifica las categorías de los objetos presentes en una imagen, sino que también localiza sus posiciones mediante cajas delimitadoras (bounding boxes).

Ejemplo: Detección de Objetos con YOLO (You Only Look Once)

# Este es un ejemplo simplificado y conceptual de cómo se podría usar YOLO para la detección de objetos
# La implementación completa requiere un entorno configurado con Darknet y el modelo YOLO preentrenado

import cv2
import numpy as np

# Cargar el modelo YOLO preentrenado y las clases
net = cv2.dnn.readNet("yolov3.weights", "yolov3.cfg")
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]
classes = open("coco.names").read().strip().split("\n")

# Leer la imagen y preparar la entrada para YOLO
image = cv2.imread("image.jpg")
height, width = image.shape[:2]
blob = cv2.dnn.blobFromImage(image, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
net.setInput(blob)

# Ejecutar la detección
outs = net.forward(output_layers)

# Procesar las detecciones
for out in outs:
    for detection in out:
        scores = detection[5:]
        class_id = np.argmax(scores)
        confidence = scores[class_id]
        if confidence > 0.5:
            center_x = int(detection[0] * width)
            center_y = int(detection[1] * height)
            w = int(detection[2] * width)
            h = int(detection[3] * height)
            x = int(center_x - w / 2)
            y = int(center_y - h / 2)
            cv2.rectangle(image, (x, y), (x + w, y + h), (0, 255, 0), 2)
            cv2.putText(image, classes[class_id], (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

cv2.imshow("Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

  1. Segmentación Semántica

La segmentación semántica es una tarea más detallada que la detección de objetos, ya que asigna una etiqueta a cada píxel de la imagen, identificando así las regiones específicas de cada objeto.

Ejemplo: Segmentación Semántica con U-Net

import tensorflow as tf
from tensorflow.keras import layers, models

# Definir la arquitectura U-Net
def unet_model(input_size=(128, 128, 1)):
    inputs = layers.Input(input_size)
    c1 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(inputs)
    c1 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(c1)
    p1 = layers.MaxPooling2D((2, 2))(c1)
    
    c2 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(p1)
    c2 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(c2)
    p2 = layers.MaxPooling2D((2, 2))(c2)
    
    c3 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(p2)
    c3 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(c3)
    p3 = layers.MaxPooling2D((2, 2))(c3)
    
    c4 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(p3)
    c4 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(c4)
    p4 = layers.MaxPooling2D((2, 2))(c4)
    
    c5 = layers.Conv2D(1024, (3, 3), activation='relu', padding='same')(p4)
    c5 = layers.Conv2D(1024, (3, 3), activation='relu', padding='same')(c5)
    
    u6 = layers.Conv2DTranspose(512, (2, 2), strides=(2, 2), padding='same')(c5)
    u6 = layers.concatenate([u6, c4])
    c6 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(u6)
    c6 = layers.Conv2D(512, (3, 3), activation='relu', padding='same')(c6)
    
    u7 = layers.Conv2DTranspose(256, (2, 2), strides=(2, 2), padding='same')(c6)
    u7 = layers.concatenate([u7, c3])
    c7 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(u7)
    c7 = layers.Conv2D(256, (3, 3), activation='relu', padding='same')(c7)
    
    u8 = layers.Conv2DTranspose(128, (2, 2), strides=(2, 2), padding='same')(c7)
    u8 = layers.concatenate([u8, c2])
    c8 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(u8)
    c8 = layers.Conv2D(128, (3, 3), activation='relu', padding='same')(c8)
    
    u9 = layers.Conv2DTranspose(64, (2, 2), strides=(2, 2), padding='same')(c8)
    u9 = layers.concatenate([u9, c1])
    c9 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(u9)
    c9 = layers.Conv2D(64, (3, 3), activation='relu', padding='same')(c9)
    
    outputs = layers.Conv2D(1, (1, 1), activation='sigmoid')(c9)
    
    model = models.Model(inputs=[inputs], outputs=[outputs])
    return model

# Crear y compilar el modelo U-Net
model = unet_model()
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Entrenar el modelo (suponiendo que se tienen los datos de entrenamiento y validación)
# model.fit(train_images, train_masks, epochs=10, validation_data=(val_images, val_masks))

Ejercicios Prácticos

Ejercicio 1: Clasificación de Imágenes

Tarea: Implementa una CNN para clasificar el conjunto de datos MNIST (dígitos escritos a mano).

Solución:

import tensorflow as tf
from tensorflow.keras import datasets, layers, models

# Cargar y preprocesar el conjunto de datos MNIST
(train_images, train_labels), (test_images, test_labels) = datasets.mnist.load_data()
train_images = train_images.reshape((60000, 28, 28, 1)).astype('float32') / 255
test_images = test_images.reshape((10000, 28, 28, 1)).astype('float32') / 255

# Definir la arquitectura de la CNN
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# Compilar y entrenar el modelo
model.compile(optimizer='adam',
              loss='sparse_categorical_crossentropy',
              metrics=['accuracy'])
model.fit(train_images, train_labels, epochs=5, 
          validation_data=(test_images, test_labels))

Ejercicio 2: Detección de Objetos

Tarea: Implementa una detección de objetos simple utilizando un modelo preentrenado como MobileNet SSD.

Solución:

import cv2

# Cargar el modelo MobileNet SSD preentrenado y las clases
net = cv2.dnn.readNetFromCaffe("deploy.prototxt", "mobilenet_iter_73000.caffemodel")
classes = open("synset_words.txt").read().strip().split("\n")

# Leer la imagen y preparar la entrada para MobileNet SSD
image = cv2.imread("image.jpg")
(h, w) = image.shape[:2]
blob = cv2.dnn.blobFromImage(cv2.resize(image, (300, 300)), 0.007843, (300, 300), 127.5)
net.setInput(blob)

# Ejecutar la detección
detections = net.forward()

# Procesar las detecciones
for i in range(detections.shape[2]):
    confidence = detections[0, 0, i, 2]
    if confidence > 0.2:
        idx = int(detections[0, 0, i, 1])
        box = detections[0, 0, i, 3:7] * np.array([w, h, w, h])
        (startX, startY, endX, endY) = box.astype("int")
        label = "{}: {:.2f}%".format(classes[idx], confidence * 100)
        cv2.rectangle(image, (startX, startY), (endX, endY), (0, 255, 0), 2)
        y = startY - 15 if startY - 15 > 15 else startY + 15
        cv2.putText(image, label, (startX, y), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (0, 255, 0), 2)

cv2.imshow("Image", image)
cv2.waitKey(0)
cv2.destroyAllWindows()

Conclusión

Las Redes Neuronales Convolucionales (CNN) han demostrado ser extremadamente efectivas en una variedad de tareas de reconocimiento de imágenes, incluyendo la clasificación de imágenes, la detección de objetos y la segmentación semántica. A través de ejemplos prácticos y ejercicios, hemos explorado cómo implementar estas aplicaciones utilizando diferentes arquitecturas y frameworks. En el próximo módulo, profundizaremos en las Redes Neuronales Recurrentes (RNN) y sus aplicaciones en el procesamiento del lenguaje natural y las series temporales.

◄ Anterior
◄
Siguiente ►
►
El Proyecto | Sobre nosotros | Contribuir | Donaciones | Licencia
© Copyright 2024. Todos los derechos reservados