Explicación del ejemplo introductorio (Perceptrón desde cero con OR)

Esta explicación corresponde solo al bloque anterior, donde se entrena un perceptrón desde cero para aprender la compuerta OR.

¿Qué se hizo en este ejemplo? (paso a paso)

1. Se cargó el dataset Iris Se usó load_iris() de scikit-learn, que trae 150 flores etiquetadas en 3 especies.

2. Se seleccionaron 2 variables de entrada De las 4 variables originales, se tomaron solo:

• Longitud del pétalo
• Ancho del pétalo

Esto se hace para poder graficar en 2D y entender mejor la frontera de decisión.

3. Se convirtió el problema a clasificación binaria La variable objetivo se transformó así:

• 1 si la flor es Iris Setosa
• 0 si es Versicolor o Virginica

4. Se creó y entrenó el modelo Se entrenó Perceptron(random_state=42) con X e y. El modelo aprende una combinación lineal de las variables para separar las dos clases.

5. Se probó una predicción puntual Se evaluó el modelo con una flor de ejemplo [[2, 0.5]] para ver si la clasifica como Setosa o no.

6. Se construyó una malla de puntos para visualizar Se generó una cuadrícula (meshgrid) que cubre el rango de los datos. En cada punto de esa malla, el modelo predice clase 0 o 1.

7. Se graficó la frontera de decisión

• El fondo coloreado muestra la clase que el modelo asigna en cada zona.
• Los puntos reales del dataset muestran dónde caen las flores observadas.
• La transición de color entre zonas representa la frontera de decisión lineal del Perceptrón.

Lectura rápida del resultado

Si la mayoría de puntos Setosa quedan en una zona y los no Setosa en otra, el modelo está separando bien para este caso. Si hay mezcla fuerte de colores y puntos, la separación no es buena con un modelo lineal.

Explicación Simple del Concepto de Frontera de Decisión

La frontera de decisión es la línea (o superficie) que separa diferentes categorías en un problema de clasificación.

🔴 🔴 🔴 | 🔵 🔵 🔵
🔴 🔴 🔴 | 🔵 🔵 🔵
🔴 🔴 🔴 | 🔵 🔵 🔵

Implementación de la Neurona de McCulloch-Pitts para la función AND

# Comentario: Simula una neurona de McCulloch-Pitts para la compuerta logica AND.

import numpy as np

def mcculloch_pitts_neuron(inputs, weights, threshold=1):
    """
    Implementa la neurona de McCulloch-Pitts con función escalón.
    """
    weighted_sum = np.dot(inputs, weights)  # Producto punto entre entradas y pesos
    return 1 if weighted_sum >= threshold else 0

# Prueba con la compuerta lógica AND
weights = [0.5, 0.5]  # Pesos asignados a las entradas
test_cases = [(0, 0), (0, 1), (1, 0), (1, 1)]  # Entradas posibles

print("Entrada  ->  Salida")
for x in test_cases:
    output = mcculloch_pitts_neuron(x, weights)
    print(f"{x} -> {output}")

Entrada  ->  Salida
(0, 0) -> 0
(0, 1) -> 0
(1, 0) -> 0
(1, 1) -> 1

Explicación del Resultado: Perceptrón en la Función XOR

🔴 El Perceptrón falla en aprender la función XOR.

¿Qué está pasando?

1️⃣ Resultados esperados de la función XOR
| Entrada (x1, x2) | Salida esperada y | Predicción del Perceptrón | |——————–|——————|———————-| | (0,0) | 0 | 0 ✅ | | (0,1) | 1 | 0 ❌ | | (1,0) | 1 | 0 ❌ | | (1,1) | 0 | 0 ✅ |

2️⃣ La frontera de decisión es incorrecta
- El Perceptrón clasifica todas las entradas como 0.
- No separa correctamente las clases, porque XOR no es linealmente separable.

3️⃣ ¿Por qué falla el Perceptrón?
- El Perceptrón solo puede aprender fronteras de decisión lineales.
- XOR requiere una frontera de decisión más compleja (no lineal).
- Se necesita una Red Neuronal con más de una capa (Perceptrón Multicapa - MLP).

Solución: Usar un Perceptrón Multicapa (MLP)

✅ Para resolver XOR, usar una red neuronal con capas ocultas y activaciones no lineales como ReLU o Sigmoid.

# Comentario: Usa un MLP para resolver XOR y mostrar una frontera no lineal.

# Implementación de un Perceptrón Multicapa (MLP) para la Función XOR

import numpy as np
import matplotlib.pyplot as plt
from sklearn.neural_network import MLPClassifier

# 1. Datos de entrada (X) y etiquetas esperadas (y) para la compuerta XOR
X = np.array([[0,0], [0,1], [1,0], [1,1]])  # Entradas binarias
y = np.array([0, 1, 1, 0])  # Salidas esperadas (función XOR)

# 2. Crear y entrenar un Perceptrón Multicapa (MLP) con parámetros ajustados
mlp = MLPClassifier(hidden_layer_sizes=(8, 4), activation='tanh', solver='adam', 
                    alpha=0.001, max_iter=20000, random_state=42, tol=1e-7)
mlp.fit(X, y)

# 3. Evaluación del modelo
predictions = mlp.predict(X)

# 4. Imprimir resultados de las predicciones
print("Entrada -> Salida (predicción)")
for i in range(len(X)):
    print(f"{X[i]} -> {predictions[i]}")

# 5. Crear una malla para visualizar la frontera de decisión
x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 200), np.linspace(y_min, y_max, 200))

# 6. Predecir sobre la malla
Z = mlp.predict(np.c_[xx.ravel(), yy.ravel()])
Z = Z.reshape(xx.shape)

# 7. Graficar la frontera de decisión
plt.figure(figsize=(8, 6))
plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.coolwarm)
plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.coolwarm, edgecolors="k", s=150)
plt.title("Frontera de Decisión del Perceptrón Multicapa para la función XOR")
plt.xlabel("Entrada X1")
plt.ylabel("Entrada X2")
plt.show()

Entrada -> Salida (predicción)
[0 0] -> 0
[0 1] -> 1
[1 0] -> 1
[1 1] -> 0

Clasificación Binaria con Perceptrón Simple

Usar el perceptrón para resolver un problema de clasificación binaria simple: la clasificación de puntos en el plano (2D) según si están por encima o por debajo de una línea recta

# Comentario: Entrena un perceptron simple en PyTorch con datos 2D y visualiza resultados.

import numpy as np
import matplotlib.pyplot as plt
import torch
import torch.nn as nn
import torch.optim as optim

# Generación de datos de ejemplo
np.random.seed(42)
X = np.random.randn(100, 2)
y = np.array([1 if x[0] + x[1] > 0 else 0 for x in X])

# Convertir a tensores
X_tensor = torch.tensor(X, dtype=torch.float32)
y_tensor = torch.tensor(y, dtype=torch.float32).view(-1, 1)

# Definición del perceptrón simple
class Perceptron(nn.Module):
    def __init__(self):
        super(Perceptron, self).__init__()
        self.linear = nn.Linear(2, 1)

    def forward(self, x):
        return torch.sigmoid(self.linear(x))

model = Perceptron()
criterion = nn.BCELoss()
optimizer = optim.SGD(model.parameters(), lr=0.1)

# Entrenamiento del perceptrón
epochs = 1000
for epoch in range(epochs):
    optimizer.zero_grad()
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)
    loss.backward()
    optimizer.step()

# Visualización de resultados
x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.1), np.arange(y_min, y_max, 0.1))
grid = torch.tensor(np.c_[xx.ravel(), yy.ravel()], dtype=torch.float32)
probs = model(grid).detach().numpy().reshape(xx.shape)

plt.contourf(xx, yy, probs, alpha=0.5)
plt.scatter(X[:, 0], X[:, 1], c=y, edgecolor='k')
plt.title('Frontera de decisión del Perceptrón Simple')
plt.show()

En este ejemplo, se crea un Perceptrón Simple usando PyTorch para clasificar puntos en un plano según si están por encima o por debajo de una línea. Primero, se generan datos aleatorios en 2D y se asigna una etiqueta (0 o 1) según la posición del punto. Luego, se define el modelo del perceptrón como una red muy simple que toma dos números como entrada y devuelve una probabilidad usando la función sigmoide. El entrenamiento se realiza ajustando los pesos para que el modelo acierte lo más posible, usando una técnica llamada Gradiente Descendente Estocástico (SGD). PyTorch facilita el manejo de estos cálculos automáticamente. Finalmente, se visualiza cómo el modelo aprendió a separar los puntos mostrando una línea de decisión en el gráfico.

Ejemplo Práctico: Clasificación de Puntos en Espiral usando un Perceptrón Multicapa (MLP)

def generate_spiral_data(points, classes):
    X = np.zeros((points * classes, 2), dtype=np.float32)
    y = np.zeros((points * classes, 1), dtype=np.float32)
    for class_number in range(classes):
        ix = range(points * class_number, points * (class_number + 1))
        r = np.linspace(0.0, 1, points)  # Radio creciente
        t = np.linspace(class_number * 4, (class_number + 1) * 4, points) + np.random.randn(points) * 0.2  # Ángulo
        X[ix] = np.c_[r * np.sin(t), r * np.cos(t)]
        y[ix] = class_number % 2  # Alterna entre 0 y 1
    return X, y

class SpiralMLP(nn.Module):
    def __init__(self):
        super(SpiralMLP, self).__init__()
        self.hidden = nn.Sequential(
            nn.Linear(2, 16),
            nn.ReLU(),
            nn.Linear(16, 8),
            nn.ReLU(),
            nn.Linear(8, 1),
            nn.Sigmoid()
        )

    def forward(self, x):
        return self.hidden(x)

model = SpiralMLP()
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.01)

for epoch in range(3000):
    optimizer.zero_grad()
    outputs = model(X_tensor)
    loss = criterion(outputs, y_tensor)
    loss.backward()
    optimizer.step()

x_min, x_max = X[:, 0].min() - 0.5, X[:, 0].max() + 0.5
y_min, y_max = X[:, 1].min() - 0.5, X[:, 1].max() + 0.5
xx, yy = np.meshgrid(np.linspace(x_min, x_max, 200), np.linspace(y_min, y_max, 200))
grid = torch.tensor(np.c_[xx.ravel(), yy.ravel()], dtype=torch.float32)
probs = model(grid).detach().numpy().reshape(xx.shape)

plt.figure(figsize=(8, 8))
plt.contourf(xx, yy, probs, alpha=0.6, cmap=plt.cm.coolwarm)
plt.scatter(X[:, 0], X[:, 1], c=y.ravel(), cmap=plt.cm.coolwarm, edgecolor="k")
plt.title("Frontera de Decisión del Perceptrón Multicapa para Datos en Espiral")
plt.show()

Perceptrón Multicapa usando Make Moons

X, y = make_moons(n_samples=500, noise=0.1, random_state=0)

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42, stratify=y
)

mlp = MLPClassifier(
    hidden_layer_sizes=(10, 5),
    activation='relu',
    solver='adam',
    max_iter=3000,
    random_state=42
)

mlp.fit(X_train, y_train)
print(f"Precisión en entrenamiento: {mlp.score(X_train, y_train) * 100:.2f}%")
print(f"Precisión en prueba: {mlp.score(X_test, y_test) * 100:.2f}%")

def plot_decision_boundary(X, y, model):
    x_min, x_max = X[:, 0].min() - 1, X[:, 0].max() + 1
    y_min, y_max = X[:, 1].min() - 1, X[:, 1].max() + 1
    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 100), np.linspace(y_min, y_max, 100))
    Z = model.predict(np.c_[xx.ravel(), yy.ravel()]).reshape(xx.shape)
    plt.contourf(xx, yy, Z, alpha=0.3, cmap=plt.cm.coolwarm)
    plt.scatter(X[:, 0], X[:, 1], c=y, cmap=plt.cm.coolwarm, edgecolor='k')
    plt.title("Frontera de Decisión del Perceptrón Multicapa - make_moons")
    plt.xlabel("X1")
    plt.ylabel("X2")
    plt.show()

💬 ¿Te sirvió?

Deja en los comentarios una duda o un caso donde aplicarías esto — respondo todos. Sígueme para no perderte el próximo artículo de la serie y comparte con alguien que esté aprendiendo análisis de datos.

👉 El código completo está disponible para ejecutar directamente.

Naive Benchmark (Benchmark Ingenuo): El Promedio

El criterio de referencia más simple en predicción, conocido como benchmark ingenuo, consiste en utilizar el valor promedio de la variable objetivo como predicción para todos los nuevos registros. Este enfoque ignora completamente la información de los predictores y se basa únicamente en el promedio de los valores de la variable de resultado del conjunto de entrenamiento.

Por ejemplo, si estamos intentando predecir el precio de una casa, el benchmark ingenuo predice el mismo precio promedio para cada nueva casa, sin considerar factores como la ubicación, el tamaño o el estado de la propiedad. Aunque esta técnica es muy básica y no proporciona ninguna información específica de cada registro, es útil como un punto de referencia.

La idea es que cualquier modelo predictivo que se desarrolle debe, como mínimo, superar esta predicción promedio en términos de precisión. En otras palabras, un buen modelo debería ser capaz de captar patrones en los datos y ofrecer predicciones que reduzcan el error promedio en comparación con este benchmark ingenuo. Si un modelo no puede mejorar sustancialmente este criterio de referencia, puede ser una señal de que el modelo no está capturando suficiente información relevante de los datos de entrada.

Medidas de Precisión de Predicción

El error de predicción para el registro se define como la diferencia entre su valor real y su valor predicho:

A continuación se describen las métricas más usadas para evaluar la precisión predictiva sobre el conjunto de validación (no sobre el de entrenamiento):

• MAE (Error Absoluto Medio): magnitud promedio del error, en las mismas unidades de .

  

• RMSE (Raíz del Error Cuadrático Medio): también en unidades de , pero penaliza más los errores grandes.

  

• MAPE (Error Porcentual Absoluto Medio): error relativo promedio. Útil para comparar escalas distintas; se vuelve inestable si algún es cero o muy cercano a cero.

  

• MPE (Error Porcentual Medio): igual que MAPE, pero con signo. Un MPE positivo indica subestimación promedio; uno negativo, sobreestimación.

  

Cómo leerlas juntas: si MAE es bajo y RMSE es mucho mayor, hay pocos errores pero muy grandes. Si el modelo no mejora el MAE/RMSE del benchmark ingenuo (predecir la media de entrenamiento), todavía no está aportando valor.

La implementación con un ejemplo numérico y la comparación contra el promedio aparecen en la celda siguiente.

import numpy as np
import pandas as pd
from sklearn.metrics import (
    mean_absolute_error,
    mean_squared_error,
    mean_absolute_percentage_error,
)

y_real = np.array([100.0, 200.0, 300.0, 400.0, 500.0])
y_pred = np.array([110.0, 190.0, 310.0, 405.0, 495.0])

# Benchmark ingenuo: predecir la media para todos los registros
media = y_real.mean()
y_naive = np.full_like(y_real, media)

detalle = pd.DataFrame({
    'y_real': y_real,
    'y_modelo': y_pred,
    'y_naive': y_naive,
    'error_modelo': y_real - y_pred,
    'error_naive': y_real - y_naive,
})
display(detalle)


def mpe(y_true, y_hat):
    return np.mean((y_true - y_hat) / y_true) * 100


def resumen_metricas(y_true, y_hat, nombre):
    mae = mean_absolute_error(y_true, y_hat)
    rmse = np.sqrt(mean_squared_error(y_true, y_hat))
    mape = mean_absolute_percentage_error(y_true, y_hat) * 100
    return {
        'enfoque': nombre,
        'MAE': mae,
        'RMSE': rmse,
        'MAPE (%)': mape,
        'MPE (%)': mpe(y_true, y_hat),
    }


comparacion = pd.DataFrame([
    resumen_metricas(y_real, y_pred, 'Modelo'),
    resumen_metricas(y_real, y_naive, 'Benchmark (media)'),
])
display(comparacion.round(3))

fila_modelo = comparacion.loc[comparacion['enfoque'] == 'Modelo'].iloc[0]
fila_naive = comparacion.loc[comparacion['enfoque'] == 'Benchmark (media)'].iloc[0]

print(f'Media usada como benchmark: {media:.1f}')
print(
    f"El modelo reduce el MAE de {fila_naive['MAE']:.3f} a {fila_modelo['MAE']:.3f} "
    f"y el RMSE de {fila_naive['RMSE']:.3f} a {fila_modelo['RMSE']:.3f}."
)
if abs(fila_modelo['RMSE'] - fila_modelo['MAE']) < 2:
    print('MAE y RMSE están cercanos: no hay errores extremos en este ejemplo.')

Media usada como benchmark: 300.0
El modelo reduce el MAE de 120.000 a 8.000 y el RMSE de 141.421 a 8.367.
MAE y RMSE están cercanos: no hay errores extremos en este ejemplo.

Punto de Referencia: Regla Ingenua (Naive)

La regla ingenua establece un punto de referencia básico para evaluar el rendimiento de un modelo. En el caso de modelos de regresión, esta regla consiste en predecir el valor promedio (media) de la variable objetivo para todos los casos. Para modelos de clasificación, se predice la clase más frecuente para todas las observaciones. La idea es que cualquier modelo predictivo debería superar este punto de referencia en términos de desempeño. Al comparar el modelo con esta regla, podemos verificar si el modelo está logrando capturar patrones útiles en los datos o si simplemente está imitando un enfoque básico.

Separación de Clases

La separación de clases mide la capacidad de un modelo para diferenciar entre distintas clases de datos. Si las predicciones de un modelo son efectivas, debería existir una clara separación entre las clases. Para evaluarlo, se pueden utilizar gráficos de dispersión y métricas que miden la distancia entre las clases, como la distancia euclidiana. Una buena separación de clases indica que el modelo puede generalizar mejor al clasificar nuevas observaciones. Además, se pueden utilizar técnicas de reducción de dimensionalidad, como PCA (Análisis de Componentes Principales) o t-SNE, para visualizar las separaciones en conjuntos de datos de alta dimensión.

Matriz de Confusión (Clasificación)

La matriz de confusión es una herramienta clave para evaluar modelos de clasificación. Organiza los resultados en cuatro categorías: - Verdaderos Positivos (TP): Predicciones correctas de la clase positiva. - Falsos Positivos (FP): Predicciones incorrectas donde se clasificó como positivo, pero el resultado real fue negativo. - Verdaderos Negativos (TN): Predicciones correctas de la clase negativa. - Falsos Negativos (FN): Predicciones incorrectas donde se clasificó como negativo, pero el resultado real fue positivo.

Con la matriz de confusión, podemos calcular diversas métricas importantes: - Exactitud (Accuracy): proporción de predicciones correctas. - Precisión de la clase positiva (Precision): exactitud al clasificar la clase positiva. - Sensibilidad (Recall): capacidad del modelo para capturar correctamente los casos positivos.

• Especificidad: capacidad del modelo para identificar correctamente los casos negativos.
• F1-score: combina precisión y recall para resumir el rendimiento cuando queremos equilibrar ambos aspectos.

La forma más común de interpretar la matriz es la siguiente: las filas representan la clase real y las columnas representan la clase predicha. Por tanto, la diagonal principal muestra los aciertos del modelo, mientras que los valores fuera de esa diagonal indican errores de clasificación.

En problemas de diagnóstico, por ejemplo, la clase positiva suele ser la condición de interés (por ejemplo, enfermo, fraude o incumplimiento), mientras que la clase negativa corresponde a la ausencia de esa condición.

Es importante recordar que la exactitud puede ser engañosa cuando las clases están desbalanceadas. Por ejemplo, si un 95% de los casos es negativo y el modelo predice siempre “negativo”, podría obtener una exactitud muy alta aunque no detecte ninguna instancia positiva. En esos casos, métricas como recall, precision, F1-score o AUC suelen ser más informativas.

Además, la matriz de confusión depende del umbral de decisión. Si reducimos el umbral para considerar más casos como positivos, aumentaremos la sensibilidad pero también pueden crecer los falsos positivos. Si aumentamos el umbral, se reducen los falsos positivos, pero puede perderse capacidad para detectar casos importantes. Por eso, en problemas donde los costos de error varían (por ejemplo, diagnóstico médico o detección de fraude), la elección del umbral es parte fundamental del diseño del modelo.

En resumen, la matriz de confusión no solo cuenta errores: muestra exactamente qué tipo de errores comete el modelo y permite decidir si el rendimiento es aceptable para el problema del negocio o la investigación.

3.2 Validación, costos y clases de distinta importancia

import pandas as pd
from sklearn.metrics import confusion_matrix, classification_report, accuracy_score
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier
from sklearn.dummy import DummyClassifier

iris = load_iris()
X = iris.data
y = iris.target

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.3, random_state=42, stratify=y
)

# Modelo limitado a propósito para que aparezcan errores en la matriz
clf = RandomForestClassifier(
    n_estimators=10, max_depth=2, random_state=0
)
clf.fit(X_train, y_train)

y_pred_train = clf.predict(X_train)
y_pred = clf.predict(X_test)

naive = DummyClassifier(strategy='most_frequent')
naive.fit(X_train, y_train)
acc_naive = accuracy_score(y_test, naive.predict(X_test))
acc_train = accuracy_score(y_train, y_pred_train)
acc_test = accuracy_score(y_test, y_pred)

print(f'Exactitud entrenamiento: {acc_train:.3f}')
print(f'Exactitud prueba:        {acc_test:.3f}')
print(f'Benchmark (clase más frecuente): {acc_naive:.3f}')
if acc_train - acc_test > 0.05:
    print('La brecha train/prueba sugiere algo de sobreajuste o un modelo inestable.')
else:
    print('La brecha train/prueba es moderada en este ejemplo.')

cm = confusion_matrix(y_test, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(
    cm,
    annot=True,
    fmt='d',
    cmap='Blues',
    xticklabels=iris.target_names,
    yticklabels=iris.target_names
)
plt.xlabel('Predicción')
plt.ylabel('Real')
plt.title('Matriz de Confusión (Iris, profundidad 2)')
plt.show()

report = classification_report(
    y_test,
    y_pred,
    target_names=iris.target_names,
    output_dict=True,
    zero_division=0
)

reporte_df = pd.DataFrame(report).T
reporte_df = reporte_df.rename(
    columns={
        'precision': 'Precisión',
        'recall': 'Recall',
        'f1-score': 'F1-score',
        'support': 'Soporte'
    }
)
filas = list(iris.target_names) + ['macro avg', 'weighted avg']
reporte_df = reporte_df.loc[filas]
reporte_df['Soporte'] = reporte_df['Soporte'].round(0).astype(int)
display(reporte_df[['Precisión', 'Recall', 'F1-score', 'Soporte']].round(3))

print(f'\nExactitud global (prueba): {acc_test:.3f}')

macro_f1 = report['macro avg']['f1-score']
recall_por_clase = {clase: report[clase]['recall'] for clase in iris.target_names}
min_recall = min(recall_por_clase.values())
clases_min_recall = [c for c, r in recall_por_clase.items() if r == min_recall]

print('\nConclusión del ejemplo multiclase:')
print(f'- Exactitud en prueba: {acc_test:.3f} (superó al benchmark {acc_naive:.3f}).')
print(f'- F1 macro: {macro_f1:.3f}.')
if len(clases_min_recall) == len(iris.target_names):
    print('- Todas las clases tienen el mismo recall.')
else:
    clases_txt = ', '.join(clases_min_recall)
    print(
        f"- La(s) clase(s) con menor recall: {clases_txt} ({min_recall:.3f}). "
        'Ahí se concentran las confusiones (típicamente versicolor/virginica).'
    )

Exactitud entrenamiento: 0.971
Exactitud prueba:        0.889
Benchmark (clase más frecuente): 0.333
La brecha train/prueba sugiere algo de sobreajuste o un modelo inestable.

Exactitud global (prueba): 0.889

Conclusión del ejemplo multiclase:
- Exactitud en prueba: 0.889 (superó al benchmark 0.333).
- F1 macro: 0.888.
- La(s) clase(s) con menor recall: virginica (0.733). Ahí se concentran las confusiones (típicamente versicolor/virginica).

4.1 Problema que queremos resolver

Una entidad financiera quiere estimar el riesgo de incumplimiento de sus clientes.

• 0 → el cliente no incumple.
• 1 → el cliente incumple.

Entradas típicas: ingreso, nivel de deuda, etc. El modelo estima la posibilidad de incumplimiento a partir de esas características.

4.2 Entrenamiento del modelo

Se usan dos elementos:

• X: características;
• y: resultado real conocido.

Características del cliente (X)
          │
          ▼
        MODELO
          │  aprende con y
          ▼
Resultado conocido (y)

En Python:

modelo.fit(X_train, y_train)

fit() es el entrenamiento: el algoritmo busca relaciones entre X_train e y_train. Después se aplica a observaciones que no participaron en ese ajuste (validación o prueba, sección 3.2).

4.3 El modelo genera probabilidades

Para varios clasificadores se puede pedir la probabilidad de cada clase. La de la clase positiva (incumplir) suele ser:

prob = modelo.predict_proba(X_test)[:, 1]

Ejemplo:

Interpretación: el cliente 2 tiene una probabilidad estimada del 79 %. Todavía no lo hemos clasificado como 0 o 1.

Cliente → MODELO → 0.79

La pregunta pendiente: ¿0.79 basta para declararlo incumplidor? Eso lo responde el umbral.

4.4 ¿Qué es el umbral?

El umbral convierte la probabilidad en una decisión. Un punto de partida habitual (no obligatorio) es 0.50:

Probabilidad <  0.50 → clase 0 (no incumple)
Probabilidad >= 0.50 → clase 1 (incumple)

umbral = 0.50
y_pred = (prob >= umbral).astype(int)

prob >= umbral produce True/False; .astype(int) los pasa a 1/0.

4.5 De la probabilidad a la decisión

Con umbral 0.50:

Recorrido para el cliente 2:

MODELO → probabilidad 0.79 → ¿0.79 ≥ 0.50? → sí → predicción = 1
       → comparar con el valor real → entra en la MATRIZ DE CONFUSIÓN

4.6 ¿Dónde aparece la matriz de confusión?

Después de convertir probabilidades en decisiones.

from sklearn.metrics import confusion_matrix
matriz = confusion_matrix(y_test, y_pred)

Compara y_test (real) con y_pred (decisión). No calcula probabilidades ni elige el umbral.

La matriz de confusión no decide. Evalúa decisiones que ya se tomaron.

4.7 ¿Qué ocurre si cambiamos el umbral?

Misma probabilidad 0.79:

• umbral 0.50 → 0.79 ≥ 0.50 → predicción 1
• umbral 0.80 → 0.79 ≥ 0.80 → predicción 0

El modelo no cambió. La probabilidad sigue siendo 0.79. Solo cambió la regla de decisión.

4.8 Comparación de umbrales

Una misma probabilidad puede producir distinta clase según el corte.

4.9 Disminuir el umbral

Pasar de 0.50 a 0.30 hace más fácil marcar positivos. Ejemplo: 0.42 pasa de clase 0 a clase 1.

Al bajar el umbral suelen aumentar las predicciones positivas: potencialmente más TP y más FP (más sensibilidad, más falsas alarmas).

4.10 Aumentar el umbral

Pasar de 0.50 a 0.80 exige más evidencia. 0.73 pasa de clase 1 a clase 0.

Al subir el umbral suelen caer las predicciones positivas: potencialmente menos FP y más FN.

4.11 El umbral depende del problema

0.50 es una referencia, no un óptimo universal. Cuenta el costo de cada error (sección 3.2).

• En cribado médico, un FN (enfermo clasificado sano) suele ser muy grave: a menudo se baja el umbral y se aceptan más FP, que luego se confirman con otra prueba.
• Si un FP tiene consecuencias graves para una persona, puede convenir un umbral más alto.

4.12 Idea fundamental

DATOS → MODELO → SCORE / PROBABILIDAD → UMBRAL → DECISIÓN 0/1
      → comparación con la realidad → MATRIZ DE CONFUSIÓN
      → accuracy, precision, recall, F1, ...

• El modelo estima (score o probabilidad).
• El umbral decide (clase 0 o 1).
• La matriz evalúa (TP, TN, FP, FN).

El modelo estima. El umbral decide. La matriz de confusión evalúa.

4.13 De un umbral a una matriz; de muchas matrices a la ROC

Si solo se tiene la matriz de recuentos, no se recuperan las probabilidades. Esa matriz es el resultado después de un umbral. Convención habitual (como en sklearn): filas = clase real, columnas = clase predicha.

Para probar otros cortes hay que conservar los scores o predict_proba().

La cadena, con rigor, es esta:

1. El modelo produce un score o probabilidad para cada observación.
2. Un umbral define si , y en caso contrario.
3. Al cambiar cambian las predicciones .
4. Al cambiar cambian , , y : cada umbral induce, en general, una matriz de confusión distinta.
5. De cada matriz se calculan

6. La curva ROC es el conjunto de pares al recorrer .

Una única matriz de confusión describe el comportamiento del clasificador para un umbral concreto. Para construir la curva ROC se recorren múltiples umbrales. Cada umbral produce nuevas predicciones y, por tanto, nuevos valores de TP, FP, TN y FN. A partir de ellos se calculan TPR y FPR. Cada par (FPR, TPR) corresponde a un punto de la curva ROC.

No basta decir que «la ROC sale de la matriz»: sale de una familia de matrices, una por umbral, construidas todas con el mismo vector de scores.

4.14 Hacia la práctica y hacia la sección 5

Si no tiene por qué ser el mejor corte, la pregunta operativa es: qué le ocurre a la matriz, y a TPR y FPR, cuando cambiamos . El ejemplo 4.15 lo muestra con tres cortes. Recorrer todos los cortes posibles es exactamente el objeto de la curva ROC.

4.15 Práctica: riesgo de incumplimiento, tres umbrales y tres matrices

Caso: un conjunto pequeño de clientes con ingreso, deuda e incumplió ( = incumplimiento). Entrenamos una regresión logística solo para hacer visible el mecanismo. En un ejercicio de evaluación honesta se usaría validación (sección 3.2); aquí el objetivo es ver de dónde salen las y cómo el umbral las convierte en clase.

Las columnas de probabilidad salen de predict_proba: las produce el modelo, no la matriz de confusión. La matriz aparece después, cuando ya hay .

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import seaborn as sns
from sklearn.linear_model import LogisticRegression
from sklearn.metrics import confusion_matrix, precision_score, recall_score

# Datos didácticos (reproducibles): ingreso, deuda e incumplimiento
datos = pd.DataFrame({
    "ingreso": [
        3144, 2173, 3390, 2922, 1173, 3729, 3107, 3180,
        1272, 2206, 1975, 3588, 2767, 3286, 2186, 1559, 2508, 1085,
    ],
    "deuda": [
        1172, 914, 1081, 548, 1361, 1259, 1107, 337,
        696, 138, 284, 982, 1063, 1357, 510, 569, 700, 330,
    ],
    "incumplio": [1, 1, 1, 1, 1, 1, 0, 0, 1, 0, 0, 1, 1, 1, 1, 1, 0, 1],
})

X = datos[["ingreso", "deuda"]]
y = datos["incumplio"]

modelo = LogisticRegression(random_state=42, max_iter=2000)
modelo.fit(X, y)

# Probabilidades de la clase positiva: salen DEL MODELO
prob = modelo.predict_proba(X)[:, 1]

detalle = datos.copy()
detalle["real"] = y.to_numpy()
detalle["probabilidad"] = np.round(prob, 3)
display(detalle[["ingreso", "deuda", "real", "probabilidad"]])

# El modelo y las p_i se fijan; solo cambia la regla tau
y_pred_30 = (prob >= 0.30).astype(int)
y_pred_50 = (prob >= 0.50).astype(int)
y_pred_80 = (prob >= 0.80).astype(int)

comparacion = pd.DataFrame({
    "real": y.to_numpy(),
    "probabilidad": np.round(prob, 3),
    "pred_umbral_0.30": y_pred_30,
    "pred_umbral_0.50": y_pred_50,
    "pred_umbral_0.80": y_pred_80,
})
print("Misma p_i; distintas decisiones según tau:")
display(comparacion)

print(
    "\nEl modelo no cambió. La probabilidad no cambió. "
    "Solo cambió la regla de decisión."
)
print("El modelo estima. El umbral decide. La matriz de confusión evalúa.")


def tpr_fpr(y_true, y_pred):
    tn, fp, fn, tp = confusion_matrix(y_true, y_pred, labels=[0, 1]).ravel()
    tpr = tp / (tp + fn) if (tp + fn) else 0.0
    fpr = fp / (fp + tn) if (fp + tn) else 0.0
    return {
        "TN": int(tn),
        "FP": int(fp),
        "FN": int(fn),
        "TP": int(tp),
        "precision": precision_score(y_true, y_pred, zero_division=0),
        "recall": recall_score(y_true, y_pred, zero_division=0),
        "TPR": tpr,
        "FPR": fpr,
    }


umbrales = {"0.30": y_pred_30, "0.50": y_pred_50, "0.80": y_pred_80}
fig, axes = plt.subplots(1, 3, figsize=(12, 3.6))
filas = []

for ax, (nombre, pred) in zip(axes, umbrales.items()):
    cm = confusion_matrix(y, pred, labels=[0, 1])
    sns.heatmap(
        cm,
        annot=True,
        fmt="d",
        cmap="Blues",
        ax=ax,
        cbar=False,
        xticklabels=["Pred. 0", "Pred. 1"],
        yticklabels=["Real 0", "Real 1"],
    )
    ax.set_title(f"Matriz (umbral = {nombre})")
    m = tpr_fpr(y, pred)
    m["umbral"] = nombre
    filas.append(m)

plt.tight_layout()
plt.show()

resumen = pd.DataFrame(filas)[
    ["umbral", "TN", "FP", "FN", "TP", "precision", "recall", "FPR", "TPR"]
]
print("Cada umbral: una matriz, un par (FPR, TPR) que sería un punto de la ROC.")
display(resumen.round(3))

	ingreso	deuda	real	probabilidad
0	3144	1172	1	0.921
1	2173	914	1	0.934
2	3390	1081	1	0.829
3	2922	548	1	0.373
4	1173	1361	1	0.999
5	3729	1259	1	0.879
6	3107	1107	0	0.898
7	3180	337	0	0.113
8	1272	696	1	0.949
9	2206	138	0	0.174
10	1975	284	0	0.399
11	3588	982	1	0.675
12	2767	1063	1	0.923
13	3286	1357	1	0.962
14	2186	510	1	0.613
15	1559	569	1	0.856
16	2508	700	0	0.723
17	1085	330	1	0.780

Misma p_i; distintas decisiones según tau:

	real	probabilidad	pred_umbral_0.30	pred_umbral_0.50	pred_umbral_0.80
0	1	0.921	1	1	1
1	1	0.934	1	1	1
2	1	0.829	1	1	1
3	1	0.373	1	0	0
4	1	0.999	1	1	1
5	1	0.879	1	1	1
6	0	0.898	1	1	1
7	0	0.113	0	0	0
8	1	0.949	1	1	1
9	0	0.174	0	0	0
10	0	0.399	1	0	0
11	1	0.675	1	1	0
12	1	0.923	1	1	1
13	1	0.962	1	1	1
14	1	0.613	1	1	0
15	1	0.856	1	1	1
16	0	0.723	1	1	0
17	1	0.780	1	1	0

El modelo no cambió. La probabilidad no cambió. Solo cambió la regla de decisión.
El modelo estima. El umbral decide. La matriz de confusión evalúa.

Cada umbral: una matriz, un par (FPR, TPR) que sería un punto de la ROC.

	umbral	TN	FP	FN	TP	precision	recall	FPR	TPR
0	0.30	2	3	0	13	0.812	1.000	0.6	1.000
1	0.50	3	2	1	12	0.857	0.923	0.4	0.923
2	0.80	4	1	4	9	0.900	0.692	0.2	0.692

Lectura de las tres matrices (mismo modelo, mismas ).

• Umbral bajo (0.30). Tiende a haber más predicciones positivas: potencialmente más TP y potencialmente más FP. El recall suele subir; la precision puede deteriorarse si entran falsas alarmas.
• Umbral intermedio (0.50). Es solo un corte de referencia, no un óptimo. La matriz es otra (en general) que la de 0.30 y la de 0.80.
• Umbral alto (0.80). Tiende a haber menos predicciones positivas: potencialmente menos FP y potencialmente más FN. El recall suele bajar; la precision puede mejorar.

Ese patrón es el comportamiento típico, no una identidad que valga para cualquier muestra. Por eso se habla de «tiende a» y «potencialmente».

El modelo estima. El umbral decide. La matriz de confusión evalúa.

Precision y recall (sección 3) en este mismo experimento. Al bajar suele ser más fácil predecir la clase positiva: el recall (TPR) normalmente aumenta y pueden crecer los FP, con lo que la precision puede caer. Al subir somos más exigentes: el recall generalmente disminuye, pueden reducirse los FP y la precision puede mejorar.

Cada fila de la tabla de FPR y TPR es un punto asociado a un . Con tres umbrales tenemos tres puntos. Aún no es la curva completa.

---

Pregunta. Si cada umbral genera una matriz de confusión diferente, ¿qué ocurriría si probáramos sistemáticamente todos los umbrales posibles?

Respuesta. Eso es precisamente lo que permite estudiar la curva ROC.

roc_curve(y, prob) necesita los valores reales y los scores/probabilidades del modelo. No debe recibir únicamente un y_pred obtenido con un solo umbral: ese vector ya colapsó todas las a una frontera.

¿Por qué roc_curve() recibe probabilidades y no y_pred? Porque y_pred corresponde a una frontera de decisión, mientras que la ROC necesita evaluar muchos umbrales sobre el mismo ranking.

Elemento	Función
Modelo	Aprende patrones a partir de e
Score / probabilidad	Grado de pertenencia a la clase positiva (sale del modelo)
Umbral	Convierte el score en una decisión 0/1
Predicción	Clase asignada por esa regla
Matriz de confusión	Compara con la realidad, para un umbral fijo
Precision, recall, F1, accuracy	Aspectos de esa matriz
ROC	Recorre muchos umbrales y grafica los pares (FPR, TPR)
AUC	Resume la capacidad discriminativa global del ranking

Interpretación de la curva y del AUC

El AUC (area under the curve) es el área bajo la ROC. Dos anclas:

• AUC = 0.5: capacidad discriminativa equivalente al azar (el ranking no ordena mejor que una moneda).
• AUC = 1: discriminación perfecta (existe un umbral que separa por completo positivos y negativos en la muestra evaluada).

En el intervalo , cuanto mayor es el AUC, mayor es la capacidad general de colocar observaciones positivas por encima de las negativas en el ranking. Una interpretación probabilística útil:

El AUC es la probabilidad de que el modelo asigne un score mayor a una observación positiva elegida al azar que a una observación negativa elegida al azar.

No hay umbrales universales del tipo «0.90 = excelente» o «0.80–0.90 = bueno» que valgan para todo dominio. Un AUC de 0.78 puede ser valioso en un problema difícil y insuficiente en otro. Si un AUC es “bueno” o “suficiente” lo decide el contexto (prevalencia, costos, alternativa clínica o de negocio).

AUC no elige el umbral operativo

El AUC evalúa la calidad global del ranking. No selecciona . Hay que mantener separados dos conceptos:

• AUC → discriminación / capacidad de ordenar.
• Umbral → política concreta de decisión (sección 3.2: costos de FP y FN).

Un modelo puede tener un buen AUC y, sin embargo, utilizar un umbral operativo inadecuado para el problema de negocio.

La curva muestra el menú de puntos ; el negocio elige el punto. El AUC resume el menú, no elige el plato.

El gráfico es un esquema: cerca de la esquina superior izquierda hay mejor compromiso sensibilidad–falsas alarmas; la diagonal es el azar. En 5.1 se dibujan tres ROC a partir de scores, no de un único y_pred.

5.1 Implementación práctica: tres curvas ROC

Abajo, roc_curve(y_true, y_scores) usa etiquetas y scores. No se le pasa un y_pred de un solo umbral: eso comprimiría el ranking a una matriz y la curva colapsaría a un punto (más los extremos técnicos que añade sklearn).

import numpy as np
import matplotlib.pyplot as plt
from sklearn.metrics import roc_curve, auc
# roc_curve(y_true, y_scores): etiquetas + ranking. No usar y_pred de un único umbral.

# Caso 1: modelo pobre/casi aleatorio (AUC ~ 0.55)
y_true = np.array([0, 0, 1, 1, 0, 1, 0, 1, 0, 1])
y_scores = np.array([0.58, 0.55, 0.56, 0.52, 0.53, 0.51, 0.50, 0.46, 0.45, 0.61])

fpr, tpr, thresholds = roc_curve(y_true, y_scores)
roc_auc = auc(fpr, tpr)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='darkorange', lw=2, label=f'Curva ROC (AUC = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='gray', linestyle='--')
plt.xlabel('Tasa de Falsos Positivos (1 - Especificidad)')
plt.ylabel('Tasa de Verdaderos Positivos (Sensibilidad)')
plt.title('Curva ROC - Modelo Pobre (Contraste)')
plt.legend(loc='lower right')
plt.grid(alpha=0.2)
plt.show()

print(f"AUC (caso 1): {roc_auc:.3f}")

# Caso 2: separación moderada entre clases (AUC ~ 0.7)
y_scores = np.array([0.65, 0.50, 0.70, 0.60, 0.40, 0.55, 0.30, 0.45, 0.20, 0.35])

fpr, tpr, _ = roc_curve(y_true, y_scores)
roc_auc = auc(fpr, tpr)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='blue', lw=2, label=f'Curva ROC (AUC = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='gray', linestyle='--')
plt.xlabel('Tasa de Falsos Positivos (1 - Especificidad)')
plt.ylabel('Tasa de Verdaderos Positivos (Sensibilidad)')
plt.title('Curva ROC - Implementación Básica')
plt.legend(loc='lower right')
plt.grid(alpha=0.2)
plt.show()

print(f"AUC (caso 2): {roc_auc:.3f}")

# Caso 3: modelo excelente (AUC ~ 0.9)
y_scores = np.array([0.15, 0.25, 0.90, 0.85, 0.35, 0.80, 0.78, 0.75, 0.55, 0.62])

fpr, tpr, _ = roc_curve(y_true, y_scores)
roc_auc = auc(fpr, tpr)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='green', lw=2, label=f'Curva ROC (AUC = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='gray', linestyle='--')
plt.xlabel('Tasa de Falsos Positivos (1 - Especificidad)')
plt.ylabel('Tasa de Verdaderos Positivos (Sensibilidad)')
plt.title('Curva ROC - Modelo Excelente (Contraste)')
plt.legend(loc='lower right')
plt.grid(alpha=0.2)
plt.show()

print(f"AUC (caso 3): {roc_auc:.3f}")

AUC (caso 1): 0.560

AUC (caso 2): 0.720

AUC (caso 3): 0.920

5.2 Ejemplo de decisión con umbral

Este ejemplo muestra dos momentos distintos del proceso: primero se prueban varios umbrales para comparar métricas, y luego se elige uno solo para tomar la decisión final. Así se entiende que la curva ROC y el análisis de umbrales sirven para evaluar opciones, pero en producción normalmente se usa un único corte. En 4.15 el mismo score se cortó en 0.30, 0.50 y 0.80 y cambiaron las matrices. Aquí se recorre una grilla de umbrales y se elige un corte (por F1) para producción: la ROC y la tabla sirven para evaluar opciones; el sistema desplegado usa un solo umbral.

import numpy as np
import pandas as pd
from sklearn.metrics import precision_score, recall_score, f1_score, accuracy_score

# Probabilidades del modelo para la clase positiva y etiquetas reales
y_true = np.array([0, 1, 0, 1, 0, 1, 0, 1, 0, 1])
y_prob = np.array([0.10, 0.40, 0.35, 0.80, 0.20, 0.70, 0.60, 0.90, 0.05, 0.85])

# 1) Evaluamos muchos umbrales en el mismo script
umbrales = np.arange(0.10, 0.95, 0.05)
resultados = []

for u in umbrales:
    y_pred = (y_prob >= u).astype(int)
    resultados.append({
        'umbral': round(float(u), 2),
        'accuracy': accuracy_score(y_true, y_pred),
        'precision': precision_score(y_true, y_pred, zero_division=0),
        'recall': recall_score(y_true, y_pred, zero_division=0),
        'f1': f1_score(y_true, y_pred, zero_division=0)
    })

tabla = pd.DataFrame(resultados)
display(tabla.round(3))

# 2) Elegimos umbral según objetivo de negocio: aquí maximizamos F1
mejor_fila = tabla.loc[tabla['f1'].idxmax()]
umbral_optimo = float(mejor_fila['umbral'])

print(f"\nUmbral recomendado (max F1): {umbral_optimo:.2f}")
print(
    f"Métricas en ese umbral -> "
    f"Accuracy: {mejor_fila['accuracy']:.3f}, "
    f"Precision: {mejor_fila['precision']:.3f}, "
    f"Recall: {mejor_fila['recall']:.3f}, "
    f"F1: {mejor_fila['f1']:.3f}"
)

# 3) Regla de decisión final en producción (ya con un solo umbral)
y_pred_final = (y_prob >= umbral_optimo).astype(int)
print(f"\nPredicción final usando un solo umbral ({umbral_optimo:.2f}):")
print(y_pred_final)

Umbral recomendado (max F1): 0.35
Métricas en ese umbral -> Accuracy: 0.900, Precision: 0.833, Recall: 1.000, F1: 0.909

Predicción final usando un solo umbral (0.35):
[0 1 1 1 0 1 1 1 0 1]

5.3 Ejemplo integrador: matriz de confusión y curva ROC

import numpy as np
import pandas as pd
from sklearn.metrics import (
    confusion_matrix,
    classification_report,
    accuracy_score,
    roc_curve,
    roc_auc_score,
)
import matplotlib.pyplot as plt
import seaborn as sns

y_true = np.array([0, 1, 0, 1, 0, 1, 0, 1])
y_prob = np.array([0.10, 0.40, 0.35, 0.80, 0.20, 0.70, 0.60, 0.90])

# La clase predicha sale del umbral, no de un vector aparte
umbral = 0.50
y_pred = (y_prob >= umbral).astype(int)

detalle = pd.DataFrame({
    'Real': y_true,
    'Prob': y_prob,
    'Pred': y_pred,
})
print(f'Umbral de decisión: {umbral:.2f}')
display(detalle)

cm = confusion_matrix(y_true, y_pred)
plt.figure(figsize=(8, 6))
sns.heatmap(cm, annot=True, fmt='d', cmap='Blues')
plt.xlabel('Predicción')
plt.ylabel('Real')
plt.title(f'Matriz de Confusión (umbral = {umbral:.2f})')
plt.show()

accuracy = accuracy_score(y_true, y_pred)
report = classification_report(
    y_true,
    y_pred,
    target_names=['Clase 0', 'Clase 1'],
    output_dict=True,
    zero_division=0
)

print(f'Exactitud: {accuracy:.2f}')

filas = ['Clase 0', 'Clase 1', 'macro avg', 'weighted avg']
reporte_df = pd.DataFrame(
    [{
        'Clase': clase,
        'Precisión': report[clase]['precision'],
        'Recall': report[clase]['recall'],
        'F1-score': report[clase]['f1-score'],
        'Soporte': int(report[clase]['support'])
    } for clase in filas]
)
reporte_df[['Precisión', 'Recall', 'F1-score']] = reporte_df[
    ['Precisión', 'Recall', 'F1-score']
].round(2)
print('Reporte de clasificación:')
display(reporte_df)

fpr, tpr, _ = roc_curve(y_true, y_prob)
roc_auc = roc_auc_score(y_true, y_prob)

plt.figure(figsize=(8, 6))
plt.plot(fpr, tpr, color='blue', lw=2, label=f'Curva ROC (AUC = {roc_auc:.2f})')
plt.plot([0, 1], [0, 1], color='gray', lw=2, linestyle='--')
plt.xlim([0.0, 1.0])
plt.ylim([0.0, 1.05])
plt.xlabel('Tasa de Falsos Positivos')
plt.ylabel('Tasa de Verdaderos Positivos')
plt.title('Curva ROC (independiente del umbral)')
plt.legend(loc='lower right')
plt.show()

Umbral de decisión: 0.50

Exactitud: 0.75
Reporte de clasificación:

5.4 Usos, ventajas y límites de la curva ROC

1. Evaluación de modelos de clasificación binaria
   • Permite comparar diferentes modelos para ver cuál tiene mejor capacidad predictiva.
2. Exploración de umbrales (no los elige el AUC)
   • La curva muestra el menú de pares (FPR, TPR). El umbral operativo se elige con costos y recall/precision (secciones 3.2 y 4), no porque el AUC asigne un corte.
3. Medición de la capacidad de discriminación del modelo
   • Evalúa qué tan bien el modelo distingue entre clases positivas y negativas.
4. Análisis de modelos desbalanceados
   • AUC-ROC puede ser útil para comparar capacidad de separación, pero en desbalance extremo conviene complementarla con Precision-Recall.

Ventajas de la Curva ROC

• No se reduce a un solo umbral
  • Resume el ranking en todos los cortes. Eso no sustituye elegir el umbral con una política de costos.
• Útil para comparar modelos
  • Si dos modelos tienen curvas ROC, podemos determinar cuál discrimina mejor con solo observar el AUC.

Desventajas de la Curva ROC

• Puede ser engañosa con datos extremadamente desbalanceados
  • En casos donde la clase positiva es muy rara, una alta AUC no garantiza un buen rendimiento real.
• No mide la calidad de las predicciones
  • No indica qué tan bien están calibradas las probabilidades predichas, solo mide la capacidad de discriminación.
• No siempre es la mejor métrica
  • En problemas donde es más importante evitar falsos negativos (p.ej., diagnóstico médico), es preferible usar métricas como Recall o F1-score.

6. Conclusión

Como en la sección 4: el modelo estima, el umbral decide y la matriz evalúa un solo corte. La ROC recorre los cortes; el AUC resume la discriminación del ranking y no fija el umbral de negocio. Sigue siendo una herramienta central para comparar clasificadores binarios. En desbalance extremo o cuando un tipo de error es crítico, conviene leerla junto con precision, recall, costos y, si aplica, la curva precision–recall.

Los ejercicios de esta sesión están en el notebook Taller_metricas_prediccion_clasificacion.ipynb (métricas de predicción, matrices de confusión, umbral, AUC-ROC e integración).

Evolución de Machine Learning a Deep Learning

El Machine Learning tradicional (regresión lineal, árboles de decisión, SVM, etc.) se basa en que un humano diseñe características (features) a partir de los datos crudos. Por ejemplo, para imágenes se extraían histogramas, bordes o descriptores como SIFT. Ese proceso se llama feature engineering y limita mucho el rendimiento: si las features no capturan bien el problema, el modelo no puede mejorar.

El Deep Learning cambia el paradigma: en lugar de diseñar features a mano, se usan redes neuronales profundas (muchas capas) que aprenden representaciones jerárquicas de los datos de forma automática. Las primeras capas suelen capturar patrones de bajo nivel (bordes, texturas) y las capas profundas combinan esos patrones en conceptos de alto nivel (objetos, escenas). Así, el propio modelo “decide” qué representaciones son útiles para la tarea.

Diferencias clave

Aplicaciones industriales actuales

• Visión artificial: Detección de objetos, reconocimiento facial, vehículos autónomos, diagnóstico por imagen (radiología, dermatología).
• Procesamiento de lenguaje natural (NLP): Traducción automática, chatbots, análisis de sentimiento, resumen de textos, modelos de lenguaje (GPT, BERT).
• Sistemas de recomendación: Netflix, Spotify, Amazon y redes sociales usan redes profundas para personalizar contenido y anuncios.
• Audio: Reconocimiento de voz (asistentes), generación de voz sintética, separación de fuentes.

¿Por qué Deep Learning funciona mejor con grandes volúmenes de datos?

Las redes profundas tienen millones (o miles de millones) de parámetros. Con pocos datos, esos parámetros se ajustan demasiado a los ejemplos de entrenamiento y el modelo sobreajusta: funciona bien en train pero mal en datos nuevos. Con muchos datos, el modelo puede aprender patrones estadísticamente estables y generalizables sin memorizar casos concretos. Por eso el auge del Deep Learning está ligado a la disponibilidad de grandes datasets y capacidad de cómputo (GPUs).

Conceptos clave

• Vector: Una lista ordenada de números (en ML suele ser un vector columna). Representa las características (features) de una sola muestra. Ejemplo: una persona puede describirse por el vector (altura en m, peso en kg, edad en años). La longitud del vector es la dimensionalidad del problema (aquí, 3).

• Matriz: Un conjunto de vectores dispuestos en filas (o columnas). En ML es habitual que cada fila sea una muestra y cada columna sea una feature. Así, una matriz de tamaño tiene muestras y features. Todas las operaciones de un batch (lote) de datos se expresan con esta matriz.

• Dimensionalidad: El número de features (columnas) indica la “cantidad de información” que usamos para describir cada muestra. En redes profundas se trabaja con dimensionalidades altas (cientos o miles), lo que hace imprescindible el uso eficiente de operaciones matriciales.

Operaciones fundamentales

• Producto punto (dot product) entre dos vectores: . Da un escalar. Si pensamos en como datos y como pesos, el producto punto es la “combinación lineal” que usa una neurona para una sola muestra.

• Multiplicación matricial: Para matrices (tamaño ) y (), el resultado tiene tamaño con . Así podemos aplicar el mismo conjunto de pesos a todas las muestras de un batch en una sola operación.

• Interpretación geométrica: Los vectores de datos viven en un espacio de características (cada eje es una feature). Vectores cercanos en ese espacio suelen corresponder a muestras similares. Las transformaciones lineales (producto por una matriz de pesos) rotan y escalan ese espacio; las funciones de activación introducen no linealidad y permiten modelar fronteras de decisión complejas.

# Ejemplo: Vectores y matrices en NumPy

# Un vector (una muestra con 3 features: ej. altura, peso, edad)
x = np.array([1.75, 70, 25])
print("Vector (una muestra):", x)
print("Dimensionalidad:", x.shape[0])

# Una matriz (dataset de 4 muestras, 3 features)
X = np.array([
    [1.75, 70, 25],   # persona 1
    [1.60, 55, 30],   # persona 2
    [1.85, 90, 22],   # persona 3
    [1.70, 65, 28],   # persona 4
])
print("\nMatriz (dataset):")
print(X)
print("Forma: {} muestras × {} features".format(X.shape[0], X.shape[1]))

# Producto punto entre dos vectores
w = np.array([0.5, 0.1, -0.2])
producto_punto = np.dot(x, w)
print("\nProducto punto x · w =", producto_punto)

# Multiplicación matricial: X @ w (cada fila de X con w)
predicciones = X @ w  # o np.dot(X, w)
print("Predicciones para todas las muestras:", predicciones)

Vector (una muestra): [ 1.75 70.   25.  ]
Dimensionalidad: 3

Matriz (dataset):
[[ 1.75 70.   25.  ]
 [ 1.6  55.   30.  ]
 [ 1.85 90.   22.  ]
 [ 1.7  65.   28.  ]]
Forma: 4 muestras × 3 features

Producto punto x · w = 2.875
Predicciones para todas las muestras: [2.875 0.3   5.525 1.75 ]

Fórmula de una neurona

• (pesos): Vector de coeficientes que indica qué tan importante es cada feature para la salida. Un peso grande en valor absoluto significa que esa entrada influye mucho; un peso cercano a cero la “apaga”.

• (bias): Un escalar que desplaza la salida. Permite que la neurona “active” incluso cuando la suma ponderada es cero, lo que da más flexibilidad para definir fronteras de decisión que no pasen por el origen.

• Suma ponderada: La expresión es exactamente el producto punto entre pesos y entradas: combina todas las features en un único número. Es la misma idea que en regresión lineal; la diferencia con una “red” aparece cuando encadenamos varias de estas operaciones y añadimos no linealidad entre capas.

Interpretación geométrica

En clasificación binaria, la ecuación define un hiperplano en el espacio de features. Los puntos de un lado del hiperplano se clasifican en una clase y los del otro en la otra. Los pesos definen la orientación del hiperplano y el bias su posición. Una sola neurona (sin activación) solo puede separar clases que sean linealmente separables; por eso las redes usan muchas neuronas y funciones de activación para modelar fronteras no lineales.

Representación matricial

Para procesar un batch de muestras a la vez:

• : matriz (m muestras, n features).
• : matriz (o vector de n componentes).
• : escalar que se suma a cada fila por broadcasting.

Cada fila de es la salida de la neurona para la muestra correspondiente. Esta forma es la que se implementa en código (y en GPUs) para ser eficiente.

Redes más importantes y dónde se usan

A partir de neuronas y capas se construyen arquitecturas que dominan el Deep Learning actual:

En la práctica: CNN para imágenes; Transformer para lenguaje y modelos multimodales; RNN/LSTM en series temporales; GAN y autoencoders para generación y representaciones no supervisadas.

# Implementación del modelo neuronal básico (sin activación)

def neurona_lineal(X, w, b):
    """
    Modelo lineal: z = X @ w + b
    X: (n_muestras, n_features)
    w: (n_features,)
    b: escalar
    """
    return X @ w + b

# Ejemplo
np.random.seed(42)
X_ejemplo = np.random.randn(100, 3)  # 100 muestras, 3 features
w = np.array([0.5, -0.3, 0.8])
b = 0.1

z = neurona_lineal(X_ejemplo, w, b)
print("Salida z (pre-activación) para las primeras 5 muestras:")
print(z[:5])
print("\nForma de z:", z.shape)

Salida z (pre-activación) para las primeras 5 muestras:
[ 0.9079872   0.74445138  0.28379648  0.13772153 -0.58496906]

Forma de z: (100,)

¿Por qué necesitamos no linealidad?

Si no hubiera activaciones no lineales, cualquier secuencia de capas lineales (multiplicación por matrices y suma de bias) se podría reescribir como una sola transformación lineal (una única matriz y un bias). Es decir, profundidad no aportaría nada. Con funciones de activación no lineales entre capas, cada capa puede deformar el espacio de representación de forma no lineal, y la composición de muchas de estas transformaciones permite aproximar fronteras de decisión y funciones muy complejas. Por eso las activaciones son imprescindibles en redes profundas.

Funciones comunes

Función	Fórmula	Uso típico
Sigmoid		Salida en (0,1); se interpreta como probabilidad. Muy usada en la última capa de clasificación binaria.
ReLU		Capas ocultas en la mayoría de arquitecturas actuales. Cero para , identidad para .

Otras que suelen aparecer en la literatura: tanh (similar a sigmoid pero centrada en 0), Leaky ReLU, GELU (en Transformers), etc.

Comparación y problemas típicos

• Sigmoid: Es suave y acotada en (0, 1), lo que ayuda a interpretar la salida como probabilidad. El inconveniente es el gradiente que se desvanece: cuando es grande, la curva es muy plana y la derivada es casi cero, así que el gradiente que llega a capas anteriores es muy pequeño y el aprendizaje se estanca. Por eso no suele usarse en capas ocultas profundas.

• ReLU: Es simple de calcular y no satura para (derivada 1), por lo que el gradiente fluye bien en esas neuronas “activas”. Las que dan se “apagan” (salida 0, gradiente 0) y pueden dejar de aprender (“neurona muerta”), pero en la práctica ReLU suele entrenar más rápido y estable que sigmoid en capas ocultas y es el estándar en muchas arquitecturas.

Tabla ampliada: funciones de activación y problemas típicos

En la siguiente tabla se listan más funciones de activación y en qué problemas típicos suelen usarse.

Función	Fórmula	Uso en la red	Problemas típicos donde se usa
Sigmoid		Última capa (salida probabilística)	Clasificación binaria, predicción de probabilidades (ej. click-through rate), gates en LSTM.
ReLU		Capas ocultas (default)	CNN, MLP, casi cualquier red moderna; regresión y clasificación.
Tanh		Capas ocultas (alternativa)	RNN/LSTM (estado oculto centrado en 0), cuando se quiere salida en .
Leaky ReLU	,	Capas ocultas	Cuando ReLU produce muchas “neuronas muertas”; GANs, redes muy profundas.
GELU	(aproximada)	Capas ocultas	Transformers (BERT, GPT), modelos de lenguaje; suavidad y mejor flujo de gradiente.
Softmax		Última capa (multiclase)	Clasificación multiclase (imágenes, NLP); salidas suman 1 y se interpretan como probabilidades.
Linear		Última capa en regresión	Regresión (predecir valor continuo: precios, cantidades, series temporales).

Resumen: En capas ocultas se usa sobre todo ReLU (o GELU en Transformers). En salida: Sigmoid → clasificación binaria; Softmax → clasificación multiclase; Linear → regresión.

# Implementación y visualización de funciones de activación

def sigmoid(z):
    return 1 / (1 + np.exp(-z))

def relu(z):
    return np.maximum(0, z)

def tanh(z):
    return np.tanh(z)

def leaky_relu(z, alpha=0.01):
    return np.where(z > 0, z, alpha * z)

def gelu(z):
    # Aproximación común: 0.5 * z * (1 + tanh(sqrt(2/pi) * (z + 0.044715 * z^3)))
    return 0.5 * z * (1 + np.tanh(np.sqrt(2 / np.pi) * (z + 0.044715 * z**3)))

# Tabla resumen con pandas
df_activaciones = pd.DataFrame({
    'Función': ['Sigmoid', 'ReLU', 'Tanh', 'Leaky ReLU', 'GELU'],
    'Fórmula': [r'1/(1+e^{-z})', r'max(0,z)', r'tanh(z)', r'max(αz, z), α≈0.01', r'z·Φ(z) (aprox.)'],
    'Problemas típicos': [
        'Clasificación binaria, gates LSTM, probabilidades',
        'CNN, MLP, capas ocultas (estándar)',
        'RNN/LSTM, estado centrado en (-1,1)',
        'GANs, evitar neuronas muertas',
        'Transformers (BERT, GPT), NLP'
    ]
})
print("Resumen de funciones de activación y uso típico:\n")
display(df_activaciones)

# Graficar varias funciones
z = np.linspace(-5, 5, 200)
fig, axes = plt.subplots(2, 3, figsize=(14, 8))

axes[0, 0].plot(z, sigmoid(z), 'b-', linewidth=2)
axes[0, 0].set_title('Sigmoid')
axes[0, 0].set_xlabel('z')
axes[0, 0].axhline(0, color='gray', linestyle='--', alpha=0.5)
axes[0, 0].axvline(0, color='gray', linestyle='--', alpha=0.5)
axes[0, 0].grid(True, alpha=0.3)

axes[0, 1].plot(z, relu(z), 'green', linewidth=2)
axes[0, 1].set_title('ReLU')
axes[0, 1].set_xlabel('z')
axes[0, 1].axhline(0, color='gray', linestyle='--', alpha=0.5)
axes[0, 1].axvline(0, color='gray', linestyle='--', alpha=0.5)
axes[0, 1].grid(True, alpha=0.3)

axes[0, 2].plot(z, tanh(z), 'darkorange', linewidth=2)
axes[0, 2].set_title('Tanh')
axes[0, 2].set_xlabel('z')
axes[0, 2].axhline(0, color='gray', linestyle='--', alpha=0.5)
axes[0, 2].axvline(0, color='gray', linestyle='--', alpha=0.5)
axes[0, 2].grid(True, alpha=0.3)

axes[1, 0].plot(z, leaky_relu(z), 'purple', linewidth=2)
axes[1, 0].set_title('Leaky ReLU (α=0.01)')
axes[1, 0].set_xlabel('z')
axes[1, 0].axhline(0, color='gray', linestyle='--', alpha=0.5)
axes[1, 0].axvline(0, color='gray', linestyle='--', alpha=0.5)
axes[1, 0].grid(True, alpha=0.3)

axes[1, 1].plot(z, gelu(z), 'red', linewidth=2)
axes[1, 1].set_title('GELU (aprox.)')
axes[1, 1].set_xlabel('z')
axes[1, 1].axhline(0, color='gray', linestyle='--', alpha=0.5)
axes[1, 1].axvline(0, color='gray', linestyle='--', alpha=0.5)
axes[1, 1].grid(True, alpha=0.3)

axes[1, 2].axis('off')
axes[1, 2].text(0.5, 0.5, 'Softmax y Linear\nse usan en la capa\n de salida\n(multiclase / regresión)', ha='center', va='center', fontsize=11)

plt.tight_layout()
plt.show()

Resumen de funciones de activación y uso típico:

Detalle: Sigmoid

• Fórmula: . Rango ; se interpreta como probabilidad.
• Derivada: , útil en backpropagation.
• Problema: Para grande la derivada → gradiente que se desvanece en capas profundas. Por eso se evita en capas ocultas.

Detalle: ReLU

• Fórmula: . Rango .
• Derivada: 1 si , 0 si → en la zona activa el gradiente no se atenúa.
• Ventaja: Cálculo barato, entrenamiento más estable. Riesgo: neuronas con siempre pueden quedar “muertas” (gradiente 0).

Otras funciones (referencia)

• Tanh: Rango , centrada en 0; también sufre vanishing gradient.
• Leaky ReLU: con pequeño; reduce neuronas muertas.
• GELU: Usada en Transformers; más costosa, mejor en redes muy profundas.

¿Qué significa “aprender”?

En términos prácticos, aprender es ajustar los pesos (y bias) del modelo para que las predicciones se parezcan cada vez más a los valores reales observados en los datos. La función de pérdida asigna un número a cada conjunto de predicciones: cuanto mayor es , peor encaja el modelo; el objetivo del entrenamiento es encontrar los pesos que hacen lo más pequeño posible. Así, la pérdida es el “termómetro” que guía el descenso de gradiente.

Funciones de pérdida comunes

Tarea	Función	Fórmula (idea)
Regresión	MSE (Mean Squared Error)
Clasificación binaria	Cross-Entropy binaria

En clasificación, es la probabilidad predicha para la clase positiva (por ejemplo, la salida de una sigmoid).

Interpretación

• MSE: Es el promedio de los errores al cuadrado. El cuadrado hace que los errores grandes pesen mucho más que los pequeños, por lo que el modelo se ve “forzado” a corregir sobre todo las predicciones muy desviadas. Tiene una interpretación probabilística cuando asumimos ruido gaussiano en la salida.

• Cross-Entropy: Viene de la teoría de información: mide la “sorpresa” o discrepancia entre la distribución real de la etiqueta (one-hot o binaria) y la distribución predicha (probabilidades). Minimizar cross-entropy equivale a hacer que la distribución predicha se acerque a la real. Es la elección estándar en clasificación porque se combina bien con la sigmoid en la última capa y tiene buenas propiedades de gradiente. Una interpretación probabilística: si interpretamos como , la cross-entropy es el negativo del logaritmo de la verosimilitud bajo un modelo Bernoulli.

Otras funciones de pérdida (referencia)

Función	Fórmula (idea)	Cuándo usarla
MAE (L1)		Regresión cuando hay outliers: los errores grandes no se amplifican al cuadrado.
Huber	Cuadrática para , lineal fuera	Regresión robusta: combina ventajas de MSE y MAE.
Cross-Entropy multiclase		Clasificación con varias clases; sale de Softmax en la última capa.

Gradientes de la pérdida (para backprop)

• MSE: La derivada respecto a es (o si se promedia). El gradiente “empuja” la predicción hacia el valor real.
• Cross-Entropy binaria + Sigmoid: Al combinar la pérdida con la derivada de la sigmoid, el gradiente respecto a la pre-activación resulta en la forma : muy simple y numéricamente estable, por eso es el estándar en clasificación binaria.

# Implementación de funciones de pérdida

def mse(y_true, y_pred):
    """Mean Squared Error - Regresión"""
    return np.mean((y_true - y_pred) ** 2)

def cross_entropy_binary(y_true, y_pred_prob):
    """
    Cross-Entropy para clasificación binaria.
    y_true: etiquetas 0 o 1
    y_pred_prob: probabilidades en [0, 1] (salida de sigmoid)
    """
    eps = 1e-15  # Evitar log(0)
    y_pred_prob = np.clip(y_pred_prob, eps, 1 - eps)
    return -np.mean(y_true * np.log(y_pred_prob) + (1 - y_true) * np.log(1 - y_pred_prob))

# Ejemplo MSE
y_real = np.array([1.0, 2.0, 3.0])
y_pred = np.array([1.1, 1.8, 3.2])
print("MSE:", mse(y_real, y_pred))

# Ejemplo Cross-Entropy
y_true_bin = np.array([1, 0, 1, 0])
y_prob = np.array([0.9, 0.2, 0.7, 0.1])  # Buenas predicciones
print("Cross-Entropy (buenas pred):", cross_entropy_binary(y_true_bin, y_prob))
y_prob_mala = np.array([0.3, 0.8, 0.4, 0.6])  # Malas predicciones
print("Cross-Entropy (malas pred):", cross_entropy_binary(y_true_bin, y_prob_mala))

MSE: 0.030000000000000023
Cross-Entropy (buenas pred): 0.1976348816421487
Cross-Entropy (malas pred): 1.1614980451270867

Conceptos clave

• Derivada: En una variable, la derivada de una función en un punto es la pendiente de la recta tangente en ese punto. Indica si la función crece o decrece al moverse un poco y con qué “velocidad”. Para minimizar la pérdida, interesa saber en qué dirección decrece .

• Gradiente: En varias variables, el gradiente es el vector cuyas componentes son las derivadas parciales de respecto a cada peso. El gradiente apunta en la dirección en que aumenta más rápido. Por tanto, para minimizar se avanza en la dirección opuesta al gradiente: .

• Descenso de gradiente: Se actualiza cada peso restando una fracción del gradiente (es decir, dando un “paso” en la dirección que reduce la pérdida). Repitiendo este proceso muchas veces (épocas), se tiende a un mínimo (local o global) de la pérdida.

Actualización de pesos

• (learning rate, tasa de aprendizaje): Es el tamaño del paso. Si es muy alto, los pasos son grandes y puede producirse overshoot del mínimo, incluso divergencia; si es muy bajo, se avanza muy despacio y el entrenamiento es lento y puede quedarse atascado en zonas planas. En la práctica se suele elegir por validación o con schedulers que lo reducen con el tiempo.

Flujo del entrenamiento (una época)

1. Forward pass: Con los pesos actuales, se calculan las salidas de cada capa (productos por matrices, bias, activaciones) hasta obtener las predicciones y, con ellas, el valor de la pérdida .
2. Backward pass (backpropagation): Se calculan las derivadas de respecto a cada peso y cada activación intermedia, aplicando la regla de la cadena. El resultado es el gradiente para cada peso.
3. Actualización: Cada peso se actualiza con la regla anterior: (y lo mismo para el bias).
4. Se repite para muchos batches y muchas épocas hasta que la pérdida se estabilice o se cumpla un criterio de parada.

Regla de la cadena y backpropagation

En una red con muchas capas, depende de los pesos de la última capa a través de las salidas, y esas salidas dependen de la capa anterior, y así sucesivamente. La regla de la cadena del cálculo permite escribir como producto de derivadas a lo largo del camino desde hasta . El algoritmo backpropagation calcula esas derivadas de atrás hacia adelante: primero las de la capa de salida, luego las de la penúltima, etc., reutilizando resultados ya calculados. Así se obtienen de forma eficiente los gradientes de todos los pesos con una sola pasada hacia atrás.

Batch, estocástico y mini-batch

• Batch (lote completo): Se usa todo el conjunto de entrenamiento para calcular el gradiente en cada paso. Estable pero costoso en memoria y cómputo; el gradiente es muy preciso pero hay pocos pasos por época.
• Estocástico (SGD por muestra): Se actualizan los pesos con el gradiente de una sola muestra cada vez. Mucha variabilidad, muchos pasos por época; puede escapar de mínimos locales pero es ruidoso.
• Mini-batch: Se toman grupos de muestras (por ejemplo 32 o 64), se calcula el gradiente sobre ese mini-batch y se actualiza. Equilibrio entre estabilidad y velocidad; es lo más usado en la práctica.

Learning rate y schedulers

El learning rate controla el tamaño del paso. Si es muy alto, la pérdida puede oscilar o divergir; si es muy bajo, el entrenamiento es lento. Los schedulers cambian a lo largo del entrenamiento (por ejemplo reducirlo cada cierto número de épocas o cuando la pérdida se estanca), lo que suele mejorar la convergencia y la calidad final.

Mínimos locales y gradientes

• Mínimos locales: La pérdida puede tener varios “valles”; el descenso de gradiente puede quedarse en un mínimo local en lugar del global. En redes grandes, hay tantos parámetros que los mínimos “malos” son menos frecuentes de lo que se pensaba; además, el ruido del mini-batch ayuda a escapar de algunos.
• Gradientes que se desvanecen: En redes muy profundas, si las derivadas son menores que 1 en cada capa, el gradiente puede volverse casi cero al propagarse hacia atrás; las capas iniciales aprenden muy lento. Soluciones: activaciones como ReLU, inicialización adecuada, y a veces capas residuales (ResNet).
• Gradientes que explotan: Si las derivadas son mayores que 1, el gradiente puede crecer descontroladamente. Soluciones: reducir , gradient clipping (limitar la norma del gradiente) y buenas prácticas de inicialización.

# Visualización: Descenso de gradiente en 2D

# Función de pérdida simple: L(w) = w^2 (mínimo en w=0)
def loss(w):
    return w**2

def grad_loss(w):
    return 2*w

# Simular descenso de gradiente
np.random.seed(42)
w = 2.5  # Punto inicial
lr = 0.3  # Learning rate
history = [w]

for _ in range(15):
    w = w - lr * grad_loss(w)
    history.append(w)

# Graficar
w_vals = np.linspace(-3, 3, 200)
plt.figure(figsize=(10, 5))
plt.plot(w_vals, loss(w_vals), 'b-', label='L(w) = w²')
plt.plot(history, [loss(wi) for wi in history], 'ro-', markersize=8, label='Descenso de gradiente')
plt.xlabel('w')
plt.ylabel('Pérdida L(w)')
plt.title('Intuición del descenso de gradiente: minimizar L(w)')
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

División Train/Test

• Conjunto de entrenamiento (train): Son los datos que el algoritmo usa para ajustar los pesos (mediante descenso de gradiente). El modelo “ve” muchas veces estos ejemplos durante las épocas.

• Conjunto de test: Son datos que el modelo no usa nunca durante el entrenamiento. Solo se usan al final para medir el rendimiento. Así se simula el comportamiento en datos “nuevos” y se evita evaluar solo sobre lo que el modelo ya ha memorizado o ajustado.

Una división típica es 80% train y 20% test (o 70/30). Es importante que la división sea aleatoria (o estratificada por clase) para que train y test sean representativos de la misma distribución.

Concepto de generalización

Generalizar significa que el modelo se comporta bien en datos que no ha visto durante el entrenamiento. Lo relevante en producción es precisamente ese rendimiento en datos nuevos.

• Si la pérdida (o error) en train es mucho menor que en test, el modelo está sobreajustando (overfitting): ha “memorizado” o se ha adaptado demasiado al train y no captura patrones que se mantengan en test.
• Si train y test tienen rendimiento similar y razonable, el modelo está generalizando bien.
• Si tanto train como test van mal, puede haber subajuste (underfitting) (modelo muy simple o poco entrenamiento).

Por eso es fundamental visualizar la pérdida (y si aplica, el accuracy) en train (y en validación si la hay) a lo largo de las épocas.

Métricas a visualizar

• Curva de pérdida: En el eje X las épocas (o steps) y en el eje Y el valor de la pérdida en train (y opcionalmente en validación). Lo esperado es que baje y luego se estabilice. Si la pérdida de validación sube mientras la de train sigue bajando, es señal de overfitting.

• Accuracy (en clasificación): Proporción de ejemplos bien clasificados. Se puede graficar accuracy en train (y en validación) frente a las épocas. En el notebook aplicado se muestra también una comparación de accuracy en train vs test al final del entrenamiento.

Train / Validación / Test

Además de train y test, es habitual usar un conjunto de validación (valid): datos que no se usan para entrenar ni para el reporte final, sino para elegir hiperparámetros (learning rate, número de épocas, tamaño del modelo, etc.) y para early stopping (parar cuando la pérdida en validación deja de mejorar). Así se evita “afinar” el modelo mirando el test; el test se reserva solo para una evaluación final y honesta. Una división típica es 70% train, 15% validación, 15% test (o 80/10/10).

Métricas de clasificación (más allá del accuracy)

Cuando las clases están desbalanceadas o el coste de equivocarse no es simétrico, el accuracy puede ser engañoso. Conviene considerar:

• Precision (por clase positiva): de todos los que el modelo predijo como positivos, cuántos lo son realmente. .
• Recall (sensibilidad): de todos los positivos reales, cuántos detectó el modelo. .
• F1: media armónica de precision y recall; resume ambos en un solo número. .

(TP = verdaderos positivos, FP = falsos positivos, FN = falsos negativos.)

Matriz de confusión

La matriz de confusión es una tabla de 2×2 (en clasificación binaria) donde: - Filas = clase real (lo que dice la etiqueta). - Columnas = clase predicha (lo que dijo el modelo).

Cada celda cuenta cuántos ejemplos caen en esa combinación: - TN (arriba-izquierda): predijo negativo y era negativo → acierto. - FP (arriba-derecha): predijo positivo y era negativo → falso alarm. - FN (abajo-izquierda): predijo negativo y era positivo → se le escapó un positivo. - TP (abajo-derecha): predijo positivo y era positivo → acierto.

Así se puede ver de un vistazo si el modelo se equivoca más en una dirección (por ejemplo muchos FN si la clase positiva es la “importante”) y es la base para calcular precision, recall y F1. En Python se usa confusion_matrix de sklearn y suele dibujarse como heatmap.

ROC y AUC

Cuando el modelo devuelve probabilidades (p. ej. salida de sigmoid), no hay un único “umbral”: si se elige umbral 0.5 se clasifica como positivo cuando , pero también se podría usar 0.3 o 0.7. La curva ROC muestra, para cada posible umbral, el trade-off entre: - Eje X: Tasa de falsos positivos (FP / (FP + TN)) — cuántos negativos se marcan como positivos. - Eje Y: Tasa de verdaderos positivos = Recall (TP / (TP + FN)) — cuántos positivos se detectan.

Un buen modelo tiene la curva “pegada” al borde superior-izquierdo (muchos TP, pocos FP). El AUC (área bajo esa curva) es un número entre 0 y 1: 1 = clasificador perfecto, 0.5 = como tirar una moneda, menor que 0.5 = peor que aleatorio. Sirve para comparar modelos sin fijar un umbral. En Python: roc_curve y roc_auc_score de sklearn.

A continuación se ilustran con Python las métricas anteriores: matriz de confusión, curva ROC/AUC, Precision/Recall/F1 y un ejemplo de curvas de pérdida en entrenamiento.

# Ejemplos: Matriz de confusión, ROC/AUC, Precision/Recall/F1 y curvas de pérdida
from sklearn.metrics import (
    confusion_matrix, ConfusionMatrixDisplay, roc_curve, roc_auc_score,
    precision_score, recall_score, f1_score, classification_report
)
from sklearn.linear_model import LogisticRegression

# Datos sintéticos y modelo rápido para tener predicciones y probabilidades
X, y = make_classification(n_samples=400, n_features=10, n_informative=6, n_classes=2, random_state=42)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.3, random_state=42)

modelo = LogisticRegression(max_iter=500, random_state=42)
modelo.fit(X_train, y_train)
y_pred = modelo.predict(X_test)
y_proba = modelo.predict_proba(X_test)[:, 1]   # probabilidad de la clase 1

# --- 1) Matriz de confusión ---
cm = confusion_matrix(y_test, y_pred)
fig, ax = plt.subplots(1, 1, figsize=(5, 4))
ConfusionMatrixDisplay(cm, display_labels=["Negativo", "Positivo"]).plot(ax=ax, values_format="d")
plt.title("Matriz de confusión (real = filas, predicho = columnas)")
plt.tight_layout()
plt.show()
print("Interpretación: TN (0→0), FP (0→1), FN (1→0), TP (1→1).")

# --- 2) Curva ROC y AUC ---
fpr, tpr, _ = roc_curve(y_test, y_proba)
auc = roc_auc_score(y_test, y_proba)

fig, ax = plt.subplots(1, 1, figsize=(5, 4))
ax.plot(fpr, tpr, "b-", linewidth=2, label=f"ROC (AUC = {auc:.3f})")
ax.plot([0, 1], [0, 1], "k--", label="Aleatorio (AUC = 0.5)")
ax.set_xlabel("Tasa de falsos positivos")
ax.set_ylabel("Tasa de verdaderos positivos (Recall)")
ax.set_title("Curva ROC")
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# --- 3) Precision, Recall, F1 ---
precision = precision_score(y_test, y_pred, average="binary")
recall = recall_score(y_test, y_pred, average="binary")
f1 = f1_score(y_test, y_pred, average="binary")
print("Reporte por clase (classification_report):")
print(classification_report(y_test, y_pred, target_names=["Negativo", "Positivo"]))

fig, ax = plt.subplots(1, 1, figsize=(5, 4))
metricas = ["Precision", "Recall", "F1"]
valores = [precision, recall, f1]
colores = ["#2ecc71", "#3498db", "#9b59b6"]
ax.bar(metricas, valores, color=colores, edgecolor="black", linewidth=0.8)
ax.set_ylim(0, 1.05)
ax.set_ylabel("Valor")
ax.set_title("Métricas de clasificación (clase positiva)")
for i, v in enumerate(valores):
    ax.text(i, v + 0.02, f"{v:.2f}", ha="center", fontsize=11)
plt.tight_layout()
plt.show()

# --- 4) Ejemplo de curvas de pérdida (train vs validación) ---
# Simulación: pérdida en train baja; en validación baja y luego sube un poco (overfitting)
np.random.seed(42)
epocas = np.arange(1, 31)
loss_train = 0.8 * np.exp(-epocas / 8) + 0.05 + np.random.rand(30) * 0.03
loss_valid = 0.7 * np.exp(-epocas / 7) + 0.08 + np.random.rand(30) * 0.04
loss_valid[20:] += np.linspace(0, 0.06, 10)  # sube al final (overfitting)

fig, ax = plt.subplots(1, 1, figsize=(6, 4))
ax.plot(epocas, loss_train, "b-", linewidth=2, label="Pérdida train")
ax.plot(epocas, loss_valid, "r-", linewidth=2, label="Pérdida validación")
ax.set_xlabel("Época")
ax.set_ylabel("Pérdida")
ax.set_title("Ejemplo: curvas de pérdida (validación sube → señal de overfitting)")
ax.legend()
ax.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Interpretación: TN (0→0), FP (0→1), FN (1→0), TP (1→1).

Reporte por clase (classification_report):
              precision    recall  f1-score   support

    Negativo       0.86      0.78      0.82        64
    Positivo       0.77      0.86      0.81        56

    accuracy                           0.82       120
   macro avg       0.82      0.82      0.82       120
weighted avg       0.82      0.82      0.82       120