Introducción a Machine Learning y Data Acquisition I

ML no es una línea recta: es un ciclo donde cada evaluación genera una nueva pregunta sobre los datos.

— Principio del ciclo de ML

3.1 El ciclo de vida del Machine Learning

Todo proyecto serio de ML recorre el mismo camino, sea para churn, precios o segmentación:

Pregunta de negocio
        ↓
Problema de datos medible (target + métrica)
        ↓
Adquisición y comprensión de datos
        ↓
Preparación y limpieza
        ↓
Modelado (entrenamiento + validación)
        ↓
Evaluación con datos no vistos
        ↓
Despliegue, monitoreo y mejora
        → vuelve a Pregunta

Cada flecha hacia abajo es una transformación; la flecha final hacia arriba es el aprendizaje del equipo. Si la evaluación muestra que el modelo memoriza pero no generaliza, no ajustas hiperparámetros a ciegas: vuelves a los datos.

Las seis etapas con criterio

Qué documentar antes de codificar

Antes de abrir un notebook, escribe en una línea:

Una fila = un cliente activo al cierre de mes
Target  = cancela en los próximos 30 días (0/1)
Features= compras 90 días, tickets abiertos, saldo pendiente
Horizonte= 30 días
Métrica = F1 (equilibrio entre falsos positivos y falsos negativos)
Baseline= predecir siempre la clase mayoritaria

Si no puedes escribir eso, aún no tienes un problema de ML: tienes una intención.

3.2 Aprendizaje supervisado

Aprende de pares (X, y) donde y es la etiqueta conocida. El modelo aproxima la función f: X → y.

Histórico etiquetado              Modelo entrenado         Datos nuevos
[X: compras, tickets, saldo] → f(X) → ŷ (predicción) → decisión

Dos tareas fundamentales

• Clasificación: y es discreta. ¿El cliente cancela? ¿El mail es spam? ¿Qué segmento asignar?
• Regresión: y es continua. ¿Cuál será el gasto mensual? ¿El precio de la vivienda? ¿Las unidades vendidas?

Cuándo usarlo y con qué algoritmos

Úsalo cuando tienes histórico etiquetado y quieres repetir esa misma predicción a futuro.

Algoritmos habituales por tarea:

• Clasificación: Regresión logística, árboles, Random Forest, XGBoost, SVM, redes neuronales.
• Regresión: Regresión lineal/regularizada (Ridge/Lasso), árboles y ensembles, redes.

# Idea del flujo supervisado con scikit-learn
from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestClassifier

# X = features, y = target conocido
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
modelo = RandomForestClassifier(random_state=42)
modelo.fit(X_train, y_train)          # aprende de etiquetas
predicciones = modelo.predict(X_test) # aplica a datos no vistos

La validación se hace comparando predicciones contra y_test con una métrica adecuada (accuracy, F1, RMSE, etc.).

3.3 Aprendizaje no supervisado

Solo tienes X, sin y. El objetivo es descubrir estructura.

• Clustering: agrupar observaciones similares sin clases predefinidas. Ej: segmentar clientes por gasto y frecuencia.
• Reducción de dimensionalidad: PCA, t-SNE, UMAP para comprimir o visualizar.
• Reglas de asociación: “quien compra X también compra Y”.
• Detección de anomalías: transacciones que no encajan con el comportamiento normal.

from sklearn.cluster import KMeans
from sklearn.preprocessing import StandardScaler

# Sin y: solo X
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X[['gasto_mensual']])

kmeans = KMeans(n_clusters=3, random_state=42, n_init=10)
clusters = kmeans.fit_predict(X_scaled)

La evaluación aquí no usa y_test. Se usan métricas internas como inercia o silueta, o validación cualitativa con negocio.

3.4 Cómo elegir: del problema al paradigma

Regla práctica en una línea:

Si puedes preguntar “dado X, ¿cuánto vale y?”, es supervisado. Si preguntas “¿qué grupos naturales existen en X?”, es no supervisado.

3.5 Fuentes de datos y formatos

La adquisición condiciona todo lo que sigue. Clasifica la fuente antes de elegir herramienta.

CSV vs Excel vs JSON vs Parquet

Criterio profesional: registra siempre origen, fecha de extracción, encoding y versión del archivo. Sin eso no puedes reproducir un resultado.

3.6 Lectura robusta en Python: pandas, json y pathlib

Dos errores clásicos rompen pipelines en producción: rutas absolutas hardcodeadas y encoding asumido.

Por qué pathlib.Path

# Frágil: solo funciona en tu máquina
csv_path = "C:\\Users\\denny\\OneDrive\\Documentos\\archivo.csv"

# Robusto: portable entre SO y resiste mover el proyecto
from pathlib import Path
csv_path = Path("data") / "ventas_mensuales.csv"
# Si el script se mueve, usa Path(__file__).parent / "data" / "ventas_mensuales.csv"

Path une con / de forma portable, resuelve .. y evita mezclar \ y /.

Por qué encoding="utf-8"

CSV no declara encoding. Si el archivo tiene tildes, ñ o emojis y lees sin declarar, obtienes UnicodeDecodeError o caracteres mojibake.

import pandas as pd

# Explícito y reproducible
df = pd.read_csv(csv_path, encoding="utf-8")
print(df.head())
print(df.dtypes)  # verifica qué tipos infirió pandas

Por qué with + json.load

import json

# json.load lee desde archivo abierto; json.loads lee desde string
with open(json_path, encoding="utf-8") as f:
    config = json.load(f)  # asegura cierre del archivo incluso si falla

print(config["nombre_tienda"])

with garantiza cierre del descriptor. json.load(f) vs json.loads(texto): la s es de string.

Ejercicio 1 — Carga de CSV y JSON

import pandas as pd
import json
from pathlib import Path

# Define rutas portables (no absolutas)
csv_path = Path("data/ventas_mensuales.csv")
json_path = Path("data/configuracion_tienda.json")

def cargar_datos():
    # --- CSV con encoding explícito ---
    df_ventas = pd.read_csv(csv_path, encoding="utf-8")
    print(df_ventas.head())   # primeras 5 filas
    print(df_ventas.shape)    # filas × columnas
    print(df_ventas.dtypes)   # tipos inferidos

    # --- JSON con with + json.load ---
    with open(json_path, encoding="utf-8") as f:
        data_config = json.load(f)

    print(data_config["nombre_tienda"])
    print(f"Claves del JSON: {list(data_config.keys())}")

    return df_ventas, data_config

if __name__ == "__main__":
    ventas, config = cargar_datos()

3.7 Preparación inicial: duplicados, tipos y nulos

Los datos reales llegan sucios. Limpiar no es “estorbo previo”: es parte del modelado.

Duplicados

# Duplicados exactos: filas 100% idénticas
df = df.drop_duplicates()

# Duplicados por clave de negocio
df = df.drop_duplicates(subset=["id_cliente"])
print(f"Duplicados restantes: {df.duplicated().sum()}")

Un duplicado exacto sesga promedios y conteos. Un duplicado por clave (mismo id_cliente dos veces) puede indicar un join mal hecho aguas arriba.

Tipos

Antes de modelar, asegura que cada columna tenga el tipo que su semántica exige:

• gasto_mensual → float (numérico continuo)
• segmento → str / category (categórica)
• id_cliente → int o str según si es identificador o feature

df["gasto_mensual"] = pd.to_numeric(df["gasto_mensual"], errors="coerce")
df["segmento"] = df["segmento"].astype("string")

errors="coerce" convierte lo no numérico en NaN en lugar de romper el pipeline: luego decides si imputas o descartas.

Nulos: mediana vs media vs etiqueta

import numpy as np

mediana = df["gasto_mensual"].median()  # ignora NaN por defecto
df["gasto_mensual"] = df["gasto_mensual"].fillna(mediana)

df["segmento"] = df["segmento"].fillna("Sin Info")

print(df.isna().sum())  # debe ser 0 en ambas columnas

fillna no modifica in-place por defecto. df["col"].fillna(v) sin asignar no cambia df. Usa df["col"] = df["col"].fillna(v).

3.8 División train/test y fuga de información

Entrenar y evaluar sobre los mismos datos es autoengaño. Separa:

from sklearn.model_selection import train_test_split

# X = features, y = target
X = df[["id_cliente", "segmento"]]  # o df.drop(columns=["gasto_mensual"])
y = df["gasto_mensual"]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.2, random_state=123
)
print(f"Train: {len(X_train)} filas | Test: {len(X_test)} filas")

• test_size=0.2 → 80% entrena, 20% evalúa. Estándar en datasets pequeños/medianos. Con 1.000 filas: 800 train / 200 test.
• random_state=123 → semilla fija: el mismo split reproducible en cada ejecución. Sin ella, cada run baraja distinto y no puedes comparar experimentos.
• stratify=y (opcional, en clasificación) → preserva proporción de clases en train y test.

El principio que no puedes violar: sin leakage

En este capítulo simplificamos y calculamos la mediana sobre el dataset completo para enfocarnos en la mecánica. En un pipeline profesional:

# Correcto en producción: mediana aprendida solo de train
mediana_train = X_train["gasto_mensual"].median() if "gasto_mensual" in X_train else df_train["gasto_mensual"].median()
X_train["gasto_mensual"] = X_train["gasto_mensual"].fillna(mediana_train)
X_test["gasto_mensual"]  = X_test["gasto_mensual"].fillna(mediana_train)  # reutiliza la de train

La misma regla aplica a StandardScaler, OneHotEncoder y cualquier transformador: fit en train, transform en test.

Ejercicio 2 — Limpieza, imputación y división

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

data = {
    "id_cliente": [101, 102, 102, 103, 104, 105],
    "gasto_mensual": [250.0, 300.5, 300.5, np.nan, 150.0, 400.0],
    "segmento": ["Premium", "Básico", "Básico", "Premium", np.nan, "Básico"],
}
df = pd.DataFrame(data)

# 1. Duplicados exactos
df = df.drop_duplicates()
print(f"Filas tras dedup: {len(df)}")  # 5, no 6

# 2. Mediana para numérico (robusta)
mediana = df["gasto_mensual"].median()
df["gasto_mensual"] = df["gasto_mensual"].fillna(mediana)
print(f"Mediana imputada: {mediana}")

# 3. Etiqueta para categórico
df["segmento"] = df["segmento"].fillna("Sin Info")

# 4. División 80/20 reproducible
X = df[["id_cliente", "segmento"]]
y = df["gasto_mensual"]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=123)

print("Train:\n", X_train)
print("Nulos por columna:\n", df.isna().sum())

assert df.duplicated().sum() == 0, "Quedan duplicados"
assert df["gasto_mensual"].isna().sum() == 0
assert df["segmento"].isna().sum() == 0
assert len(X_train) == 4 and len(X_test) == 1  # 80/20 de 5 filas tras dedup

3.9 Integración: pipeline reproducible mínimo

Un pipeline no es un script largo: es una secuencia con contrato y validación.

import pandas as pd
from pathlib import Path

def cargar_datos(csv_path: Path) -> pd.DataFrame:
    df = pd.read_csv(csv_path, encoding="utf-8")
    return df

def validar_contrato(df: pd.DataFrame) -> pd.DataFrame:
    requeridas = {"id_cliente", "gasto_mensual", "segmento"}
    faltantes = requeridas - set(df.columns)
    if faltantes:
        raise ValueError(f"Faltan columnas: {faltantes}")
    if (df["gasto_mensual"] < 0).any():
        raise ValueError("gasto_mensual no puede ser negativo")
    return df

def limpiar(df: pd.DataFrame) -> pd.DataFrame:
    df = df.drop_duplicates()
    mediana = df["gasto_mensual"].median()
    df["gasto_mensual"] = df["gasto_mensual"].fillna(mediana)
    df["segmento"] = df["segmento"].fillna("Sin Info")
    return df

# Uso
df = cargar_datos(Path("data/ventas.csv"))
df = validar_contrato(df)
df = limpiar(df)

Tres evidencias de un pipeline profesional:

• Contrato: columnas, tipos y rangos esperados (falla temprano si el origen cambia).
• Linaje: de qué archivo vino cada columna y qué transformaciones recibió.
• Idempotencia: dos ejecuciones con la misma entrada producen el mismo resultado, sin duplicar.

3.10 Preguntas de entrevista

3.11 Recursos