Padding y Strides

Clase 10 de 25 • Curso de Redes Neuronales Convolucionales con Python y Keras

Clase anteriorSiguiente clase

Carlos Felipe Saldarriaga Bejarano

student•

Padding

Stride

Daniel Fernando Murcia Perdomo

student•

Muchas gracias super diciente la imagen, complementa mucho la explicación del profe carlos

Tomas Dale

student•

ESTE CURSO LO LLEVO DESPACIO, PERO ES INCREIBLE COMO ESTOY APRENDIENDO, MUCHISIMAS GRACIAS PROFE, GRACIAS PLATZI POR ESTOS CURSOS

Alarcon7a

student•

siempre un placer

Videl Chavez Benavente

student•

Padding: Si deseas obtener un mapa de características de salida con las mismas dimensiones espaciales que la entrada, puedes utilizar el relleno (padding). El relleno consiste en agregar un número adecuado de filas y columnas a cada lado del mapa de características de entrada para permitir que se ajusten ventanas de convolución centradas alrededor de cada casilla de entrada. En las capas Conv2D, el relleno se configura mediante el argumento "padding", que acepta dos valores: "valid", que significa sin relleno (se utilizarán solo ubicaciones de ventanas válidas); y "same", que significa "rellenar de manera que la salida tenga el mismo ancho y alto que la entrada". El argumento de relleno se establece de forma predeterminada en "valid".

Strides: La distancia entre dos ventanas sucesivas es un parámetro de la convolución, llamado paso (stride), que por defecto es 1. Es posible tener convoluciones con pasos (strides) mayores que 1. Usar un paso de 2 significa que el ancho y la altura del mapa de características se reducen a la mitad (además de cualquier cambio inducido por los efectos de los bordes). Las convoluciones con pasos (strides) no se utilizan con frecuencia en la práctica, aunque pueden ser útiles para algunos tipos de modelos; es bueno estar familiarizado con el concepto.

Para reducir el tamaño de los mapas de características, en lugar de utilizar pasos (strides), tendemos a utilizar la operación de max-pooling.

Extraido de : Deep Learning with Python "Francois Chollet"

Adriana Razo De León

student•

El stride me dice como avanza el kerner que tomé y el padding añade ceros a la matriz para que no me quede tan pequeña. ¿entendí bien?

Alarcon7a

student•

Para que no se reduzca el outout después de que todo el Kernel pase por la imagen

Joaquin Romero Flores

student•

Padding y Strides

Son dos tipos de hiper parámetros que pertenecen a las capas de convolución.

El kernel es considerado por muchos como el hiper-parámetro de referencia de la convolución ya que puede especificar qué tipo y tamaño de Kernel se va a manejar para hacer la convolución de la imagen.

Padding Es un margen que se le agrega a la imagen para que al momento de realizar la operación de convolución la imagen resultante no reduzca su tamaño. Se utilizan 0 para que no altere las características de las imágenes original.

Stride Es el tamaño del paso en cada convolución. Entre más grande sea el paso menor será la imagen resultante.

Como se implemente en la capa de convolución?

Invocas la capa de convolución que deseas utilizar
Filters: cuantos Kernel’s voy a utilizar
Kernel_size: el tamaño de la matriz
Strides: que se reciben como una tupla en la cual el primer parámetro registra el movimiento hacia los lados y el segundo, su movimiento hacia arriba o hacia abajo
Padding: recibe en un array dos valores “valid” y “same”.

Si se selecciona same, entonces Keras automáticamente se encarga de todos los hiper-parámetros para que el padding sea lo suficientemente grande, tanto para que la imagen de entrada como la de salida sean exactamente las mismas y no se pierda ningún dato durante el proceso.

Si se selecciona “valid”, entonces no aplica el “padding”. Al momento de pasar el filtro tomara el primer hasta el último pixel original de la imagen pero esto resultara en una imagen más corta en ancho y largo.

Joseph Peña Quino

student•

En este ejemplo no estamos usando padding exactamente, pero vale la pena ver el resultado. Si en la imagen de la anterior clase utilizamos un kernel bastante grande, como este:

s =  205
kernel = np.zeros((s, s))
kernel[s-1][s//2] = 1

Podemos obtener varios resultados dependiendo de como definimos que rellene las filas de los límites.

Héctor Domínguez

student•

Cuando defino padding="valid", es equivalente a no usar padding?, es decir, no necesito definir esto si voy a ponerle valid.

Es así?

Xavier Medina Veintimilla

student•

¡Hola! :D

¿Cuál es el problema que tienes?, ¿en qué te puedo ayudar? No comprendo muy bien tu pregunta.

Nunca pares de aprender 💚

Jhon Freddy Tavera Blandon

student•

Padding (Relleno)

Hay dos tipos comunes de relleno

Valid Padding (Relleno válido)

No se agrega ningún píxel adicional a la imagen de entrada. Esto puede provocar que la salida de la convolución sea más pequeña que la entrada, especialmente en los bordes.

Same Padding (Relleno del mismo tamaño)

Se agrega suficiente relleno para que la salida de la convolución tenga el mismo tamaño que la entrada. Esto se logra agregando píxeles con un valor de relleno (generalmente cero) alrededor de la imagen.

Relación entre Padding y Strides:

El relleno y los pasos afectan tanto el tamaño como la forma de la salida de la convolución. La fórmula general para calcular el tamaño de la salida de la convolución es: Tamaño de salida = ((Tamaño de entrada - Tamaño del kernel + 2 * Relleno) / Pasos) + 1 Ajustar adecuadamente el relleno y los pasos es importante para controlar el tamaño y la resolución de la salida de la convolución y garantizar que la red neuronal pueda aprender representaciones útiles de los datos.

Mario Alexander Vargas Celis

student•

### **Padding** y **Strides** en Redes Neuronales Convolucionales (CNN)

Las **redes neuronales convolucionales (CNN)** utilizan dos conceptos clave para controlar cómo se aplican los filtros a las entradas: **padding** y **strides**. Ambos conceptos influyen en el tamaño de las salidas y en cómo se mueven los filtros a lo largo de la imagen de entrada.

### **1. Padding**

El **padding** se refiere al proceso de añadir píxeles adicionales alrededor del borde de la imagen de entrada antes de aplicar el filtro convolucional. Esto se hace para controlar el tamaño de la salida y prevenir la pérdida de información en los bordes.

#### Tipos de Padding:

- **Sin padding (valid padding):** No se añaden píxeles adicionales. Esto reduce el tamaño de la imagen de salida, ya que el filtro solo se aplica a las áreas donde puede encajar completamente.

- **Padding (same padding):** Se añaden píxeles para asegurarse de que la salida tenga el mismo tamaño que la entrada. Esto es útil para mantener las dimensiones originales de la imagen.

#### Ejemplo:

Si tienes una imagen de tamaño 5x5 y aplicas un filtro de 3x3 sin padding, la imagen de salida será de 3x3 (menor que la original). Con padding, la imagen de salida podría ser de 5x5.

**Ejemplo de código:**


import tensorflow as tf



\# Imagen de entrada de 5x5x1

input\_image = tf.random.normal(\[1, 5, 5, 1])



\# Aplicamos una convolución sin padding (válido)

conv\_layer\_no\_padding = tf.keras.layers.Conv2D(filters=1, kernel\_size=3, padding='valid')

output\_no\_padding = conv\_layer\_no\_padding(input\_image)



print("Tamaño de salida sin padding:", output\_no\_padding.shape)  # Salida de 3x3



\# Aplicamos una convolución con padding (mismo tamaño)

conv\_layer\_with\_padding = tf.keras.layers.Conv2D(filters=1, kernel\_size=3, padding='same')

output\_with\_padding = conv\_layer\_with\_padding(input\_image)



print("Tamaño de salida con padding:", output\_with\_padding.shape)  # Salida de 5x5

### **2. Strides**

El **stride** define cuántos píxeles se mueve el filtro a lo largo de la imagen de entrada cada vez que se aplica. El valor por defecto del stride es 1, lo que significa que el filtro se mueve un píxel a la vez. Un **stride** mayor permite mover el filtro más rápido y reduce el tamaño de la imagen de salida.

#### Ejemplo:

Si aplicas un filtro de 3x3 con un **stride de 1**, el filtro se moverá un píxel a la vez y generará una salida más detallada. Si aplicas un **stride de 2**, el filtro se moverá dos píxeles a la vez, reduciendo el tamaño de la salida.

**Ejemplo de código:**


\# Imagen de entrada de 5x5x1

input\_image = tf.random.normal(\[1, 5, 5, 1])



\# Aplicamos una convolución con stride de 1

conv\_layer\_stride\_1 = tf.keras.layers.Conv2D(filters=1, kernel\_size=3, strides=1, padding='valid')

output\_stride\_1 = conv\_layer\_stride\_1(input\_image)



print("Tamaño de salida con stride 1:", output\_stride\_1.shape)  # Salida de 3x3



\# Aplicamos una convolución con stride de 2

conv\_layer\_stride\_2 = tf.keras.layers.Conv2D(filters=1, kernel\_size=3, strides=2, padding='valid')

output\_stride\_2 = conv\_layer\_stride\_2(input\_image)



print("Tamaño de salida con stride 2:", output\_stride\_2.shape)  # Salida de 2x2

### **Combinando Padding y Strides**

Puedes combinar **padding** y **strides** para ajustar tanto el tamaño como la forma en que se procesan las imágenes. El **padding** te ayuda a controlar si la salida tendrá el mismo tamaño que la entrada, mientras que los **strides** ajustan cómo se aplica el filtro.

### **Conclusión**

- **Padding** ayuda a mantener el tamaño de la imagen y prevenir la pérdida de información en los bordes.

- **Strides** controlan la velocidad con la que el filtro se mueve a través de la imagen, afectando el tamaño de la salida.

El correcto uso de **padding** y **strides** es crucial para controlar las dimensiones y el rendimiento de los modelos de CNN.

Francisco Franco

student•

Dos conceptos muy importantes en las redes neuronales convolucionales son los Padding y strides, estos afectan cómo se aplica la convolución a las imágenes de entrada.

Padding se refiere a la adición de bordes alrededor de la imagen de entrada antes de aplicar la convolución.

Strides se refiere al paso con el cual se desplaza el filtro durante la convolucion.

Joel Orellana

student•

Carlos que genial, tus explicaciones!

Andres Gutiérrez Castillo

student•

Padding: es un margen que se le agrega a la imagen para que al momento de realizar la operación de convolución la imagen resultante no reduzca su tamaño. Se utilizan 0 para que no altere las características de las imágenes original.

Stride: Es el tamaño del paso en cada convolución. Entre mas grande sea el paso menor será la imagen resultante.

Padding y Strides

Redes convolucionales y su importancia

La importancia del computer vision

¿Qué herramientas usaremos para redes neuronales convolucionales?

¿Qué son las redes convolucionales?

Mi primera red neuronal convolucional

Creando nuestra primera red convolucional

Entrenando nuestra primera red convolucional

Manejo de imágenes

Consejos para el manejo de imágenes

Manejo de imágenes con Python

Fundamentos de redes neuronales convolucionales

Kernel en redes neuronales

El kernel en acción

Padding y Strides

Capa de pooling

Arquitectura de redes convolucionales

Resolviendo un problema de clasificación

Clasificación con redes neuronales convolucionales

Creación de red convolucional para clasificación

Entrenamiento de un modelo de clasificación con redes convolucionales

Optimización de red neuronal convolucional

Data augmentation

Aplicando data augmentation

Callbacks: early stopping y checkpoints

Batch normalization

Optimización de modelo de clasificación

Entrenamiento de nuestro modelo de clasificación optimizado

Resolviendo una competencia de Kaggle

Clasificando entre perros y gatos

Entrenamiento del modelo de clasificación de perros y gatos

Resumen y siguientes pasos

Siguientes pasos con redes neuronales convolucionales

Comparte tu proyecto de clasificación con redes convolucionales y certifícate