4.4 Redes Neuronales y CNN

Abre la puerta al deep learning

En los capítulos anteriores vimos que los métodos tradicionales de visión por computadora a menudo fallan en el mundo real. Su éxito suele depender de que la escena coincida con un patrón específico o un conjunto de suposiciones, como iluminación estable, fondos limpios, puntos de vista fijos o formas de objetos predecibles. Una vez que estas condiciones cambian, su rendimiento puede degradarse rápidamente. El deep learning, sin embargo, adopta un enfoque muy diferente. En lugar de depender principalmente de reglas hechas a mano, aprende patrones visuales útiles directamente a partir de grandes cantidades de datos. Esto le permite manejar mucha más variación en apariencia, fondo, escala, iluminación y pose. Como resultado, el deep learning ha hecho que la visión por computadora sea mucho más robusta y práctica para aplicaciones del mundo real.

De Reglas a Representaciones Aprendidas

En la visión clásica, escribimos reglas explícitamente:

• desenfocar la imagen
• encontrar los bordes
• extraer el contorno

En una red neuronal, dejamos que el modelo aprenda patrones útiles a partir de ejemplos.

Este es el cambio conceptual clave: el sistema aprende representaciones en lugar de depender únicamente de características diseñadas manualmente.

Qué Es una Red Neuronal

Una red neuronal es una función formada por capas que transforman los datos de entrada paso a paso.

Cada capa aprende parámetros. Durante el entrenamiento, esos parámetros se ajustan para que las salidas de la red sean más útiles para la tarea.

¿Cómo se ve una NN en código?

import torch
import torch.nn as nn
import torch.nn.functional as F

# 1. Define the Network Structure
class SimpleMLP(nn.Module):
    def __init__(self, input_size=784, hidden_size=128, num_classes=10):
        super(SimpleMLP, self).__init__()
        
        # --- Fully Connected Layers (Dense Layers) ---
        
        # First layer: Maps input features to the first hidden layer
        self.fc1 = nn.Linear(input_size, hidden_size)
        
        # Second layer: Maps first hidden layer to the second hidden layer
        self.fc2 = nn.Linear(hidden_size, 64)
        
        # Output layer: Maps second hidden layer to the number of classes
        self.fc3 = nn.Linear(64, num_classes)
        
        # Optional: Dropout layer to prevent overfitting (drops 20% of neurons)
        self.dropout = nn.Dropout(p=0.2)

    # 2. Define the Data Flow (Forward Pass)
    def forward(self, x):
        # Flatten the input tensor
        # Converts (batch_size, channels, height, width) to (batch_size, -1)
        # Example: 28x28 image becomes a 784-dimensional vector
        x = x.view(x.size(0), -1)  
        
        # First hidden layer: Linear transformation -> ReLU Activation -> Dropout
        x = F.relu(self.fc1(x))
        x = self.dropout(x)
        
        # Second hidden layer: Linear transformation -> ReLU Activation
        x = F.relu(self.fc2(x))
        
        # Output layer: Linear transformation (no activation here, usually handled by loss function)
        x = self.fc3(x)
        
        return x

# 3. Instantiate the Model
model = SimpleMLP()
print(model)

Inténtalo

cd 4.4-Neural-Networks-and-CNNs/code
python powerful_neural_network.py

🚀 ¡Entrena tu propia red neuronal y mira cómo se desempeña!

Por Qué las CNN Son Buenas para las Imágenes

Las CNN (red neuronal convolucional) funcionan bien para imágenes porque las imágenes no son solo números aleatorios. En una imagen, los píxeles cercanos suelen pertenecer al mismo borde, forma o textura, por lo que los patrones locales son muy importantes. Las CNN aprovechan esto utilizando pequeños filtros que recorren la imagen y buscan características útiles como bordes, esquinas y formas simples. A medida que la red se hace más profunda, combina estas pequeñas características en otras más grandes, como partes de un objeto y, finalmente, el objeto completo en sí. Por eso las CNN son especialmente buenas comprendiendo imágenes de manera eficiente y precisa.

Una CNN suele tener una estructura por capas para convertir una imagen en una comprensión visual de nivel superior. Comienza con una imagen de entrada, luego la pasa a través de varias capas de convolución que aprenden patrones locales como bordes, texturas y formas. A estas suelen seguirles funciones de activación como ReLU y capas de pooling que reducen el tamaño espacial mientras se mantiene la información importante. Después de varios bloques de este tipo, los mapas de características se aplanan o se reducen mediante pooling a una representación compacta y luego se pasan a una o más capas totalmente conectadas para producir la predicción final, como una etiqueta de clase. En resumen, una CNN común se ve así:

entrada → convolución + activación → pooling → bloques de extracción de características repetidos → capa totalmente conectada → salida

Beneficios de la convolución:

• extracción de patrones locales

La convolución ayuda al modelo a encontrar pequeños patrones útiles en una imagen, como bordes, esquinas, texturas o formas simples. Estos pequeños patrones son los bloques básicos para entender objetos más grandes.

• compartición de parámetros

El mismo filtro se utiliza en distintas partes de la imagen. Esto significa que el modelo no necesita aprender un nuevo conjunto de pesos para cada posición, lo que lo hace más eficiente y reduce el número de parámetros.

• robustez a la traslación

Si un objeto se mueve a otro lugar de la imagen, el filtro de convolución aún puede detectarlo. En otras palabras, el modelo puede reconocer el mismo patrón aun cuando cambie su posición.

Mapas de Características

Cuando una capa convolucional procesa una imagen, produce mapas de características. Estos mapas responden a patrones como:

• bordes
• esquinas
• texturas
• estructuras semánticas más grandes en capas más profundas

Pooling y Submuestreo

El pooling reduce el tamaño espacial mientras mantiene la información importante.

Esto ayuda a:

• reducir el cálculo
• mejorar la robustez
• construir representaciones más compactas

Inténtalo

cd 4.4-Neural-Networks-and-CNNs/code
python cnn_process_visualization.py

🚀 Ejecuta el script para experimentar el proceso de la red convolucional sobre la imagen.

Entrenamiento vs Inferencia

• Training: el modelo aprende actualizando los pesos
• Inference: el modelo entrenado realiza predicciones sin actualizar pesos

Esta distinción es crucial porque los capítulos posteriores de despliegue se centran principalmente en la inferencia.

¿Cómo se ve una CNN en código?

mport torch
import torch.nn as nn

class TinyCNN(nn.Module):
    def __init__(self):
        super().__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 16, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2),
            nn.Conv2d(16, 32, kernel_size=3, padding=1),
            nn.ReLU(),
            nn.MaxPool2d(2)
        )
        self.classifier = nn.Sequential(
            nn.Flatten(),
            nn.Linear(32 * 56 * 56, 64),
            nn.ReLU(),
            nn.Linear(64, 10)
        )

    def forward(self, x):
        x = self.features(x)
        x = self.classifier(x)
        return x

model = TinyCNN()
dummy = torch.randn(1, 3, 224, 224)
output = model(dummy)
print(output.shape)

Malentendidos Comunes

• "Una CNN literalmente ve como un ojo humano."
  • Las CNN procesan patrones numéricos. La analogía es útil, pero no literal.
• "Más capas siempre significa mejor rendimiento."
  • Los modelos más profundos pueden ser más potentes, pero también más difíciles de entrenar y desplegar.
• "Si entiendo el código, automáticamente entiendo el entrenamiento."
  • El entrenamiento también depende de los datos, la pérdida, la optimización y la evaluación.

Ejercicios / Reflexión

1. Con tus propias palabras, explica por qué la convolución es más adecuada para imágenes que una capa totalmente conectada plana.
2. Ejecuta el ejemplo tiny CNN e imprime la forma de la salida.
3. Cambia el número de canales de salida en la primera convolución y observa cómo cambia la estructura del modelo.
4. Reflexiona sobre cómo difieren las CNN de los filtros clásicos como el desenfoque o la detección de bordes.

Resumen

Las redes neuronales aprenden representaciones a partir de los datos, y las CNN son especialmente eficaces para imágenes porque explotan la estructura local. Comprender la convolución, los mapas de características, el pooling y la diferencia entre entrenamiento e inferencia prepara al estudiante para tareas de visión modernas.

Siguiente Paso Sugerido

Continúa a 4.5 Tareas de Visión por Computadora con Deep Learning.

Referencias

• PyTorch Tutorials