Data Analysis · Lección 14 de 19

Introducción a Machine Learning

Machine Learning (ML) es el campo de la inteligencia artificial donde las computadoras aprenden patrones a partir de datos, sin ser programadas explícitamente para cada caso. No necesitás un doctorado para entenderlo — los conceptos fundamentales son simples y poderosos. Como Data Analyst, no vas a construir modelos complejos de deep learning, pero sí necesitás entender cómo funcionan para colaborar con Data Scientists y evaluar resultados.

90–120 min Prerrequisitos: Lección 13 (NumPy)

Concepto teórico

¿Qué es Machine Learning?

La programación tradicional funciona así: le das reglas + datos → la computadora produce respuestas. Machine Learning invierte el proceso: le das datos + respuestas correctas → la computadora descubre las reglas sola.

Analogía del médico: un médico no memoriza "si temperatura > 38°C y tos seca → gripe". Después de ver miles de pacientes (datos) con sus diagnósticos (respuestas), su cerebro aprende patrones. Cuando llega un nuevo paciente, aplica esos patrones para diagnosticar. Machine Learning hace exactamente eso, pero con datos y matemáticas.

Los 3 tipos de Machine Learning

Tipo	Qué tiene	Qué hace	Ejemplo
Supervisado	Datos + respuestas correctas	Aprende a predecir la respuesta	Predecir si un email es spam
No supervisado	Solo datos (sin respuestas)	Descubre estructura oculta	Agrupar clientes similares
Por refuerzo	Entorno + recompensas	Aprende por prueba y error	Un robot que aprende a caminar

El 90% del ML en empresas es supervisado. ¿El cliente va a abandonar? (clasificación). ¿Cuánto va a facturar este trimestre? (regresión). ¿Este mail es spam? (clasificación). ¿Cuánto vale esta propiedad? (regresión). Como Data Analyst, el ML supervisado es lo que más vas a encontrar.

Clasificación vs Regresión

Dentro del aprendizaje supervisado hay dos grandes familias:

Tipo	Variable objetivo	Predice	Ejemplo	Métricas
Clasificación	Categoría (discreta)	¿A qué grupo pertenece?	Spam / No spam	Accuracy, Precision, Recall
Regresión	Número (continuo)	¿Cuánto va a ser?	Precio de una casa	MAE, MSE, R²

El flujo de trabajo de ML

Todo proyecto de Machine Learning sigue estos 6 pasos:

Definir el problema: ¿qué queremos predecir? ¿Es clasificación o regresión?
Preparar los datos: limpieza, selección de features, encoding de variables categóricas.
Dividir: separar en train (para aprender) y test (para evaluar).
Entrenar: alimentar el modelo con los datos de entrenamiento.
Evaluar: medir el rendimiento con datos que el modelo nunca vio (test).
Iterar: ajustar parámetros, probar otros modelos, mejorar los datos.

El error más grave: evaluar con datos de entrenamiento. Si el modelo "estudio" con 100 pacientes y lo evaluás con los mismos 100, va a sacar 100% (los memorizó). Necesitás evaluarlo con pacientes nuevos — por eso se separa en train/test. Esto se llama data leakage y es la fuente #1 de modelos que parecen perfectos pero fallan en producción.

Vocabulario esencial

Término	Significado	Analogía
Features (X)	Variables predictoras (input)	Los síntomas del paciente
Target (y)	Variable a predecir (output)	El diagnóstico
Train set	Datos para aprender (70-80%)	Los pacientes que ya diagnosticaste
Test set	Datos para evaluar (20-30%)	Pacientes nuevos
Overfitting	Memoriza en vez de generalizar	Un estudiante que memoriza respuestas pero no entiende
Underfitting	Modelo demasiado simple	Un estudiante que no estudió lo suficiente
Hiperparámetros	Configuraciones del modelo	La dificultad del examen

En el trabajo real: como Data Analyst, tu rol en un proyecto de ML es: (1) entender el problema de negocio, (2) preparar y limpiar los datos (el 80% del trabajo), (3) interpretar los resultados y comunicarlos. No necesitás inventar algoritmos — necesitás saber qué significan las métricas y si el modelo sirve para el negocio.

Ejemplos explicados paso a paso

Ejemplo 1: El dataset y el problema

Antes de cualquier modelo, necesitás entender los datos. Creamos un dataset de clientes bancarios para predecir quién va a cancelar.

ejemplo_01_dataset.pyPython

import pandas as pd
import numpy as np

np.random.seed(42)
n = 200

antiguedad = np.random.randint(0, 20, n)
productos = np.clip(np.random.normal(3, 1.5, n), 1, 8).astype(int)
saldo = np.abs(np.random.normal(300000, 150000, n)).astype(int)

# La probabilidad de cancelar depende de estas variables
prob_cancel = 1 / (1 + np.exp(-(
    -2 + 
    -0.15 * antiguedad +   # más antigüedad → menos cancelación
    -0.3 * productos +      # más productos → menos cancelación
    0.000003 * saldo +      # más saldo → un poco más
    np.random.normal(0, 0.5, n)
)))
canceló = (prob_cancel > 0.5).astype(int)

df = pd.DataFrame({
    "Antiguedad": antiguedad,
    "Productos": productos,
    "Saldo": saldo,
    "Canceló": canceló
})

print("=== Dataset de Churn (cancelación) ===")
print(f"Dimensiones: {df.shape}")
print(f"\nPrimeras filas:")
print(df.head(10))
print(f"\n=== Balance de clases ===")
print(df["Canceló"].value_counts())
print(f"Tasa de cancelación: {df['Canceló'].mean()*100:.1f}%")

print(f"\n=== Estadísticas por grupo ===")
print(df.groupby("Canceló").agg(
    Antiguedad_Prom=("Antiguedad", "mean"),
    Productos_Prom=("Productos", "mean"),
    Saldo_Prom=("Saldo", "mean")
).round(0))

Hacé clic en ▶ Ejecutar

Ejemplo 2: Train/Test Split — Separar datos

El paso más importante antes de entrenar: dividir los datos. Nunca evalúes un modelo con los datos que usó para aprender.

ejemplo_02_split.pyPython

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

np.random.seed(42)
n = 200
df = pd.DataFrame({
    "Antiguedad": np.random.randint(0, 20, n),
    "Productos": np.clip(np.random.normal(3, 1.5, n), 1, 8).astype(int),
    "Saldo": np.abs(np.random.normal(300000, 150000, n)).astype(int),
    "Canceló": np.random.choice([0, 1], n, p=[0.7, 0.3])
})

# Separar Features (X) y Target (y)
X = df[["Antiguedad", "Productos", "Saldo"]]  # Features
y = df["Canceló"]                                # Target

# Dividir: 80% train, 20% test
X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=42
)

print(f"=== Train / Test Split ===")
print(f"Dataset total: {len(df)} filas")
print(f"Train: {len(X_train)} filas ({len(X_train)/len(df)*100:.0f}%)")
print(f"Test:  {len(X_test)} filas ({len(X_test)/len(df)*100:.0f}%)")
print(f"\nFeatures (X): {list(X.columns)}")
print(f"Target (y): Canceló (0=No, 1=Sí)")

print(f"\n=== Balance en train ===")
print(y_train.value_counts())
print(f"\n=== Balance en test ===")
print(y_test.value_counts())

Hacé clic en ▶ Ejecutar

Tip profesional — stratify: si tu variable target está desbalanceada (ej: 5% cancelan), usá stratify=y en train_test_split para que ambos conjuntos tengan la misma proporción. Sin esto, podrías terminar con un test set sin ningún caso positivo.

Ejemplo 3: Primer modelo — Árbol de Decisión

Entrenar un modelo de clasificación y hacer predicciones. El árbol de decisión es el modelo más intuitivo: genera reglas tipo "si antigüedad < 3 y productos < 2 → cancela".

ejemplo_03_arbol.pyPython

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier

np.random.seed(42)
n = 200
antiguedad = np.random.randint(0, 20, n)
productos = np.clip(np.random.normal(3, 1.5, n), 1, 8).astype(int)
prob = 1/(1+np.exp(-(-1 - 0.1*antiguedad - 0.4*productos + np.random.normal(0,0.5,n))))
canceló = (prob > 0.5).astype(int)
df = pd.DataFrame({"Antiguedad": antiguedad, "Productos": productos, "Canceló": canceló})

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

# 1. Crear el modelo
modelo = DecisionTreeClassifier(max_depth=3, random_state=42)

# 2. Entrenar (fit) con datos de train
modelo.fit(X_train, y_train)

# 3. Predecir con datos de test
predicciones = modelo.predict(X_test)

print("=== Predicciones vs Realidad (primeras 10) ===")
comparacion = pd.DataFrame({
    "Real": y_test.values[:10],
    "Predicho": predicciones[:10],
    "Correcto": ["✅" if r==p else "❌" for r,p in zip(y_test.values[:10], predicciones[:10])]
})
print(comparacion.to_string(index=False))

# 4. Accuracy
from sklearn.metrics import accuracy_score
acc = accuracy_score(y_test, predicciones)
print(f"\nAccuracy: {acc*100:.1f}%")
print(f"De {len(y_test)} predicciones, {int(acc*len(y_test))} fueron correctas")

Hacé clic en ▶ Ejecutar

Ejemplo 4: Métricas — ¿Es bueno mi modelo?

Accuracy no siempre basta. Si el 95% de los clientes no cancelan, un modelo que siempre dice "no cancela" tiene 95% de accuracy pero es inútil. Necesitás precision, recall y la matriz de confusión.

ejemplo_04_metricas.pyPython

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
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)
prod = np.clip(np.random.normal(3, 1.5, n), 1, 8).astype(int)
prob = 1/(1+np.exp(-(-1 - 0.1*ant - 0.4*prod + np.random.normal(0,0.5,n))))
canc = (prob > 0.5).astype(int)
df = pd.DataFrame({"Antiguedad": ant, "Productos": prod, "Canceló": canc})

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

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

# Métricas
print("=== Métricas del Modelo ===")
print(f"Accuracy:  {accuracy_score(y_test, pred)*100:.1f}%  (% total correctos)")
print(f"Precision: {precision_score(y_test, pred)*100:.1f}%  (de los que predije + ¿cuántos realmente eran +?)")
print(f"Recall:    {recall_score(y_test, pred)*100:.1f}%  (de los reales + ¿cuántos capturé?)")

# Matriz de confusión
cm = confusion_matrix(y_test, pred)
print(f"\n=== Matriz de Confusión ===")
print(f"                  Predicho NO  Predicho SÍ")
print(f"  Real NO (0):       {cm[0,0]:>4}        {cm[0,1]:>4}")
print(f"  Real SÍ (1):       {cm[1,0]:>4}        {cm[1,1]:>4}")
print(f"\n  Verdaderos Negativos (TN): {cm[0,0]}")
print(f"  Falsos Positivos (FP):     {cm[0,1]}")
print(f"  Falsos Negativos (FN):     {cm[1,0]}  ← Los más peligrosos")
print(f"  Verdaderos Positivos (TP): {cm[1,1]}")

Hacé clic en ▶ Ejecutar

Precision vs Recall:
Precision: "De todos los que el modelo dijo que cancelan, ¿cuántos realmente cancelan?" → Importa cuando los falsos positivos son costosos (ej: enviar un descuento a alguien que no iba a cancelar).
Recall: "De todos los que realmente cancelan, ¿cuántos capturó el modelo?" → Importa cuando los falsos negativos son costosos (ej: no detectar un fraude).

Ejemplo 5: Comparar modelos

Nunca te quedes con un solo modelo. Probá varios y compará las métricas. scikit-learn hace que cambiar de modelo sea cambiar una línea de código.

ejemplo_05_comparar.pyPython

import pandas as pd
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

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)
saldo = np.abs(np.random.normal(300, 150, n))
prob = 1/(1+np.exp(-(-1 - 0.1*ant - 0.3*prod + np.random.normal(0,0.5,n))))
canc = (prob > 0.5).astype(int)

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

# Probar 3 modelos distintos
modelos = {
    "Árbol de Decisión": DecisionTreeClassifier(max_depth=3, random_state=42),
    "Regresión Logística": LogisticRegression(random_state=42, max_iter=200),
    "K-Vecinos (K=5)": KNeighborsClassifier(n_neighbors=5),
}

print("=== Comparación de Modelos ===")
print(f"{'Modelo':<25} {'Accuracy':>10}")
print("-" * 37)

for nombre, modelo in modelos.items():
    modelo.fit(X_train, y_train)
    pred = modelo.predict(X_test)
    acc = accuracy_score(y_test, pred)
    print(f"{nombre:<25} {acc*100:>9.1f}%")

print("\nMismos datos, 3 algoritmos, resultados distintos.")
print("Elegí el que mejor se adapte al problema y las métricas que importan.")

Hacé clic en ▶ Ejecutar

Referencia rápida

Paso	Código scikit-learn	Qué hace
Separar datos	`train_test_split(X, y)`	80/20 (o 70/30)
Crear modelo	`DecisionTreeClassifier()`	Instanciar
Entrenar	`modelo.fit(X_train, y_train)`	Aprender patrones
Predecir	`modelo.predict(X_test)`	Aplicar lo aprendido
Accuracy	`accuracy_score(y, pred)`	% correcto total
Precision	`precision_score(y, pred)`	% de positivos predichos que son reales
Recall	`recall_score(y, pred)`	% de positivos reales capturados
Confusión	`confusion_matrix(y, pred)`	Tabla TN/FP/FN/TP

Ejercicios

Nivel 1 · Básico

Ejercicio 1: Separar Features y Target

Separá X (Edad, Ingreso) e y (Compra). Imprimí el shape de X. Debe incluir (6, 2).

ejercicio_01.pyDebe incluir "(6, 2)"

import pandas as pd

df = pd.DataFrame({
    "Edad": [25, 30, 35, 40, 45, 50],
    "Ingreso": [200, 350, 400, 550, 600, 750],
    "Compra": [0, 0, 1, 1, 1, 1]
})

# Separá X (features) e y (target)

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 2: Train/Test split

Dividí el dataset en 80% train y 20% test. Imprimí cuántas filas tiene el train. Debe incluir 160.

ejercicio_02.pyDebe incluir "160"

import pandas as pd
import numpy as np
from sklearn.model_selection import train_test_split

np.random.seed(42)
df = pd.DataFrame({
    "Edad": np.random.randint(18, 65, 200),
    "Ingreso": np.random.normal(400, 100, 200).astype(int),
    "Compra": np.random.choice([0, 1], 200)
})

X = df[["Edad", "Ingreso"]]
y = df["Compra"]

# train_test_split con test_size=0.2

Hacé clic en ▶ Ejecutar

Nivel 1 · Básico

Ejercicio 3: Entrenar y predecir

Entrenáun DecisionTreeClassifier y hacé predicciones. Imprimí la accuracy. Debe incluir %.

ejercicio_03.pyDebe incluir "%"

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

np.random.seed(42)
X = np.random.rand(200, 3)
y = (X[:, 0] + X[:, 1] > 1).astype(int)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Crear modelo, fit, predict, accuracy

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 4: Matriz de confusión

Entrenáun modelo y mostrásu matriz de confusión. Imprimí cuántos Falsos Negativos hay. Debe incluir FN.

ejercicio_04.pyDebe incluir "FN"

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import confusion_matrix

np.random.seed(42)
X = np.random.rand(200, 2)
y = (X[:, 0] * 2 + X[:, 1] > 1.5).astype(int)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Entrenar, predecir, confusion_matrix

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 5: Precision y Recall

Calculá precision y recall del modelo. Imprimí ambas. Debe incluir Precision.

ejercicio_05.pyDebe incluir "Precision"

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import precision_score, recall_score

np.random.seed(42)
X = np.random.rand(200, 2)
y = (X[:, 0] + X[:, 1] > 1).astype(int)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Entrenar, predecir, precision, recall

Hacé clic en ▶ Ejecutar

Nivel 2 · Intermedio

Ejercicio 6: Probar otro modelo (Regresión Logística)

Cambiá el modelo a LogisticRegression y medí su accuracy. Debe incluir %.

ejercicio_06.pyDebe incluir "%"

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
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_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# LogisticRegression → fit → predict → accuracy

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 7: Comparar 2 modelos

Compará Árbol de Decisión vs Regresión Logística. Imprimí cuál ganó. Debe incluir Ganador.

ejercicio_07.pyDebe incluir "Ganador"

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.metrics import accuracy_score

np.random.seed(42)
X = np.random.rand(300, 3)
y = (X[:, 0] + X[:, 1] * 0.5 > 0.8).astype(int)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Entrenar ambos, comparar accuracy, imprimir ganador

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 8: Overfitting — profundidad del árbol

Entrenáárboles con max_depth de 1 a 10. Imprimí accuracy de train y test para cada uno. El test accuracy puede bajar con árboles profundos (overfitting). Debe incluir depth.

ejercicio_08.pyDebe incluir "depth"

import numpy as np
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier
from sklearn.metrics import accuracy_score

np.random.seed(42)
X = np.random.rand(200, 3)
y = (X[:, 0] + X[:, 1] > 1).astype(int)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Probar depth 1 a 10

Hacé clic en ▶ Ejecutar

Nivel 3 · Avanzado

Ejercicio 9: Feature importance

Después de entrenar un árbol, imprimí qué features son más importantes con modelo.feature_importances_. Debe incluir Importancia.

ejercicio_09.pyDebe incluir "Importancia"

import pandas as pd
import numpy as np
from sklearn.tree import DecisionTreeClassifier

np.random.seed(42)
n = 200
df = pd.DataFrame({
    "Antiguedad": np.random.randint(0, 20, n),
    "Productos": np.random.randint(1, 8, n),
    "Saldo": np.random.normal(300, 150, n).astype(int)
})
df["Canceló"] = ((df["Antiguedad"] < 5) & (df["Productos"] < 3)).astype(int)

X = df[["Antiguedad", "Productos", "Saldo"]]
y = df["Canceló"]

# Entrenar y mostrar feature_importances_

Hacé clic en ▶ Ejecutar

Nivel 4 · Desafío

Ejercicio 10: Pipeline completo de ML

Flujo completo: crear datos → split → entrenar 2 modelos → evaluar con accuracy, precision, recall → imprimir el mejor. Debe incluir Mejor.

ejercicio_10_desafio.pyDebe incluir "Mejor"

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.metrics import accuracy_score, precision_score, recall_score

np.random.seed(42)
X = np.random.rand(300, 3)
y = (X[:, 0] * 2 + X[:, 1] - X[:, 2] > 1.5).astype(int)

# Pipeline completo: split → 2 modelos → métricas → ganador

Hacé clic en ▶ Ejecutar

Resumen y conexión

ML supervisado: le das datos + respuestas → aprende a predecir.
Clasificación predice categorías; regresión predice números.
Siempre separá train/test — evaluar con datos de entrenamiento es el error #1.
El flujo es: split → fit → predict → evaluate.
Accuracy no siempre basta — usá precision y recall según el costo de los errores.
Overfitting: el modelo memoriza en vez de generalizar (train accuracy alta, test baja).
Siempre compará al menos 2-3 modelos distintos.

En la siguiente lección (15 · Regresión y clasificación) vas a profundizar en los algoritmos más usados: regresión lineal, logística, árboles y KNN, con implementaciones completas y visualizaciones de sus decisiones.

Recursos: scikit-learn Getting Started · Tutorial básico

Hecho con ❤️ por Rodri Gonzalez