Repartir la culpa hacia atrás

Mete el bucle alrededor y mira bajar la pérdida.

A1 = rng.normal(0, 0.5, (3, 4)); c1 = np.zeros(4)
A2 = rng.normal(0, 0.5, (4, 1)); c2 = np.zeros(1)

for i in range(2001):
    hh = np.tanh(X @ A1 + c1)
    pp = sigmoide(hh @ A2 + c2)
    if i % 500 == 0:
        print(f'vuelta {i:4d}  pérdida {perdida(pp, y):.4f}')
    e2 = (pp - y) / len(X)
    e1 = (e2 @ A2.T) * (1 - hh ** 2)
    A2 -= 0.5 * (hh.T @ e2); c2 -= 0.5 * e2.sum(axis=0)
    A1 -= 0.5 * (X.T @ e1); c1 -= 0.5 * e1.sum(axis=0)

vuelta    0  pérdida 0.7716
vuelta  500  pérdida 0.4163
vuelta 1000  pérdida 0.3791
vuelta 1500  pérdida 0.3576
vuelta 2000  pérdida 0.3239

Baja de 0,7716 a 0,3239 y sigue bajando. Y ahora fíjate en lo importante: el y de este ejemplo lo generé tirando una moneda. No hay absolutamente nada que aprender.

O sea que esa pérdida que baja tan bonito es memorización pura. Con 50 filas y 21 pesos, la red se aprende el ruido de carrerilla, y una curva de entrenamiento preciosa no significa nada por sí sola.

Ese es el capítulo 8 en un ejercicio, y es la razón de que exista el conjunto de prueba 🎲

Imprime d1 y mira su forma y su tamaño.

print('forma de d1:', d1.shape, ' (una fila por dato, una columna por neurona)')
print()
print('culpa media que recibe cada una de las 4 neuronas ocultas:')
print(np.round(np.abs(d1).mean(axis=0), 6))
print()
print('culpa media de la capa de salida:', round(float(np.abs(d2).mean()), 6))

forma de d1: (50, 4)  (una fila por dato, una columna por neurona)

culpa media que recibe cada una de las 4 neuronas ocultas:
[0.003179 0.001939 0.000598 0.001484]

culpa media de la capa de salida: 0.009784

Cada neurona oculta recibe una cantidad de culpa distinta, según con qué peso contribuyó a la salida.

Y fíjate en la comparación con la de salida: ya en una sola capa hacia atrás la culpa se hizo más pequeña. Multiplica eso diez veces y tienes el problema de arriba 📉

Quita el * (1 - h ** 2) y compara el gradiente con el numérico.

d1_mal = d2 @ W2.T                 # sin multiplicar por la pendiente
dW1_mal = X.T @ d1_mal

correcto = gradiente_numerico(W1, 'W1')
print('con pendiente, error:', float(np.abs(dW1 - correcto).max()))
print('sin pendiente, error:', float(np.abs(dW1_mal - correcto).max()))

con pendiente, error: 1.1404513444723818e-10
sin pendiente, error: 0.0312959323249657

El correcto se equivoca en 1,1e-10 y el otro en 0,0313, o sea trescientos millones de veces más.

Y esto no da ningún error: la red entrena, la pérdida baja algo, y los pesos van a un sitio que no es. Es el tipo de fallo que solo caza el gradient checking, y por eso existe 🔍

Añade una capa y comprueba que la retropropagación es la misma línea repetida.

V1 = rng.normal(0, 0.5, (3, 4)); e1b = np.zeros(4)
V2 = rng.normal(0, 0.5, (4, 4)); e2b = np.zeros(4)
V3 = rng.normal(0, 0.5, (4, 1)); e3b = np.zeros(1)

k1 = np.tanh(X @ V1 + e1b)
k2 = np.tanh(k1 @ V2 + e2b)
q = sigmoide(k2 @ V3 + e3b)

g3 = (q - y) / len(X)
g2 = (g3 @ V3.T) * (1 - k2 ** 2)
g1 = (g2 @ V2.T) * (1 - k1 ** 2)

print('culpa media en la capa 3 (salida):', round(float(np.abs(g3).mean()), 8))
print('culpa media en la capa 2         :', round(float(np.abs(g2).mean()), 8))
print('culpa media en la capa 1         :', round(float(np.abs(g1).mean()), 8))

culpa media en la capa 3 (salida): 0.01017376
culpa media en la capa 2         : 0.0026545
culpa media en la capa 1         : 0.0011628

Una línea por capa, siempre igual: reparte con la matriz de la siguiente y multiplica por la pendiente de esta.

Ese patrón se repite tanto que se acabó automatizando, y a eso se le llama diferenciación automática. Es lo que hacen PyTorch y TensorFlow por dentro, y es básicamente esta línea con contabilidad 🧾

Compara las pendientes máximas de las dos.

print('pendiente máxima de la sigmoide:', 0.25)
print('pendiente máxima de tanh       :', 1.0)
print()
for capas in [2, 5, 10, 20]:
    print(f'{capas:2d} capas: sigmoide {0.25 ** capas:.3e}   tanh {1.0 ** capas:.3e}')

pendiente máxima de la sigmoide: 0.25
pendiente máxima de tanh       : 1.0

 2 capas: sigmoide 6.250e-02   tanh 1.000e+00
 5 capas: sigmoide 9.766e-04   tanh 1.000e+00
10 capas: sigmoide 9.537e-07   tanh 1.000e+00
20 capas: sigmoide 9.095e-13   tanh 1.000e+00

Por eso en los años 90, cuando todavía no existía ReLU, la recomendación era usar tanh en vez de sigmoide en las capas del medio.

Con la sigmoide reservada para la salida, que es donde sí la quieres porque devuelve algo entre 0 y 1. Cada función en su sitio 🎚️

Cuenta las evaluaciones que hace el gradient checking.

pesos_totales = W1.size + b1.size + W2.size + b2.size
print('pesos de esta red diminuta:', pesos_totales)
print('evaluaciones para comprobar:', pesos_totales * 2)
print()
print('en una red con un millón de pesos serían:', 1_000_000 * 2, 'evaluaciones')
print('mientras que la retropropagación cuesta como UNA pasada hacia adelante')

pesos de esta red diminuta: 21
evaluaciones para comprobar: 42

en una red con un millón de pesos serían: 2000000 evaluaciones
mientras que la retropropagación cuesta como UNA pasada hacia adelante

Cuarenta y dos evaluaciones para una red de 21 pesos, y dos millones para una de un millón.

Ahí está por qué la retropropagación fue un hallazgo y no una obviedad: calcula todos los gradientes de golpe por el precio de una pasada. Sin ella, entrenar redes grandes sería imposible, y el gradient checking se queda como herramienta de depuración sobre un puñado de pesos 🧮

Entrena la red de dos capas, escrita por nosotras, sobre el CSV de verdad. Es un adelanto del capítulo 7.

import pandas as pd
from sklearn.compose import ColumnTransformer
from sklearn.impute import SimpleImputer
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import roc_auc_score
from sklearn.model_selection import train_test_split
from sklearn.pipeline import Pipeline
from sklearn.preprocessing import OneHotEncoder, StandardScaler

URL = 'https://missyera.com/static/datasets/ventas-miss-yera.csv'

def carga_limpia(url):
    v = pd.read_csv(url).drop_duplicates()
    v['ciudad'] = (v['ciudad'].str.strip().str.lower()
                   .str.normalize('NFKD')
                   .str.encode('ascii', 'ignore').str.decode('utf-8'))
    v['monto'] = pd.to_numeric(v['monto'].str.replace(',', '.'))
    for col in ['fecha', 'fecha_ultima_compra']:
        f = pd.to_datetime(v[col], format='%Y-%m-%d', errors='coerce')
        falta = f.isna() & v[col].notna()
        f[falta] = pd.to_datetime(v.loc[falta, col], format='%d/%m/%Y', errors='coerce')
        v[col] = f
    return v

ventas = carga_limpia(URL).sort_values(['cliente_id', 'fecha']).copy()
ventas['sin_compra_previa'] = ventas['fecha_ultima_compra'].isna().astype(int)
ventas['sin_descuento'] = ventas['descuento'].isna().astype(int)
ventas['sin_satisfaccion'] = ventas['satisfaccion'].isna().astype(int)
ventas['precio_unitario'] = ventas['monto'] / ventas['unidades']
ventas['visita_numero'] = ventas.groupby('cliente_id').cumcount() + 1

NUM = ['unidades', 'monto', 'descuento', 'satisfaccion', 'precio_unitario',
       'sin_compra_previa', 'sin_descuento', 'sin_satisfaccion', 'visita_numero']
CAT = ['ciudad', 'segmento', 'canal', 'categoria']

Xv_tr, Xv_te, yv_tr, yv_te = train_test_split(
    ventas[NUM + CAT], ventas['compro'], test_size=0.25,
    random_state=42, stratify=ventas['compro'])

logistica = Pipeline([
    ('pre', ColumnTransformer([
        ('num', Pipeline([('r', SimpleImputer(strategy='median')),
                          ('e', StandardScaler())]), NUM),
        ('cat', Pipeline([('r', SimpleImputer(strategy='most_frequent')),
                          ('c', OneHotEncoder(handle_unknown='ignore'))]), CAT),
    ])),
    ('mod', LogisticRegression(max_iter=1000, random_state=42)),
]).fit(Xv_tr, yv_tr)

Tv_tr = logistica.named_steps['pre'].transform(Xv_tr)
Tv_te = logistica.named_steps['pre'].transform(Xv_te)
obj = yv_tr.values.astype(float).reshape(-1, 1)

r = np.random.default_rng(0)
M1 = r.normal(0, 0.1, (Tv_tr.shape[1], 8)); n1 = np.zeros(8)
M2 = r.normal(0, 0.1, (8, 1)); n2 = np.zeros(1)

for _ in range(2000):
    hh = np.tanh(Tv_tr @ M1 + n1)
    pp = sigmoide(hh @ M2 + n2)
    f2 = (pp - obj) / len(obj)
    f1 = (f2 @ M2.T) * (1 - hh ** 2)
    M2 -= 0.5 * (hh.T @ f2); n2 -= 0.5 * f2.sum(axis=0)
    M1 -= 0.5 * (Tv_tr.T @ f1); n1 -= 0.5 * f1.sum(axis=0)

pred = sigmoide(np.tanh(Tv_te @ M1 + n1) @ M2 + n2).ravel()
print('nuestra red de 2 capas:', round(roc_auc_score(yv_te, pred), 4))
print('logística de sklearn  :', round(roc_auc_score(
    yv_te, logistica.predict_proba(Xv_te)[:, 1]), 4))

nuestra red de 2 capas: 0.6651
logística de sklearn  : 0.7214

Funciona: 0,6651 con una red que escribimos nosotras, sobre las ventas de verdad, con sus nulos y su OneHotEncoder 🎉

Y pierde contra la logística, que saca 0,7214. Que es exactamente lo que el capítulo 1 anunció y lo que el capítulo 4 explicó: en estos datos no hay ninguna esquina cruzada, así que la capa oculta no tiene dónde ayudar y solo añade 2.000 vueltas de tropiezos.

Lo importante de este ejercicio no es el número: es que ya puedes entrenar una red sobre datos reales sin importar ninguna librería de deep learning. En el capítulo 7 la ponemos a punto 💪

Calcula d1 antes que d2, que es lo que sale si escribes el bloque de arriba abajo sin pensar.

del d2
d1_temprano = (d2 @ W2.T) * (1 - h ** 2)

NameError: name 'd2' is not defined

Obvio dicho así, y a la vez es el fallo conceptual más común cuando alguien escribe su primera red: hacia atrás significa hacia atrás. La última capa se calcula primero porque es la única que sabe algo sin depender de nadie.

Si te sale este error, casi siempre es que ordenaste el bloque como el de adelante 🔄