Data Analysis · Lección 15 de 19

Regresión y Clasificación

En la lección anterior vimos el panorama general de Machine Learning. Ahora vamos a profundizar en los 4 algoritmos más usados en la industria: regresión lineal, regresión logística, árboles de decisión y K-Nearest Neighbors. Para cada uno vas a entender cómo funciona, cuándo usarlo, y cómo interpretar sus resultados.

120–150 min Prerrequisitos: Lección 14 (Intro ML)

Concepto teórico

Los 4 algoritmos esenciales

Algoritmo	Tipo	Target	Idea central	Ejemplo de uso
Regresión Lineal	Regresión	Número continuo	Encontrar la recta que mejor ajusta los datos	Predecir precio de inmueble
Regresión Logística	Clasificación	Categoría binaria (0/1)	Calcular probabilidad de pertenecer a una clase	Predecir si un cliente cancela
Árbol de Decisión	Ambos	Número o categoría	Crear reglas tipo "si X > 5 → clase A"	Aprobar créditos
K-Nearest Neighbors	Ambos	Número o categoría	Clasificar según los K vecinos más cercanos	Recomendar productos

Regresión Lineal: la recta que predice

La regresión lineal busca la línea recta y = mx + b que minimiza la distancia entre la línea y los puntos reales. Es el modelo más simple pero tremendamente útil.

m (coeficiente/pendiente): cuánto cambia y por cada unidad de x. Ej: "por cada año de antigüedad, el ingreso sube $35K".
b (intercepto): el valor base cuando x = 0.
R² (coeficiente de determinación): va de 0 a 1. Indica qué porcentaje de la variabilidad de y es explicado por x. R² = 0.85 → el modelo explica el 85% de la variación.

Analogía: imaginate un gráfico con puntos (antigüedad vs ingreso). La regresión lineal es como poner una regla transparente sobre los puntos y rotarla hasta que quede lo más cerca posible de todos. La pendiente de esa regla te dice "por cada año más de antigüedad, ganás ~$35K más".

Métricas de regresión

Métrica	Fórmula intuitiva	Interpretación
MAE	Promedio de \|error\|	"Me equivoco en promedio $X"
MSE	Promedio de error²	Penaliza más los errores grandes
RMSE	√MSE	Error en las mismas unidades que y
R²	1 − (error modelo / error base)	% de variabilidad explicada (0 a 1)

Regresión Logística: probabilidad de evento

A pesar de su nombre, la regresión logística es un modelo de clasificación. Calcula la probabilidad de que un evento ocurra (ej: P(cancela) = 0.78) y clasifica según un umbral (si P > 0.5 → "cancela").

¿Por qué se llama "regresión" si es clasificación? Porque internamente calcula un número continuo (la probabilidad) usando una función sigmoide. Luego la convierte en categoría con un umbral. Es una regresión sobre la probabilidad.

Árboles de Decisión: reglas interpretables

Los árboles crean reglas binarias anidadas: "si antigüedad < 3 → sí cancela, sino, si productos ≥ 4 → no cancela…". Su gran ventaja: son completamente interpretables. Podés explicar cada decisión del modelo.

Cuidado con la profundidad: un árbol muy profundo (max_depth alto) memoriza los datos de entrenamiento (overfitting). La regla: empezá con max_depth=3 y subí gradualmente mientras el test accuracy mejore.

KNN: "dime con quién andás…"

K-Nearest Neighbors no "aprende" nada. Cuando llega un dato nuevo, busca los K más similares en el entrenamiento y vota: si 3 de 5 vecinos cancelaron → "cancela". Es simple pero sorprendentemente efectivo.

En el trabajo real: regresión lineal se usa para forecasting (predecir ventas del próximo trimestre). Regresión logística para scoring crediticio y churn prediction. Árboles de decisión cuando el negocio necesita entender el "por qué" de cada decisión. KNN para sistemas de recomendación simples.

Ejemplos explicados paso a paso

Ejemplo 1: Regresión Lineal — Predecir ingresos

Predecir el ingreso de un empleado a partir de sus años de antigüedad. Modelo simple, interpretable y poderoso.

ejemplo_01_regresion_lineal.pyPython

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, r2_score

np.random.seed(42)
antiguedad = np.random.uniform(1, 20, 100)
ingreso = antiguedad * 35000 + 150000 + np.random.normal(0, 50000, 100)

X = antiguedad.reshape(-1, 1)
y = ingreso

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

# Entrenar
modelo = LinearRegression()
modelo.fit(X_train, y_train)

# Interpretar coeficientes
print("=== Regresión Lineal ===")
print(f"Fórmula: Ingreso = {modelo.coef_[0]:,.0f} × Antigüedad + {modelo.intercept_:,.0f}")
print(f"→ Cada año de antigüedad suma ~${modelo.coef_[0]:,.0f}")

# Evaluar
pred = modelo.predict(X_test)
print(f"\nMAE: ${mean_absolute_error(y_test, pred):,.0f}")
print(f"R²:  {r2_score(y_test, pred):.3f} ({r2_score(y_test, pred)*100:.1f}% explicado)")

# Visualizar
plt.figure(figsize=(8, 5))
plt.scatter(X_test, y_test, alpha=0.6, label="Datos reales", color="#2196F3")
x_line = np.linspace(0, 22, 100).reshape(-1, 1)
plt.plot(x_line, modelo.predict(x_line), color="#E91E63", linewidth=2, label="Predicción")
plt.xlabel("Antigüedad (años)")
plt.ylabel("Ingreso ($)")
plt.title("Regresión Lineal: Antigüedad → Ingreso", fontweight="bold")
plt.legend()
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

Hacé clic en ▶ Ejecutar

Ejemplo 2: Regresión Logística — Predecir churn

Predecir si un cliente va a cancelar (sí/no). La logística nos da la probabilidad, lo que permite priorizar acciones de retención.

ejemplo_02_logistica.pyPython

import numpy as np
import pandas as pd
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, precision_score, recall_score, confusion_matrix

np.random.seed(42)
n = 300
ant = np.random.randint(0, 20, n).astype(float)
prod = np.clip(np.random.normal(3, 1.5, n), 1, 8)
prob = 1/(1+np.exp(-(-1 - 0.15*ant - 0.4*prod + np.random.normal(0,0.5,n))))
canc = (prob > 0.5).astype(int)

X = np.column_stack([ant, prod])
y = canc
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

modelo = LogisticRegression(random_state=42, max_iter=200)
modelo.fit(X_train, y_train)

# Predicciones con probabilidad
pred = modelo.predict(X_test)
proba = modelo.predict_proba(X_test)[:, 1]  # Probabilidad de cancelar

print("=== Regresión Logística — Churn ===")
print(f"Accuracy:  {accuracy_score(y_test, pred)*100:.1f}%")
print(f"Precision: {precision_score(y_test, pred)*100:.1f}%")
print(f"Recall:    {recall_score(y_test, pred)*100:.1f}%")

# Top 5 clientes con más riesgo
print(f"\n=== Top 5 con más riesgo de cancelar ===")
top5 = np.argsort(proba)[-5:][::-1]
for idx in top5:
    print(f"  Antigüedad={X_test[idx,0]:.0f}, Productos={X_test[idx,1]:.1f} → P(cancel)={proba[idx]:.1%}")

# Coeficientes
features = ["Antigüedad", "Productos"]
print(f"\n=== Coeficientes ===")
for feat, coef in zip(features, modelo.coef_[0]):
    efecto = "reduce" if coef < 0 else "aumenta"
    print(f"  {feat}: {coef:.3f} → {efecto} la probabilidad de cancelar")

Hacé clic en ▶ Ejecutar

Tip profesional — predict_proba: modelo.predict_proba() te da la probabilidad de cada clase, no solo la clasificación binaria. Esto es valiosísimo porque podés priorizar: un cliente con P(cancel)=0.92 necesita atención urgente; uno con P=0.55 puede esperar.

Ejemplo 3: Árbol de Decisión con interpretación

Los árboles generan reglas legibles. Podés exportar las reglas y explicar cada decisión al negocio.

ejemplo_03_arbol.pyPython

import numpy as np
import pandas as pd
from sklearn.tree import DecisionTreeClassifier, export_text
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

np.random.seed(42)
n = 300
df = pd.DataFrame({
    "Antiguedad": np.random.randint(0, 20, n),
    "Productos": np.random.randint(1, 8, n),
    "Saldo": np.abs(np.random.normal(300, 150, n)).astype(int)
})
df["Canceló"] = ((df["Antiguedad"] < 5) & (df["Productos"] < 3)).astype(int)
# Agregar ruido
ruido = np.random.choice(n, 30, replace=False)
df.loc[ruido, "Canceló"] = 1 - df.loc[ruido, "Canceló"]

X = df[["Antiguedad", "Productos", "Saldo"]]
y = df["Canceló"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

modelo = DecisionTreeClassifier(max_depth=3, random_state=42)
modelo.fit(X_train, y_train)

print("=== Reglas del Árbol ===")
reglas = export_text(modelo, feature_names=list(X.columns))
print(reglas)

pred = modelo.predict(X_test)
print(f"\nAccuracy: {accuracy_score(y_test, pred)*100:.1f}%")

# Feature importance
print(f"\n=== Importancia de Features ===")
for feat, imp in sorted(zip(X.columns, modelo.feature_importances_), key=lambda x: -x[1]):
    barra = "█" * int(imp * 30)
    print(f"  {feat:15s} {imp:.3f} {barra}")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Regresión Lineal Múltiple

La regresión no se limita a una variable. Con múltiples features podés hacer predicciones mucho más precisas.

ejemplo_04_multiple.pyPython

import numpy as np
import pandas as pd
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, r2_score

np.random.seed(42)
n = 200
df = pd.DataFrame({
    "Metros2": np.random.randint(30, 200, n),
    "Habitaciones": np.random.randint(1, 6, n),
    "Antiguedad": np.random.randint(0, 50, n),
    "Distancia_Centro": np.random.uniform(0.5, 30, n).round(1)
})

# Precio real = función de las features + ruido
df["Precio"] = (
    df["Metros2"] * 2500 +
    df["Habitaciones"] * 15000 -
    df["Antiguedad"] * 800 -
    df["Distancia_Centro"] * 3000 +
    50000 +
    np.random.normal(0, 30000, n)
).astype(int)

X = df[["Metros2", "Habitaciones", "Antiguedad", "Distancia_Centro"]]
y = df["Precio"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

modelo = LinearRegression()
modelo.fit(X_train, y_train)
pred = modelo.predict(X_test)

print("=== Regresión Lineal Múltiple — Precio Inmueble ===")
print(f"R²:  {r2_score(y_test, pred):.3f}")
print(f"MAE: ${mean_absolute_error(y_test, pred):,.0f}")

print(f"\n=== Coeficientes (impacto de cada feature) ===")
for feat, coef in zip(X.columns, modelo.coef_):
    signo = "+" if coef > 0 else ""
    print(f"  {feat:20s}: {signo}${coef:,.0f}")
print(f"  {'Intercepto':20s}: ${modelo.intercept_:,.0f}")

# Predicción para un depto específico
nuevo = pd.DataFrame({"Metros2":[80], "Habitaciones":[3], "Antiguedad":[10], "Distancia_Centro":[5]})
print(f"\nPredicción para 80m², 3 hab, 10 años, 5km: ${modelo.predict(nuevo)[0]:,.0f}")

Hacé clic en ▶ Ejecutar

Ejemplo 5: Comparación completa de modelos con visualización

Probamos 4 algoritmos, comparamos métricas y visualizamos los resultados.

ejemplo_05_comparar.pyPython

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score

np.random.seed(42)
n = 400
X = np.column_stack([
    np.random.uniform(0, 20, n),   # Antigüedad
    np.random.uniform(1, 8, n),    # Productos
    np.random.normal(300, 150, n)  # Saldo
])
prob = 1/(1+np.exp(-(-1.5 - 0.1*X[:,0] - 0.3*X[:,1] + 0.001*X[:,2] + np.random.normal(0,0.5,n))))
y = (prob > 0.5).astype(int)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)

modelos = {
    "Árbol (d=3)": DecisionTreeClassifier(max_depth=3, random_state=42),
    "Árbol (d=6)": DecisionTreeClassifier(max_depth=6, random_state=42),
    "Log. Regresión": LogisticRegression(random_state=42, max_iter=300),
    "KNN (k=5)": KNeighborsClassifier(n_neighbors=5),
}

resultados = []
print(f"{'Modelo':<18} {'Accuracy':>9} {'Precision':>10} {'Recall':>8}")
print("-" * 48)

for nombre, mod in modelos.items():
    mod.fit(X_tr, y_tr)
    p = mod.predict(X_te)
    acc = accuracy_score(y_te, p)
    prec = precision_score(y_te, p, zero_division=0)
    rec = recall_score(y_te, p, zero_division=0)
    resultados.append((nombre, acc, prec, rec))
    print(f"{nombre:<18} {acc*100:>8.1f}% {prec*100:>9.1f}% {rec*100:>7.1f}%")

# Gráfico comparativo
fig, ax = plt.subplots(figsize=(10, 5))
nombres = [r[0] for r in resultados]
x = np.arange(len(nombres))
w = 0.25
ax.bar(x - w, [r[1]*100 for r in resultados], w, label="Accuracy", color="#2196F3")
ax.bar(x, [r[2]*100 for r in resultados], w, label="Precision", color="#4CAF50")
ax.bar(x + w, [r[3]*100 for r in resultados], w, label="Recall", color="#FF9800")
ax.set_xticks(x)
ax.set_xticklabels(nombres, fontsize=9)
ax.set_ylabel("%")
ax.set_title("Comparación de Modelos", fontweight="bold")
ax.legend()
ax.grid(axis="y", alpha=0.3)
plt.tight_layout()
plt.show()

Hacé clic en ▶ Ejecutar

Referencia rápida

Algoritmo	Import	Parámetros clave
Regresión Lineal	`LinearRegression()`	(sin hiperparámetros - ajusta automáticamente)
Reg. Logística	`LogisticRegression()`	`max_iter, C (regularización)`
Árbol Decisión	`DecisionTreeClassifier()`	`max_depth, min_samples_split`
KNN	`KNeighborsClassifier()`	`n_neighbors (K)`

Métrica regresión	Código	Ideal
MAE	`mean_absolute_error(y, pred)`	0 (menor = mejor)
R²	`r2_score(y, pred)`	1 (mayor = mejor)

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Regresión Lineal simple

Entrenáuna regresión lineal de Metros2 → Precio. Imprimí el coeficiente. Debe incluir un número (ej: 2).

ejercicio_01.pyDebe incluir un coeficiente

import numpy as np
from sklearn.linear_model import LinearRegression

np.random.seed(42)
metros = np.array([30, 50, 70, 90, 120, 150]).reshape(-1, 1)
precio = np.array([75000, 125000, 175000, 225000, 300000, 375000])

# Entrenar e imprimir coeficiente

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Predecir con regresión lineal

Usá el modelo entrenado para predecir el precio de un depto de 100 m². Debe incluir 250.

ejercicio_02.pyDebe incluir "250"

import numpy as np
from sklearn.linear_model import LinearRegression

metros = np.array([30, 50, 70, 90, 120, 150]).reshape(-1, 1)
precio = np.array([75000, 125000, 175000, 225000, 300000, 375000])

modelo = LinearRegression().fit(metros, precio)

# Predecí para 100 m²

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: R² — bondad de ajuste

Calculá el R² del modelo de regresión. Debe incluir un valor alto (ej: 0.9).

ejercicio_03.pyDebe incluir "0.9..."

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.metrics import r2_score

np.random.seed(42)
X = np.random.uniform(20, 150, 50).reshape(-1, 1)
y = X.ravel() * 2500 + 50000 + np.random.normal(0, 15000, 50)

modelo = LinearRegression().fit(X, y)
pred = modelo.predict(X)

# Calculá e imprimí el R²

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Reg. Logística con probabilidades

Entrenáuna regresión logística y usá predict_proba para obtener probabilidades. Imprimí la probabilidad del primer caso de test. Debe incluir 0..

ejercicio_04.pyDebe incluir "0."

import numpy as np
from sklearn.linear_model import LogisticRegression
from sklearn.model_selection import train_test_split

np.random.seed(42)
X = np.random.rand(200, 2)
y = (X[:, 0] + X[:, 1] > 1).astype(int)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)

# Entrenar, predict_proba, imprimir P del primer caso

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Árbol de decisión — exportar reglas

Entrenáun árbol con max_depth=2 e imprimí las reglas con export_text. Debe incluir <= (símbolo de regla).

ejercicio_05.pyDebe incluir "<="

import numpy as np
from sklearn.tree import DecisionTreeClassifier, export_text

np.random.seed(42)
X = np.random.rand(100, 2)
y = ((X[:, 0] > 0.5) & (X[:, 1] > 0.3)).astype(int)

# Entrenar con max_depth=2, export_text

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: KNN — probar distintas K

Probá KNN con K = 1, 3, 5, 7, 9. Imprimí la accuracy de cada uno. Debe incluir k=.

ejercicio_06.pyDebe incluir "k="

import numpy as np
from sklearn.neighbors import KNeighborsClassifier
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score

np.random.seed(42)
X = np.random.rand(200, 2)
y = (X[:, 0] + X[:, 1] > 1).astype(int)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)

# Probar K = 1, 3, 5, 7, 9

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Regresión múltiple con MAE

Entrená regresión con 3 features, evaluá con MAE y R². Debe incluir R².

ejercicio_07.pyDebe incluir "R²"

import numpy as np
from sklearn.linear_model import LinearRegression
from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_absolute_error, r2_score

np.random.seed(42)
n = 200
X = np.column_stack([np.random.randint(30,150,n), np.random.randint(1,6,n), np.random.randint(0,40,n)])
y = X[:,0]*2500 + X[:,1]*15000 - X[:,2]*800 + np.random.normal(0,20000,n)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)

# Entrenar, evaluar con MAE y R²

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Visualizar regresión lineal

Entrenáuna regresión y graficá los puntos reales + la recta de predicción. Imprimí Gráfico OK.

ejercicio_08.pyDebe imprimir "Gráfico OK"

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
from sklearn.linear_model import LinearRegression

np.random.seed(42)
X = np.random.uniform(1, 20, 50).reshape(-1, 1)
y = X.ravel() * 35000 + 150000 + np.random.normal(0, 50000, 50)

# Entrenar, graficar scatter + recta, imprimir "Gráfico OK"

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Feature importance del árbol

Entrenaun árbol con 3 features. Imprimí la importancia de cada una ordenada de mayor a menor. Debe incluir Importancia.

ejercicio_09.pyDebe incluir "Importancia"

import numpy as np
from sklearn.tree import DecisionTreeClassifier

np.random.seed(42)
n = 200
X = np.column_stack([np.random.rand(n), np.random.rand(n), np.random.rand(n)])
y = (X[:, 0] * 2 + X[:, 1] > 1.5).astype(int)
features = ["Feature_A", "Feature_B", "Feature_C"]

# Entrenar árbol, imprimir importancia ordenada

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Pipeline completo con gráfico de comparación

Compará 3 clasificadores, generá un gráfico de barras con sus accuracy, precision y recall. Imprimí Comparación completa.

ejercicio_10_desafio.pyDebe imprimir "Comparación completa"

import matplotlib
matplotlib.use('Agg')
import matplotlib.pyplot as plt
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.linear_model import LogisticRegression
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, precision_score, recall_score

np.random.seed(42)
X = np.random.rand(300, 3)
y = (X[:, 0] + X[:, 1] * 0.5 > 0.8).astype(int)
X_tr, X_te, y_tr, y_te = train_test_split(X, y, test_size=0.2, random_state=42)

# 3 modelos → métricas → gráfico de barras comparativo

Hacé clic en ▶ Ejecutar

Resumen y conexión

Regresión Lineal: predice números. Interpretación directa: "por cada unidad de X, Y cambia en coef."
Regresión Logística: predice probabilidades (0 a 1). Perfecta para scoring y clasificación binaria.
Árboles de Decisión: generan reglas legibles. max_depth controla la complejidad (evitar overfitting).
KNN: clasifica por cercanía. Simple pero efectivo. K grande = más estable, menos detallado.
Para regresión usá MAE y R². Para clasificación usá accuracy, precision, recall.
Feature importance te dice qué variables son las más influyentes en las predicciones.
Siempre compará al menos 2-3 modelos antes de elegir uno.

En la siguiente lección (16 · Power BI / Tableau intro) vas a aprender cómo llevar tus análisis a herramientas de visualización empresarial que usan los equipos de Business Intelligence en todo el mundo.

Recursos: scikit-learn Supervised Learning · Model Evaluation

Hecho con ❤️ por Rodri Gonzalez