Deep Learning en Python y Tensorflow

Estructura de las capas en las redes

Una red de Keras es una pila de capas: cada una recibe un tensor, lo transforma y entrega otro, a veces con otra forma. Para leer o diseñar una red necesitas saber qué hace cada capa con la forma de los datos y cuántos parámetros aprende. En esta lección recorres las capas que usa el clasificador de prendas de PyShop.

Forma de entrada y forma de salida

Las fotos de Fashion-MNIST son de 28×28 píxeles en escala de grises. Keras trabaja con lotes, así que la primera dimensión de todo tensor es el tamaño del lote; en model.summary() aparece como None porque no se fija de antemano. Las capas de imagen esperan además un eje de canales al final: una foto en gris tiene 1 canal y una en color, 3. Por eso la entrada de la red convolucional es (28, 28, 1) y la del MLP, (28, 28).

Las capas del curso

• Dense(n). Capa densa: cada una de sus n neuronas se conecta con todas las entradas. Calcula $y = f(xW + b)$, donde $W$ es la matriz de pesos, $b$ el sesgo y $f$ la activación. Aprende $\text{entradas} \times n + n$ parámetros: la primera capa oculta del MLP tiene $784 \times 128 + 128 = 100{,}480$.
• Flatten(). Aplana cada ejemplo a un vector: (28, 28) pasa a 784 valores. No aprende nada (0 parámetros). Es el puente entre una imagen y una capa densa.
• Conv2D(filtros, tamaño). Desliza filtros pequeños, por ejemplo de 3×3, sobre la imagen y produce un mapa de características por filtro. Los mismos pesos se usan en todas las posiciones, así que detecta un borde o una textura esté donde esté. Sin relleno, una ventana de 3×3 recorta un píxel por lado: de 28×28 pasa a 26×26.
• MaxPooling2D(). Toma el máximo de cada ventana de 2×2 y reduce el alto y el ancho a la mitad, redondeando hacia abajo (11×11 pasa a 5×5). No aprende parámetros. Hace la red más barata y tolerante a pequeños desplazamientos.
• Dropout(tasa). Durante el entrenamiento apaga al azar una fracción de las entradas; al predecir no hace nada. No cambia la forma ni aprende parámetros. Es una defensa contra el sobreajuste.

La red convolucional, capa por capa

El bloque siguiente pasa una imagen vacía de forma (1, 28, 28, 1) por las capas de la CNN del curso e imprime la forma de salida y los parámetros de cada una:

import numpy as np
from keras import layers

x = np.zeros((1, 28, 28, 1), dtype="float32")
capas = [layers.Conv2D(32, 3, activation="relu"),
         layers.MaxPooling2D(),
         layers.Conv2D(64, 3, activation="relu"),
         layers.MaxPooling2D(),
         layers.Flatten(),
         layers.Dropout(0.3),
         layers.Dense(10, activation="softmax")]
for capa in capas:
    x = capa(x)
    nombre = type(capa).__name__
    print(f"{nombre:13} {tuple(x.shape)!s:17} {capa.count_params()}")

Salida:

Conv2D        (1, 26, 26, 32)   320
MaxPooling2D  (1, 13, 13, 32)   0
Conv2D        (1, 11, 11, 64)   18496
MaxPooling2D  (1, 5, 5, 64)     0
Flatten       (1, 1600)         0
Dropout       (1, 1600)         0
Dense         (1, 10)           16010

Los parámetros se pueden contar a mano. Un filtro de Conv2D tiene un peso por píxel de la ventana y por canal de entrada, más un sesgo:

En total son 34,826 parámetros, menos de la mitad que los 101,770 del MLP Flatten → Dense(128) → Dense(10). Aun así, en el curso la CNN acierta 0.902 en el conjunto de prueba contra 0.8746 del MLP. La diferencia está en la estructura: la capa densa trata cada píxel como una entrada independiente, mientras que la convolución reutiliza pocos pesos a lo largo de toda la imagen y conserva la vecindad entre píxeles.

La capa de salida

Para clasificar en 10 prendas, la última capa es Dense(10, activation="softmax"). Softmax convierte los 10 valores en probabilidades que suman 1; con tres valores, softmax de [2, 1, 0.1] da [0.659, 0.242, 0.099]. Para un problema de sí o no basta una neurona con sigmoide.

Otras capas que vas a encontrar

• BatchNormalization normaliza las activaciones de cada lote para que el entrenamiento sea más estable. Es uno de los extras del proyecto final.
• Capas recurrentes como LSTM y GRU procesan secuencias (texto, series de tiempo) paso a paso. No se usan en este curso, porque los datos son imágenes.

Cuándo usar cada una

Trampas comunes

• Olvidar el canal. Conv2D espera cuatro dimensiones (lote, alto, ancho, canales). Con las fotos en (60000, 28, 28) hay que añadir el eje con x[..., None].
• Contar el lote como parte de la forma. keras.Input(shape=(28, 28, 1)) describe un solo ejemplo; el lote se agrega solo.
• Esperar parámetros en Flatten, MaxPooling2D o Dropout. Cambian o filtran los datos, pero no aprenden pesos.
• Usar relu en la salida de un clasificador. La salida debe ser softmax para varias clases, o sigmoide para dos.

Antes de entrenar cualquier red, llama a model.summary() y comprueba que la forma de cada capa sea la que esperas. El notebook redes-convolucionales repite este recorrido y entrena la CNN completa.