Evaluar bien: métricas, matriz de confusión y curva ROC

a) VN = 850 (correos normales que llegan a la bandeja), FP = 10 (correos normales mandados a la basura), FN = 40 (basura que se coló) y VP = 100 (basura atrapada).

b)

• Exactitud = (100 + 850) / 1000 = 0,95
• Precisión = 100 / (100 + 10) = 100 / 110 ≈ 0,909
• Exhaustividad = 100 / (100 + 40) = 100 / 140 ≈ 0,714
• F1 = 2 · 0,909 · 0,714 / (0,909 + 0,714) ≈ 0,8

c) Precisión: de cada 11 correos que el filtro manda a la basura, 10 eran basura de verdad. Exhaustividad: de cada 7 correos basura que llegan, el filtro atrapa 5 y deja pasar 2.

Para comprobarlo con código, armamos dos arreglos que tengan esa matriz:

# 860 correos normales y 140 de basura
y_r = np.array([0] * 860 + [1] * 140)
y_p = np.array([0] * 850 + [1] * 10 + [0] * 40 + [1] * 100)
print(confusion_matrix(y_r, y_p))
print(f"exactitud {accuracy_score(y_r, y_p):.3f}"
      f"   precisión {precision_score(y_r, y_p):.3f}"
      f"   exhaustividad {recall_score(y_r, y_p):.3f}"
      f"   F1 {f1_score(y_r, y_p):.3f}")

[[850  10]
 [ 40 100]]
exactitud 0.950   precisión 0.909   exhaustividad 0.714   F1 0.800

1. Es peor un falso negativo: un enfermo que no se detecta pierde el tratamiento temprano, mientras que un falso positivo solo cuesta repetir el análisis. Mira la exhaustividad y baja el umbral.
2. Es peor un falso positivo: un correo importante que termina en la basura y nadie ve. Un correo basura que se cuela solo molesta. Mira la precisión.
3. Lo que importa es que, de las 20 casas elegidas, la mayor cantidad tenga fallas de verdad: es la precisión entre los 20 primeros. Que se escapen otras casas es inevitable con un solo inspector.
4. Clases equilibradas y errores del mismo costo: la exactitud sirve bien.
5. Todavía no hay umbral: el AUC compara qué tan bien ordena cada modelo. Como el fraude es muy raro, conviene mirar también la curva precisión–exhaustividad.

def matriz_confusion(y_real, y_pred, k):
    m = np.zeros((k, k), dtype=int)
    for r, p in zip(y_real, y_pred):
        m[r, p] += 1                 # fila = real, columna = predicho
    return m

mia = matriz_confusion(y3_prueba, p3, 3)
print(mia)
print("Igual a scikit-learn:",
      np.array_equal(mia, confusion_matrix(y3_prueba, p3)))
# La exhaustividad de cada clase: la diagonal entre el total de su fila
print("Exhaustividad por clase:",
      np.round(np.diag(mia) / mia.sum(axis=1), 2))

[[338  18   2]
 [ 34  30   5]
 [ 10   5   8]]
Igual a scikit-learn: True
Exhaustividad por clase: [0.94 0.43 0.35]

La diagonal son los aciertos. La exhaustividad de cada clase se lee por filas (de los casos reales de esa clase, cuántos acertó) y la precisión, por columnas. Sin el bucle, np.add.at(m, (y_real, y_pred), 1) hace lo mismo de una vez.

vn, fp, fn, vp = 955, 25, 5, 15
total = vn + fp + fn + vp
print(f"Exactitud del modelo: {(vp + vn) / total:.3f}")
print(f"Exactitud del tonto:  {(vn + fp) / total:.3f}")
print(f"Exhaustividad del modelo: {vp / (vp + fn):.2f}"
      f"   precisión: {vp / (vp + fp):.3f}")

Exactitud del modelo: 0.970
Exactitud del tonto:  0.980
Exhaustividad del modelo: 0.75   precisión: 0.375

a) El modelo tiene una exactitud de 0,97 y el tonto, de 0,98: el tonto «gana» en exactitud.

b) El tonto no encuentra ninguna pieza fallada (exhaustividad 0). El modelo encuentra 15 de las 20 (exhaustividad 0,75), a cambio de 25 falsas alarmas: de cada 8 piezas que marca, 3 tienen la falla. Si una pieza fallada que sale de la fábrica es cara, el modelo es mucho mejor, aunque su exactitud sea más baja. La exactitud sola habría elegido al modelo inútil.

Original:         0.9917
Puntajes / 2:     0.9917
Puntajes al cubo: 0.9917
1 − puntajes:     0.0083

Dividir entre 2 o elevar al cubo cambia los números, pero no cambia el orden de los casos: el que tenía más puntaje sigue teniendo más. Como el AUC solo mira el orden (la probabilidad de que un positivo tenga más puntaje que un negativo), queda igual. En cambio, la exactitud con umbral 0,5 sí cambiaría, porque con los puntajes divididos entre 2 casi ninguno pasaría de 0,5.

Con 1 − puntajes el orden se invierte y el AUC pasa a 1 − 0,9917 = 0,0083: un modelo que se equivoca casi siempre en el orden. Un AUC muy por debajo de 0,5 no es un modelo inútil, es uno al revés: invirtiendo su respuesta sería excelente. Lo verdaderamente inútil es un AUC cerca de 0,5.

from sklearn.model_selection import cross_val_predict
from sklearn.pipeline import make_pipeline

tuberia = make_pipeline(StandardScaler(), LogisticRegression())

# Paso 1: puntajes «fuera de pliegue» del entrenamiento
proba_cv = cross_val_predict(tuberia, X_ent, y_ent, cv=5,
                             method="predict_proba")[:, 1]

# Paso 2: el umbral más alto que cumple cada objetivo
prec_cv, exh_cv, umb_cv = precision_recall_curve(y_ent, proba_cv)
elegidos = []
for objetivo in [0.95, 0.98]:
    cumple = exh_cv[:-1] >= objetivo
    u = umb_cv[cumple].max()
    i = list(umb_cv).index(u)
    elegidos.append(u)
    # Métricas medidas en la validación cruzada
    print(f"Objetivo {objetivo}: umbral {u:.3f}  exhaustividad"
          f" {exh_cv[i]:.3f}  precisión {prec_cv[i]:.3f}")

# Pasos 3 y 4: una sola vez sobre la prueba
tuberia.fit(X_ent, y_ent)
proba_t = tuberia.predict_proba(X_prueba)[:, 1]
print("En la prueba:")
for u in elegidos + [0.5]:
    p = (proba_t >= u).astype(int)
    vn, fp, fn, vp = confusion_matrix(y_prueba, p).ravel()
    print(f"umbral {u:.3f}:  VP={vp} FN={fn} FP={fp} VN={vn}"
          f"   exhaustividad={recall_score(y_prueba, p):.3f}"
          f"  precisión={precision_score(y_prueba, p):.3f}")

Objetivo 0.95: umbral 0.565  exhaustividad 0.953  precisión 1.000
Objetivo 0.98: umbral 0.179  exhaustividad 0.986  precisión 0.912
En la prueba:
umbral 0.565:  VP=59 FN=5 FP=2 VN=105   exhaustividad=0.922  precisión=0.967
umbral 0.179:  VP=61 FN=3 FP=13 VN=94   exhaustividad=0.953  precisión=0.824
umbral 0.500:  VP=60 FN=4 FP=4 VN=103   exhaustividad=0.938  precisión=0.938

• Por qué el umbral más alto: todos los umbrales más bajos también cumplen la condición (bajar el umbral nunca baja la exhaustividad), pero dan más falsas alarmas. El más alto que todavía la cumple es el de mayor precisión.
• El umbral justo en 0,95 no alcanza en la prueba: en la validación cruzada llegaba a 0,953, pero en la prueba se escapan 5 de 64 malignos (exhaustividad 0,922, un 7,8 % de malignos perdidos). Ni siquiera el 0,5 cumple: pierde 4.
• Con el margen sí se cumple: el umbral de 0,179 deja escapar 3 de 64 (exhaustividad 0,953, un 4,7 % perdido). El precio son 13 falsas alarmas en lugar de 4: de cada 74 tumores que el modelo manda a revisión, 61 son malignos. Para un primer filtro médico, es un buen negocio.
• Por qué hace falta el margen: las métricas se miden con pocos casos. Con 64 malignos en la prueba, cada tumor que se escapa mueve la exhaustividad en más de 0,015, así que un umbral elegido justo en el límite puede fallar fácilmente con casos nuevos. El margen se decide antes de mirar la prueba; lo que no se debe hacer es volver a elegir el umbral después de ver cómo le fue en ella.