Stride y padding en convoluciones

Curso de Redes Neuronales Convolucionales

Contenido del curso

No sé dónde empezar

Fundamentos de las CNN y su aplicación biomédica

Construcción práctica con PyTorch

Entrenamiento y evaluación de modelos

Optimización y generalización

Tomar examen

Cursos Empresas Blog Live Conf Eventos Precios

0:005:54

Stride y padding en convoluciones

Curso de Redes Neuronales Convolucionales

Clase 4 de 15

Clase 4 / 15

Recursos

Las convoluciones son la herramienta que te permite resaltar bordes, texturas y patrones complejos dentro de una imagen, y entender cómo configurarlas con parámetros como stride y padding marca la diferencia entre un procesamiento básico y uno realmente útil para visión por computador. Si trabajas con redes neuronales convolucionales, dominar estos ajustes te da control fino sobre lo que tu modelo aprende.

Antes de entrar en materia, vale la pena recordar el flujo de trabajo: conectarte al entorno, importar librerías y decidir si vas a usar CPU o GPU. En Google Colab tienes esa opción disponible y conviene revisarla desde el inicio [0:11].

¿Cómo se configura un notebook para aplicar convoluciones?

La preparación define la calidad del experimento. Necesitas tres elementos básicos antes de tocar un kernel.

Conectarte al entorno de ejecución y verificar si está activa la CPU o la GPU.
Importar las librerías necesarias para el procesamiento de imágenes.
Cargar las imágenes con las que vas a trabajar, ya sea sintéticas o propias.

En la práctica, puedes trabajar con tres tipos de imágenes: una imagen sintética con gradiente horizontal, la letra P que se viene usando como referencia, y una imagen propia como el logo de Platzi o incluso una radiografía [0:25]. Para cargarla, das clic en archivos, arrastras la imagen, copias su ruta con clic derecho y la pegas en la celda de carga y procesamiento.

¿Qué es una convolución en procesamiento de imágenes? Es una operación que combina una imagen con un kernel mediante una suma de productos punto, aplicada región por región, para resaltar características como bordes o texturas.

¿Qué hace el filtro Sobel sobre distintos tipos de imagen?

El filtro Sobel detecta bordes y su comportamiento cambia según la imagen de entrada. Eso lo convierte en un buen punto de partida para entender qué hace realmente un kernel [1:05].

Cuando aplicas Sobel sobre el gradiente horizontal, el resultado se ve plano porque no hay bordes que detectar: la transición del negro al blanco es continua. En cambio, sobre la letra P los bordes aparecen marcados con claridad. Y en el logo de Platzi, una imagen a color que primero se convierte a escala de grises, el filtro resalta bordes y texturas con definición.

Aquí viene un detalle clave: cuando aplicas una convolución a una imagen a color, la operación se ejecuta sobre los tres canales RGB. Por eso al visualizar el resultado puedes ver un canal por separado, como el canal R (rojo), o un promedio de los tres [1:48].

¿Para qué sirven el stride y el padding en una convolución?

Más allá de la imagen y el kernel, hay dos parámetros que cambian por completo el resultado y el rendimiento de la operación.

¿Qué es el stride y cómo afecta el procesamiento?

El stride es el paso con el que el kernel recorre la imagen. Por defecto, la convolución se aplica píxel a píxel, pero puedes configurarla para avanzar de dos en dos, de tres en tres o más [2:18].

Stride de 1: recorrido píxel por píxel, máximo detalle.
Stride de 2: salta un píxel entre cada operación, procesamiento más rápido.
Stride de 4: deforma la imagen y resalta características distintas a las originales.

Un stride mayor agiliza el procesamiento pero sacrifica resolución. Es un balance que decides según el objetivo del modelo.

¿Qué es el padding y por qué se usa?

El padding resuelve un problema concreto: qué hacer cuando el kernel cae sobre una esquina o un borde de la imagen y no tiene suficientes píxeles vecinos para multiplicar [2:42]. La solución es rellenar los bordes con ceros.

¿Para qué sirve el padding de 1 en una convolución? Se usa para mantener la forma original de la imagen después de aplicar el kernel, evitando que la salida quede más pequeña que la entrada.

Con un stride de 1 y padding de 1 conservas las dimensiones originales. Si subes el stride a 4 y el padding a 2, la imagen se deforma y aparecen patrones que antes no eran visibles.

¿Cómo trabajan los filtros múltiples sobre una misma imagen?

No estás limitado a un solo kernel. Puedes aplicar varios filtros en paralelo y comparar resultados [3:30]. Un caso típico es usar el filtro Sobel vertical y el filtro Sobel horizontal al mismo tiempo, cada uno con su propio kernel y un padding de 1.

Al ejecutar ambos sobre la misma imagen, ocurre algo que parece contraintuitivo: el filtro Sobel vertical detecta bordes horizontales, y el filtro Sobel horizontal detecta bordes verticales. No es un error, es la forma en que el kernel actúa matemáticamente sobre la imagen [4:08]. La orientación del kernel responde a las transiciones perpendiculares a su eje.

¿Por qué un filtro Sobel vertical detecta bordes horizontales? Porque el kernel está diseñado para responder a cambios bruscos de intensidad en la dirección perpendicular a su orientación, lo que matemáticamente captura los bordes contrarios al nombre del filtro.

Con esto ya tienes el panorama de cómo detectar patrones con convoluciones ajustando kernel, stride, padding y múltiples filtros. El siguiente paso es decidir qué hacer con esos patrones, y ahí entran las funciones de activación. ¿Qué imagen vas a usar para tu primer experimento con Sobel?

Jesús Alberto Romero Hernández

Hace 4 meses

A continuación les comparto mis resultados de mi codigo modificado por usar entorno de VSCode con extensión de Colab para usar GPU gratuito. La imagen cargada es un corte axial de una Lesión Ocupante de Espacio (Cáncer) cerebral en secuanecia T1 con Gadolineo (contraste). No estoy usando JupyterNotebook sino Interactive Python lo cual para mí es mejor.

# %% [markdown]
## Curso de CNN con PyTorch
from IPython.display import display, Markdown
# %% [markdown]
## 1) 🎯 Capas Convolucionales

capas_convolucionales="""
Las **capas convolucionales** son el corazón de las CNN (Redes Neuronales Convolucionales).

Permiten extraer **características espaciales** como bordes, texturas o patrones complejos directamente desde las imágenes de entrada."""
display(Markdown(capas_convolucionales))
# %% [markdown]
## 2) 📐 Fundamento Matemático
### 2.1) 🔢 ¿Qué es una convolución?
Una_convolucion=r"""
Una **convolución** es una operación matemática que aplica un **filtro (o kernel)** sobre una imagen para producir un **mapa de características**.

**Fórmula:**
$$
O(i, j) = \sum_{m=0}^{kH-1} \sum_{n=0}^{kW-1} I(i+m, j+n) \cdot K(m,n)
$$

Donde:
- \( I \): Imagen de entrada  
- \( K \): Kernel o filtro  
- \( O \): Salida (feature map)  
- \( kH, kW \): Altura y ancho del filtro  """
display(Markdown(Una_convolucion))
# %% [markdown]
### 2.2) 🧰 Componentes importantes
Filtros_Kernel=r"""
### Filtros (Kernels)
###
**Filtros (Kernels)**
- Son pequeños tensores (e.g. 3×3, 5×5) entrenables.
- Detectan patrones específicos como bordes, líneas o texturas.

**Stride**
- Determina cuánto se desplaza el filtro al aplicarse.
- `stride=1` → máxima superposición  
- `stride=2` → reduce resolución más rápido

**Padding**
- Añade bordes de ceros para no perder información en los bordes.
- `same` padding → salida del mismo tamaño que la entrada  
- `valid` padding → sin relleno

**Canales**
- Imágenes RGB tienen 3 canales.
- Cada filtro se aplica en **todos los canales**, y se suman."""
display(Markdown(Filtros_Kernel))
# %% [markdown] 
# Todo el texto (incluyendo el título) debe ir dentro de las comillas
Patrones_espaciales = r"""
### 2.3) 🔍 ¿Para qué sirven?
- Extraer patrones espaciales
- Detectar jerarquías (de píxeles a bordes, de bordes a objetos)
- Reducir dimensionalidad con stride o pooling
"""
display(Markdown(Patrones_espaciales))
# %% [markdown] 

## 3) 🧪 Ejemplos
import torch
import torch.nn.functional as F
import matplotlib.pyplot as plt
import numpy as np
from torchvision import transforms
from PIL import Image

device = 'cuda' if torch.cuda.is_available() else 'cpu'
print(f"Dispositivo de cómputo activo: {device}")
# %% [markdown]
### 📷 Imagen 1: Gradiente blanco y negro

# Imagen sintética: gradiente horizontal
gradient = np.tile(np.linspace(0, 1, 64), (64, 1))
img_grad = torch.tensor(gradient, dtype=torch.float32).unsqueeze(0).unsqueeze(0).to(device)

### 📷 Imagen 2: Letra "P"

P_img = np.zeros((64, 64))
## Parte vertical
P_img[10:50, 10:20] = 1
## Parte superior del círculo de la P
P_img[10:20, 10:40] = 1
## Parte media horizontal de la P
P_img[30:40, 10:40] = 1
## Borde derecho del "círculo"
P_img[20:30, 30:40] = 1
## Parte interior para que no parezca una B
P_img[20:30, 20:30] = 0  # vaciar la parte interior
img_P = torch.tensor(P_img, dtype=torch.float32).unsqueeze(0).unsqueeze(0).to(device)

# %% [markdown]
### 📷 Imagen 3: RGB cargada por el usuario

# Carga y preprocesamiento

# Cargar imagen
from google.colab import drive
drive.mount('/content/drive')
img_path = "/content/drive/MyDrive/Data/Curso de Redes Neuronales Convolucionales/GBM.jpeg"

try:
    # Cargamos en escala de grises para procesar un solo canal de entrada (1, 1, H, W)
    img_gbm = Image.open(img_path).convert("L").resize((64, 64))
    transform = transforms.Compose([transforms.ToTensor()])
    img_gbm_tensor = transform(img_gbm).unsqueeze(0).to(device)
    print("¡Éxito! Imagen del GBM cargada y transferida a la GPU.")
    gbm_disponible = True
except FileNotFoundError:
    print(f"⚠️ Archivo no detectado en: '{img_path}'")
    print("Nota: El script ejecutará solo las imágenes sintéticas hasta que subas el JPEG a Colab.")
    gbm_disponible = False (1, 3, 64, 64)
    
### 🧪 3.1) Aplicar un filtro de detección de bordes
# Filtro Sobel Vertical (Detecta gradientes en el eje X)
sobel_x = torch.tensor([[-1.,  0.,  1.],
                        [-2.,  0.,  2.],
                        [-1.,  0.,  1.]])

# Filtro Sobel Horizontal (Detecta gradientes en el eje Y)
sobel_y = torch.tensor([[-1., -2., -1.],
                        [ 0.,  0.,  0.],
                        [ 1.,  2.,  1.]])

# Apilamos ambos operadores para procesarlos en una única operación convolucional
# Shape resultante: (Filtros_out=2, Canales_in=1, H=3, W=3)
kernels = torch.stack([sobel_y, sobel_x]).unsqueeze(1).to(device)
# %% [markdown]
# ## 3) Definición de Funciones Analíticas y Visualización

# %%
def aplicar_convolucion(img, kernel_tensor, stride=1, padding=1):
    return F.conv2d(img, kernel_tensor, stride=stride, padding=padding)

def visualizar_bancos_de_filtros(img, title):
    """Aplica el banco de filtros y grafica los mapas de características resultantes."""
    out = aplicar_convolucion(img, kernels)
    
    # Retornamos los tensores a CPU y formato NumPy para el renderizado de Matplotlib
    out_np = out.squeeze().detach().cpu().numpy()
    img_np = img.squeeze().detach().cpu().numpy()

    plt.figure(figsize=(12, 4))

    # Canal Original
    plt.subplot(1, 3, 1)
    plt.imshow(img_np, cmap='gray')
    plt.title("Entrada Original")
    plt.axis("off")

    # Respuesta al filtro horizontal
    plt.subplot(1, 3, 2)
    plt.imshow(out_np[0], cmap='gray')
    plt.title("Respuesta Sobel Y (Bordes Horiz.)")
    plt.axis("off")

    # Respuesta al filtro vertical
    plt.subplot(1, 3, 3)
    plt.imshow(out_np[1], cmap='gray')
    plt.title("Respuesta Sobel X (Bordes Vert.)")
    plt.axis("off")

    plt.suptitle(title, y=1.02, fontsize=12)
    plt.tight_layout()
    plt.show()

# %% [markdown]
# ## 4) Ejecución y Extracción de Características Espaciales

# %%
# Evaluación sobre las señales de control (Sintéticas)
visualizar_bancos_de_filtros(img_grad, "Análisis de Bordes: Gradiente Continuo")
visualizar_bancos_de_filtros(img_P, "Análisis de Bordes: Estructura Digital 'P'")

# Evaluación sobre la anatomía médica (Si el archivo JPEG fue cargado)
if gbm_disponible:
    visualizar_bancos_de_filtros(img_gbm_tensor, "Análisis de Bordes Histológicos / Anatómicos: GBM")

# %% [markdown]
# ## 5) Evaluación Dimensional: Impacto de Stride y Padding

# %%
def analizar_reduccion_espacial(img, combinaciones, title):
    """Visualiza cómo se altera el tamaño de la matriz de salida según el paso del filtro."""
    kernel_operativo = sobel_y.unsqueeze(0).unsqueeze(0).to(device)
    
    plt.figure(figsize=(4 * len(combinaciones), 4))
    
    for i, (s, p) in enumerate(combinaciones):
        res = aplicar_convolucion(img, kernel_operativo, stride=s, padding=p)
        res_np = res.squeeze().detach().cpu().numpy()
        
        plt.subplot(1, len(combinaciones), i + 1)
        plt.imshow(res_np, cmap='gray')
        # Imprimimos explícitamente el Shape resultante para verificar el submuestreo
        plt.title(f"Stride={s}, Padding={p}\nDim: {res_np.shape}")
        plt.axis('off')
        
    plt.suptitle(title, y=1.05)
    plt.tight_layout()
    plt.show()

# Combinaciones analíticas de Stride y Padding
configuraciones = [(1, 1), (2, 1), (4, 1)]

analizar_reduccion_espacial(img_P, configuraciones, "Efecto Dimensional en Objeto Sintético")

if gbm_disponible:
    analizar_reduccion_espacial(img_gbm_tensor, configuraciones, "Efecto Dimensional en Tensor GBM")# %% [markdown]
## 4) 💡 Tips
Tips=r"""
| Tema | Recomendaciones |
|------|------------------|
| Filtros | Diseñados para extraer características específicas. Los primeros detectan bordes; los últimos detectan partes de objetos. |
| Stride > 1 | Útil para reducir tamaño espacial y acelerar procesamiento. Pero se puede perder información fina. |
| Padding | Siempre usar `padding=1` si querés conservar la dimensión. Muy importante para no achicar imágenes rápidamente. |
| Canales | En RGB, cada filtro procesa todos los canales y produce 1 mapa de salida. Convierte 3 canales a N mapas. | """
display(Markdown(Tips))

Fundamentos de las CNN y su aplicación biomédica

Redes convolucionales con PyTorch para imágenes médicas

Cómo las radiografías se convierten en números

Convoluciones en PyTorch con tensores

Stride y padding en convoluciones

ReLU, Sigmoide y Tanh en redes convolucionales

Max Pooling vs Average Pooling en CNNs

Qué hace flatten en redes neuronales

Construcción práctica con PyTorch

Carga de datasets de imágenes en Google Colab con GPU

Imágenes a tensores con PyTorch

Cómo construir tu primera CNN en código

Entrenamiento y evaluación de modelos

Entrenamiento de red neuronal para detectar neumonía

Predicciones reales con tu modelo PyTorch

Precisión, Recall y ROC en redes neuronales

Optimización y generalización

ResNet 50 lleva accuracy de 0.69 a 0.96

Grad-Cam para detectar neumonía en rayos X

Stride y padding en convoluciones

Progreso del curso

Fundamentos de las CNN y su aplicación biomédica

Construcción práctica con PyTorch

Entrenamiento y evaluación de modelos

Optimización y generalización

Recursos

Recursos