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.

a) Ana: en los 8 días de lluvia se aleja 1 − 0,8 = 0,2, que al cuadrado da 0,04; en los 2 días secos se aleja 0,8, que al cuadrado da 0,64. Brier = (8 · 0,04 + 2 · 0,64) / 10 = (0,32 + 1,28) / 10 = 0,16. Beto: en los días de lluvia acierta de lleno (0) y en los 2 secos se aleja 1, que al cuadrado da 1. Brier = 2 / 10 = 0,2. Ana está mejor calibrada: cuando dice 80 %, llueve el 80 % de las veces; Beto dice 100 % y se equivoca 2 de cada 10 veces.

b)

lluvia = np.array([1] * 8 + [0] * 2)
for dice in [0.5, 0.7, 0.8, 0.9, 1.0]:
    p = np.full(10, dice)
    print(f"Siempre {dice}: Brier {brier_score_loss(lluvia, p):.3f}")

Siempre 0.5: Brier 0.250
Siempre 0.7: Brier 0.170
Siempre 0.8: Brier 0.160
Siempre 0.9: Brier 0.170
Siempre 1.0: Brier 0.200

El mejor número fijo es 0,8, justo la fracción de días con lluvia. El Brier premia decir la probabilidad verdadera: exagerar hacia 1 o achicar hacia 0,5 lo empeora.

for nombre, Xs, ys in [("ajuste", Xc_aj, yc_aj),
                       ("calibración", Xc_cal, yc_cal)]:
    p = knn_c.predict_proba(Xs)[:, 1]
    print(f"Brier con los datos de {nombre}: "
          f"{brier_score_loss(ys, p):.3f}")

mal = CalibratedClassifierCV(FrozenEstimator(knn_c), method="sigmoid")
mal.fit(Xc_aj, yc_aj)          # ¡con los datos de entrenamiento!
bien = modelos_c["k-NN sigmoid"]

seguro = p_knn_prueba == 1      # donde el k-NN dice 100 %
print(f"El k-NN dice 100 % en {seguro.sum()} casos de prueba; "
      f"eran positivos el {yc_prueba[seguro].mean():.1%}")
for nombre, mod in [("bien", bien), ("mal", mal)]:
    p = mod.predict_proba(Xc_prueba)[:, 1]
    print(f"Calibrado {nombre}: ahí dice {p[seguro].mean():.1%}"
          f"   log-loss {log_loss(yc_prueba, p):.3f}")

Brier con los datos de ajuste: 0.080
Brier con los datos de calibración: 0.119
El k-NN dice 100 % en 346 casos de prueba; eran positivos el 94.8%
Calibrado bien: ahí dice 95.7%   log-loss 0.383
Calibrado mal: ahí dice 98.6%   log-loss 0.413

a) Con sus datos de ajuste el k-NN parece mucho mejor que con datos nuevos: Brier 0,080 contra 0,119. Cada caso de ajuste es uno de sus propios 5 vecinos (está a distancia 0 de sí mismo), así que siempre «vota» por su clase verdadera.

b) El calibrador que aprendió con los datos de ajuste vio al k-NN en su mejor día y le cree de más: donde el k-NN dice 100 %, él dice 98,6 %, cuando en la prueba fueron positivos el 94,8 %. El que calibramos con datos separados dice 95,7 %, mucho más cerca, y su log-loss es más baja (0,383 contra 0,413). La corrección se aprende siempre con datos que el modelo no vio al entrenar.

vp10 = np.diag(cm10)               # los aciertos de cada dígito
fp10 = cm10.sum(axis=0) - vp10     # por columnas: lo que dijo de más
fn10 = cm10.sum(axis=1) - vp10     # por filas: lo que se le escapó
print("FP por dígito:", fp10)
print("FN por dígito:", fn10)

d = fp10.argmax()
print(f"Más falsos positivos: el {d}, con precisión "
      f"{vp10[d]}/{vp10[d] + fp10[d]} = "
      f"{vp10[d] / (vp10[d] + fp10[d]):.3f}")
prec10 = precision_score(y10_prueba, pred10, average=None)
print(f"Según scikit-learn: {prec10[d]:.3f}")
print("Fila del 5:   ", cm10[5])
print("Columna del 5:", cm10[:, 5])

FP por dígito: [0 4 0 0 0 2 1 1 2 1]
FN por dígito: [0 2 1 1 2 2 0 0 2 1]
Más falsos positivos: el 1, con precisión 35/39 = 0.897
Según scikit-learn: 0.897
Fila del 5:    [ 0  0  0  0  0 35  1  1  0  0]
Columna del 5: [ 0  0  0  1  0 35  0  0  0  1]

a) Los falsos positivos de un dígito son su columna menos el acierto, y los falsos negativos, su fila menos el acierto. En total hay 11 de cada uno: cada error es a la vez un falso negativo del dígito real y un falso positivo del dígito que dijo el modelo.

b) El 1: el modelo dijo «1» 39 veces y 4 no lo eran (un 2, un 4 y dos 8). Su precisión es 35 / 39 = 0,897, igual a la de scikit-learn. Es la precisión más baja de los diez dígitos, aunque su exhaustividad (0,946) no sea la peor.

c) En su fila, un 5 se leyó como 6 y otro como 7: esos son sus falsos negativos. En su columna, el modelo dijo «5» ante un 3 y ante un 9: esos son sus falsos positivos. Las confusiones no son simétricas: que un 5 se lea como 6 no quiere decir que un 6 se lea como 5 (aquí, ningún 6 se leyó como 5).

1. Es regresión. Una regresión lineal se entrena con el MSE; como unos pocos atípicos lo dominan, el MAE es una alternativa como pérdida (o revisar y limpiar esos anuncios antes de entrenar). Como métrica, el MAE, que se lee en bolivianos y no se deja llevar por los atípicos; el R² sirve además para compararse con predecir siempre el precio promedio.
2. Son dos clases: una regresión logística con entropía cruzada binaria. La exactitud no sirve: el modelo que dice siempre «no es fraude» acierta el 99,8 %. Como el falso negativo es el error caro, mira la exhaustividad de la clase fraude y, para no ahogar a quien revisa, la precisión (o F1); el umbral se elige con validación, como en el mini-proyecto. Para comparar modelos antes de elegir el umbral, el AUC, junto con la curva precisión–exhaustividad, porque la clase es muy rara.
3. Son varias clases: entropía cruzada categórica con softmax (una logística o una red). Como la especie rara es la que importa, informa la exhaustividad de esa clase y el F1 macro, no la exactitud ni el micro, que la esconden. Y como la aplicación muestra probabilidades, revisa también la log-loss o el Brier y la calibración: ese «90 %» tiene que ser creíble.

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.