Una CNN en animaciones: perros y gatos

# Si falta algo, descomenta, ejecuta una vez y reinicia el kernel:
# %pip install numpy pandas matplotlib pillow scikit-learn requests
# %pip install torch

from pathlib import Path
import sys, time
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from IPython.display import display
import torch
from torch import nn
from torch.utils.data import DataLoader, TensorDataset
from sklearn.model_selection import train_test_split
from sklearn.metrics import roc_auc_score, confusion_matrix

AQUI = next((p.resolve() for p in [Path.cwd(), Path.cwd() / 'ejemplo_clase',
                                    Path.cwd() / 'breastdcedl-usecase/ejemplo_clase']
             if (p / 'datos_perros_gatos.py').exists()), None)
if AQUI is None:
    raise FileNotFoundError('Abre el cuaderno desde la carpeta ejemplo_clase.')
for carpeta in (AQUI.parent / 'solution', AQUI):
    sys.path.insert(0, str(carpeta))

from modelo import CNNMama                           # LA red del proyecto
from dispositivo import semilla
from datos_perros_gatos import preparar, cargar_rgb  # 400 fotos, se descargan solas (~10 MB)
from dibujos import estilo, imagen, matriz
import animaciones as anim

estilo()
torch.set_num_threads(4)
device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
print('Dispositivo:', device)

LADO = 64
tabla = preparar().reset_index(drop=True)
imagenes = np.stack([cargar_rgb(r, lado=LADO) for r in tabla.ruta])      # (400, 64, 64, 3)
etiquetas = tabla.clase.to_numpy(dtype=np.float32)
ids_train, ids_val = train_test_split(np.arange(len(etiquetas)), test_size=.25,
                                      stratify=etiquetas, random_state=42)
X = torch.tensor(imagenes).permute(0, 3, 1, 2).contiguous()               # (400, 3, 64, 64)
y = torch.tensor(etiquetas)

id_perro = int(ids_val[etiquetas[ids_val] == 1][0])                        # nuestro perro
foto = imagenes[id_perro]
foto_grande = cargar_rgb(tabla.ruta[id_perro], lado=224)                   # solo para verla bien
gris_grande = foto_grande @ np.array([.2126, .7152, .0722], dtype=np.float32)

fig, axes = plt.subplots(2, 7, figsize=(17, 5.4))
imagen(axes[0, 0], foto_grande, 'NUESTRO PERRO\n(la red no lo ve al entrenar)')
imagen(axes[1, 0], foto, 'lo que entra: 64×64')
for ax, i in zip(axes[:, 1:].ravel(), ids_train[:12]):
    imagen(ax, imagenes[i], 'perro' if etiquetas[i] else 'gato')
plt.tight_layout(); plt.show()
print(f'Entrenar: {len(ids_train)} fotos   ·   Comprobar: {len(ids_val)} fotos')

anim.animar_arquitectura(LADO)

gris = foto @ np.array([.2126, .7152, .0722], dtype=np.float32)
fila, col = max(((r, c) for r in range(LADO - 8) for c in range(LADO - 8)),
                key=lambda rc: gris[rc[0]:rc[0] + 8, rc[1]:rc[1] + 8].std())   # el trozo con más contraste
bordes_verticales = np.array([[-1, 0, 1],
                              [-1, 0, 1],
                              [-1, 0, 1]], dtype=np.float32)
anim.animar_convolucion(gris[fila:fila + 8, col:col + 8], bordes_verticales, intervalo=450)

FILTROS = {
    'Identidad': ([[0, 0, 0], [0, 1, 0], [0, 0, 0]],
                  'Un 1 en el centro y ceros alrededor:\ncada píxel se queda igual.\nNo cambia nada.'),
    'Bordes verticales': ([[-1, 0, 1], [-2, 0, 2], [-1, 0, 1]],
                          'Resta la izquierda y suma la derecha.\nMarca los contornos de pie:\npatas, lados de la cara.'),
    'Bordes horizontales': ([[-1, -2, -1], [0, 0, 0], [1, 2, 1]],
                            'Resta arriba y suma abajo.\nMarca los contornos tumbados:\nlomo, ojos, boca.'),
    'Bordes diagonales': ([[0, 1, 2], [-1, 0, 1], [-2, -1, 0]],
                          'Compara una esquina con la opuesta.\nMarca las líneas inclinadas.'),
    'Todos los bordes': ([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]],
                         'El centro contra sus 8 vecinos.\nMarca cualquier cambio,\nen cualquier dirección.'),
    'Difuminar': ([[1 / 9] * 3] * 3,
                  'La media de los 9 píxeles.\nBorra el detalle fino:\nla foto queda borrosa.'),
    'Realzar': ([[0, -1, 0], [-1, 5, -1], [0, -1, 0]],
                'La foto más sus bordes.\nResalta el detalle: pelo, bigotes.'),
    'Relieve': ([[-2, -1, 0], [-1, 1, 1], [0, 1, 2]],
                'Una diagonal oscura y otra clara:\nparece iluminada desde un lado.'),
}
anim.animar_filtros_foto(gris_grande, FILTROS)

mi_filtro = np.array([[ 1,  1,  1],
                      [ 0,  0,  0],
                      [-1, -1, -1]], dtype=np.float32)

salida = anim._convolucion_numpy(gris_grande, mi_filtro)
fig, axes = plt.subplots(1, 2, figsize=(9, 4.3))
imagen(axes[0], gris_grande, 'la foto', cmap='gray', vmin=0, vmax=1)
tope = np.percentile(np.abs(salida), 99.5)
imagen(axes[1], salida, f'tu filtro (sus números suman {mi_filtro.sum():g})',
       cmap='RdBu_r' if abs(mi_filtro.sum()) < .05 else 'gray',
       vmin=-tope if abs(mi_filtro.sum()) < .05 else None, vmax=tope if abs(mi_filtro.sum()) < .05 else None)
plt.tight_layout(); plt.show()

fila_p, col_p = max(((r, c) for r in range(0, LADO - 8, 2) for c in range(0, LADO - 8, 2)),
                    key=lambda rc: gris[rc[0]:rc[0] + 8, rc[1]:rc[1] + 8].std())   # el trozo con más contraste
anim.animar_maxpool(gris[fila_p:fila_p + 8, col_p:col_p + 8])

anim.animar_pooling_foto(foto)

EPOCAS, LOTE, PASO = 20, 32, 5e-4

semilla(42)
red = CNNMama().to(device)
criterio = nn.BCEWithLogitsLoss()
optimizador = torch.optim.AdamW(red.parameters(), lr=PASO, weight_decay=1e-4)
planificador = torch.optim.lr_scheduler.CosineAnnealingLR(optimizador, T_max=EPOCAS)
cargador = DataLoader(TensorDataset(X[ids_train], y[ids_train]), batch_size=LOTE,
                      shuffle=True, drop_last=True, generator=torch.Generator().manual_seed(42))
x_perro = X[[id_perro]].to(device)


def predecir(ids):
    red.eval()
    with torch.inference_mode():
        return torch.cat([red(X[ids[i:i + 64]].to(device)).cpu() for i in range(0, len(ids), 64)])


def fotografiar(epoca):
    """Guarda cómo está la red en esta época."""
    fila = {'época': epoca}
    for parte, ids in [('entrenar', ids_train), ('comprobar', ids_val)]:
        salida = predecir(ids)
        fila[f'perdida_{parte}'] = criterio(salida, y[ids]).item()
        fila[f'acierto_{parte}'] = ((salida >= 0) == y[ids].bool()).float().mean().item()
    historial.append(fila)
    with torch.inference_mode():
        filtros_ep.append(red.bloque1[0].weight.detach().cpu().numpy().copy())
        mapas1_ep.append(red.bloque1[:3](x_perro)[0].cpu().numpy())               # Conv+BN+ReLU del bloque 1
        mapas2_ep.append(red.bloque2[:3](red.bloque1(x_perro))[0].cpu().numpy())  # y del bloque 2
        prob_perro_ep.append(red(x_perro).sigmoid().item())


historial, filtros_ep, mapas1_ep, mapas2_ep, prob_perro_ep = [], [], [], [], []
fotografiar(0)
reloj = time.perf_counter()
for epoca in range(1, EPOCAS + 1):
    red.train()
    for fotos, respuestas in cargador:
        fotos, respuestas = fotos.to(device), respuestas.to(device)
        voltear = torch.rand(len(fotos)) < .5
        fotos = torch.where(voltear[:, None, None, None].to(device), fotos.flip(3), fotos)
        optimizador.zero_grad()                          # 1
        prediccion = red(fotos)                          # 2
        perdida = criterio(prediccion, respuestas)       # 3
        perdida.backward()                               # 4
        optimizador.step()                               # 5
    planificador.step()
    fotografiar(epoca)
    print(f'época {epoca:2d}/{EPOCAS}   error {historial[-1]["perdida_entrenar"]:.3f}   '
          f'acierto en fotos nuevas {historial[-1]["acierto_comprobar"]:.0%}   '
          f'P(perro) de nuestro perro {prob_perro_ep[-1]:.2f}', flush=True)
historial = pd.DataFrame(historial)
red.eval()
print(f'\nTerminado en {time.perf_counter() - reloj:.0f} s.')

fig, axes = plt.subplots(1, 2, figsize=(13, 3.8))
for parte, color in [('entrenar', 'tab:blue'), ('comprobar', 'tab:orange')]:
    axes[0].plot(historial['época'], historial['perdida_' + parte], 'o-', ms=4, color=color, label=parte)
    axes[1].plot(historial['época'], historial['acierto_' + parte], 'o-', ms=4, color=color, label=parte)
axes[0].set(title='El error baja', xlabel='época')
axes[1].set(title='El acierto sube', xlabel='época', ylim=(.4, 1))
axes[1].axhline(.5, color='gray', ls=':')
for ax in axes:
    ax.legend(); ax.grid(alpha=.2)
plt.tight_layout(); plt.show()

anim.animar_mapas_aprendiendo(foto, filtros_ep, mapas1_ep, mapas2_ep, historial, prob_perro_ep,
                              es_perro=True)

with torch.inference_mode():
    tras_conv = red.bloque1[0](x_perro)
    tras_bn = red.bloque1[1](tras_conv)
    tras_relu = red.bloque1[2](tras_bn)
    tras_pool = red.bloque1[3](tras_relu)

etapas_bloque = [
    ('la entrada', 'Tres mapas: el rojo, el verde y el azul de la foto.', x_perro[0]),
    ('Conv2d (16 filtros)', 'Cada filtro da un mapa. Rojo = el filtro responde a favor; azul = en contra.', tras_conv[0]),
    ('BatchNorm2d', 'Los mismos mapas, puestos a una escala parecida entre sí.', tras_bn[0]),
    ('ReLU', 'Lo negativo se apaga: solo queda lo que cada filtro SÍ ha encontrado.', tras_relu[0]),
    ('MaxPool2d', 'La mitad de tamaño: de cada cuadrito 2×2 se queda lo más fuerte.', tras_pool[0]),
]
anim.animar_etapas(foto, [(t, e, m.cpu().numpy()) for t, e, m in etapas_bloque])

with torch.inference_mode():
    salidas, paso = [('la entrada', 'La foto: 3 mapas (rojo, verde, azul) de 64×64.', x_perro[0])], x_perro
    explicaciones = ['Bordes, colores y manchas.',
                     'Combinaciones de bordes: esquinas, texturas.',
                     'Partes más grandes: formas, zonas del cuerpo.',
                     'Muy abstracto: cada mapa de 4×4 dice cuánto hay de «algo» y dónde, a grandes rasgos.']
    for b, explicacion in zip(['bloque1', 'bloque2', 'bloque3', 'bloque4'], explicaciones):
        paso = getattr(red, b)(paso)
        salidas.append((b, explicacion, paso[0]))
    p_perro = red(x_perro).sigmoid().item()

anim.animar_etapas(foto, [(t, e, m.cpu().numpy()) for t, e, m in salidas], intervalo=3000)

with torch.inference_mode():
    mapas_b4 = salidas[-1][2]                                       # (128, 4, 4): lo que sale del bloque 4
    vector = red.promedio(mapas_b4[None]).flatten(1)[0]             # promedio global + Flatten: (128,)
    lineal = red.clasificador[-1]
    pesos_lineal, sesgo_lineal = lineal.weight[0].detach().cpu(), lineal.bias.item()
    z_perro = red(x_perro).item()
# Comprobación: la suma a mano es exactamente el logit de la red.
assert abs((vector.cpu() @ pesos_lineal).item() + sesgo_lineal - z_perro) < 1e-4
print(f'bloque 4: {tuple(mapas_b4.shape)}  →  promedio + Flatten: {tuple(vector.shape)}  →  '
      f'Linear: z = {z_perro:+.3f}  →  sigmoide: P(perro) = {p_perro:.2f}')

anim.animar_final_red(foto, mapas_b4.cpu().numpy(), pesos_lineal.numpy(), sesgo_lineal)

bloques = [m.cpu().numpy() for _, _, m in salidas[1:]]              # los 4 bloques de la sección 8.2
anim.animar_red_simulacion(foto, bloques, vector.cpu().numpy(), pesos_lineal.numpy(), sesgo_lineal)

print('Nuestro perro era de las fotos que la red nunca vio al entrenar.',
      '¡Acierta!' if p_perro >= .5 else 'Esta vez se equivoca: le da menos de 0,5.')

probs = predecir(ids_val).sigmoid().numpy()
verdad = etiquetas[ids_val]
cm = confusion_matrix(verdad, probs >= .5, labels=[0, 1])

fig, axes = plt.subplots(1, 2, figsize=(12, 4))
matriz(axes[0], cm, f'acierta el {cm.trace() / cm.sum():.0%}  ·  AUC = {roc_auc_score(verdad, probs):.2f}', fmt='.0f')
axes[0].set(xlabel='lo que dijo la red', ylabel='lo que era', xticks=[0, 1], yticks=[0, 1],
            xticklabels=['gato', 'perro'], yticklabels=['gato', 'perro'])
axes[1].hist(probs[verdad == 0], bins=20, range=(0, 1), alpha=.65, label='gatos', color='tab:purple')
axes[1].hist(probs[verdad == 1], bins=20, range=(0, 1), alpha=.65, label='perros', color='tab:green')
axes[1].axvline(.5, color='black', ls='--')
axes[1].set(title='qué probabilidad les dio', xlabel='P(perro)')
axes[1].legend()
plt.tight_layout(); plt.show()

fig, axes = plt.subplots(2, 8, figsize=(18, 6))
for ax, i in zip(axes.ravel(), range(16)):
    acierto = (probs[i] >= .5) == bool(verdad[i])
    imagen(ax, imagenes[ids_val[i]], f"era {'perro' if verdad[i] else 'gato'}\nP(perro) = {probs[i]:.2f}")
    ax.title.set_color('tab:green' if acierto else 'tab:red')
fig.suptitle('16 fotos nuevas: verde = acierta, rojo = falla', fontsize=14)
plt.tight_layout(h_pad=2); plt.show()