Fundamentos de Machine Learning

Hasta ahora has limpiado tablas y dibujado gráficos. En esos casos eras tú quien escribía la regla: «si el área supera 100 m², el precio es alto». El Machine Learning cambia el reparto: le entregas ejemplos resueltos y él propone la regla.

Esta lección es el mapa del territorio. No entrenarás todavía un modelo complejo: entenderás qué entra, qué sale y cómo se comprueba si el resultado sirve. Con ese vocabulario, las tres lecciones siguientes encajan como piezas de un mismo motor.

¿Qué es el Machine Learning?

El Machine Learning es la rama de la inteligencia artificial que construye programas capaces de mejorar con datos en lugar de recibir una instrucción para cada caso. Un programa clásico recibe reglas y datos y devuelve respuestas; un modelo recibe datos y respuestas, y devuelve la regla, que después aplica a datos nuevos.

Buscas una función f tal que f(X) se parezca a y. Si X son el área y las habitaciones de un departamento, e y su precio, aprender es ajustar los números internos de f hasta que sus predicciones se acerquen a los precios reales. Lo importante no es acertar en los ejemplos vistos, sino en los que verá por primera vez: eso se llama generalizar.

¿Para qué sirve?

Tiene sentido cuando la decisión se repite muchas veces, existe un historial de casos resueltos y las reglas escritas a mano se vuelven inmanejables. Casos típicos, con su tipo de problema:

• Filtro de spam: decides si un correo es basura a partir de palabras y remitente (clasificación).
• Precio de una vivienda: estimas un número continuo con área, zona y antigüedad (regresión).
• Segmentos de clientes: agrupas compras parecidas sin saber qué grupos existen (clustering).
• Detección de fraude: encuentras pocos cargos anómalos entre millones normales (clasificación desbalanceada).
• Mantenimiento predictivo: anticipas qué máquina fallará según vibración y temperatura.

¿Cómo funciona por dentro? El pipeline conceptual

Todo proyecto recorre las mismas etapas. Cambian las herramientas, no el orden:

• Definir el problema: qué decisión tomas, qué error duele más y cómo se mide el éxito.
• Limpiar: una fila por caso, una columna por variable, sin duplicados ni fugas.
• Elegir características y etiqueta: separas X (lo que sabes antes) e y (lo que predices).
• Dividir: reservas datos que el modelo no verá durante el ajuste.
• Entrenar: el algoritmo ajusta sus parámetros para reducir una pérdida.
• Evaluar: mides el error en datos reservados y comparas con una referencia simple.

La división es la parte que más se salta y la que más engaña. Si estudias con exámenes resueltos y te evalúan con esos mismos exámenes, sacarás 20 sin haber aprendido. Reservar datos es guardar preguntas que nunca viste.

Sintaxis: el vocabulario mínimo

Las dimensiones cuentan la historia: con 6 filas y 2 columnas, X mide (6, 2) e y mide (6,). Seis ejemplos, dos características, una etiqueta por ejemplo. Cuando scikit-learn se queja de formas incompatibles, casi siempre sobra una fila o una columna.

Ejemplo básico: de una tabla a X e y

Estos seis departamentos tienen precios construidos con una regla exacta: 1.5 mil soles por metro cuadrado, 5 mil por habitación y 5 mil de base. Así puedes comprobar a mano cada número.

12345678910111213

X = [
    [40, 1],
    [60, 2],
    [80, 2],
    [100, 3],
    [120, 3],
    [140, 4],
]
y = [70, 105, 135, 170, 200, 235]  # precio en miles de soles

print(len(X), "ejemplos")
print(len(X[0]), "características")
print("primera fila:", X[0], "->", y[0])

len(X) cuenta filas; len(X[0]) cuenta columnas. La salida es 6 ejemplos, 2 características y primera fila: [40, 1] -> 70. Fíjate en que y no está dentro de X: si incluyeras el precio como columna, el modelo tendría la respuesta en la entrada.

Visualización: la matriz X y el vector y

Lee la matriz como una hoja de cálculo sin la columna del precio: esas dos columnas son lo que el modelo puede usar, y el precio vive aparte, en un vector paralelo que intentará reproducir para filas nuevas.

Ejemplo intermedio: separar antes de entrenar

Con seis filas, la división más honesta deja cuatro para aprender y dos para comprobar:

1234567891011

X = [[40, 1], [60, 2], [80, 2], [100, 3], [120, 3], [140, 4]]
y = [70, 105, 135, 170, 200, 235]

corte = 4  # cuatro filas para entrenar, dos para evaluar
X_train, y_train = X[:corte], y[:corte]
X_test, y_test = X[corte:], y[corte:]

print("entrenamiento:", len(X_train), "filas")
print("prueba:", len(X_test), "filas")
print("prueba X:", X_test)
print("prueba y:", y_test)

La salida confirma el reparto: entrenamiento: 4 filas, prueba: 2 filas, prueba X: [[120, 3], [140, 4]] y prueba y: [200, 235]. Un corte por posición sirve si el orden es arbitrario; si las filas están ordenadas por precio, el test se parece demasiado al train y la medida se infla.

1

python -m pip install scikit-learn

1234567891011

from sklearn.model_selection import train_test_split

X = [[40, 1], [60, 2], [80, 2], [100, 3], [120, 3], [140, 4]]
y = [70, 105, 135, 170, 200, 235]

X_train, X_test, y_train, y_test = train_test_split(
    X, y, test_size=0.25, random_state=0
)

print(len(X_train), "en train")
print(len(X_test), "en test")

train_test_split mezcla las filas y respeta la correspondencia entre cada X y su y. Con 6 filas, el 25 % son 1.5, así que redondea hacia arriba: 2 para test y 4 para entrenamiento. random_state fija la mezcla.

Supervisado, no supervisado y los tipos de problema

La primera división depende de si tienes respuestas. En el supervisado cada ejemplo trae su etiqueta y el modelo aprende a predecirla. En el no supervisado no hay etiqueta: buscas grupos o estructura. El refuerzo aprende por recompensas tras actuar.

Dentro del supervisado, la etiqueta decide el resto. Si y es continuo —un precio, una temperatura— hablas de regresión. Si es una categoría —spam o no— hablas de clasificación. La regresión logística se llama así por historia, pero resuelve clasificación: devuelve una probabilidad.

La pérdida: cómo se mide el error

Una función de pérdida convierte «qué tan mal predice el modelo» en un número que el algoritmo puede minimizar. En regresión, la más usada es el error cuadrático medio (MSE): promedias las diferencias al cuadrado entre lo real y lo predicho. Al elevar al cuadrado, castiga mucho los errores grandes.

El error absoluto medio (MAE) promedia el valor absoluto de los errores. Está en las mismas unidades que y y resiste mejor los valores atípicos. Ninguna es «la correcta»: elige la que refleje el coste real de equivocarte. Para minimizar la pérdida, la mayoría de modelos usa descenso de gradiente: calcula cómo cambia el error al mover cada parámetro (la derivada o gradiente) y da un pequeño paso en la dirección que lo reduce.

Traza: cómo se calcula el error paso a paso

Un baseline que siempre predice la media es la primera comparación que debes batir. Con cuatro precios, la media es 120 y el MSE se calcula así:

—

La media de estos cuatro precios (120) es menor que la de los seis departamentos (152.5), así que el error también cambia: cada conjunto tiene su referencia. Y la raíz del MSE vale 36.9 mil soles, una cifra que sí puedes comparar con un precio.

Sesgo, varianza y las tres particiones

El sesgo es el error de un modelo demasiado simple: aunque le des más datos, seguirá sin capturar la curva real. La varianza es el error de un modelo demasiado sensible: cambia sus predicciones si cambias unas filas. El primero produce subajuste (falla en ambos conjuntos); la segunda, sobreajuste (brilla en entrenamiento y cae en prueba).

Para distinguirlos necesitas tres conjuntos. Con entrenamiento ajustas parámetros; con validación eliges hiperparámetros; con prueba informas el resultado final, una sola vez. Si usas el test para decidir, deja de ser test.

Caso práctico: predecir el precio de un departamento

Con los seis departamentos puedes montar el esqueleto completo sin bibliotecas externas: entrenar, predecir y evaluar. El modelo es la media, el baseline que cualquier modelo real debe superar.

1234567891011121314151617

X = [[40, 1], [60, 2], [80, 2], [100, 3], [120, 3], [140, 4]]
y = [70, 105, 135, 170, 200, 235]

def entrenar(X, y):
    return sum(y) / len(y)          # el baseline predice siempre la media

def predecir(modelo, X):
    return [modelo for _ in X]

def mse(real, predicho):
    return sum((r - p) ** 2 for r, p in zip(real, predicho)) / len(real)

modelo = entrenar(X, y)
predicciones = predecir(modelo, X)

print("predicción constante:", modelo)
print("MSE:", round(mse(y, predicciones), 2))

La salida es predicción constante: 152.5 y MSE: 3122.92. No significa que el modelo sea malo por naturaleza: significa que ignorar el área y las habitaciones cuesta muchísimo. Un modelo que las use debería bajar el MSE de forma evidente.

Errores comunes

• Evaluar con los datos de entrenamiento: siempre sale bien y no dice nada del futuro.
• Incluir la etiqueta entre las características: el modelo copia la respuesta y la métrica se vuelve perfecta e inútil.
• Escalar antes de dividir: la media y la desviación del test se filtran al entrenamiento.
• Usar exactitud con clases desbalanceadas: si el 98 % no es fraude, un modelo que nunca detecta fraude acierta el 98 %.

Buenas prácticas

• Escribe la pregunta antes del código: qué predices, para qué y con qué error se considera útil.
• Fija random_state en cada división para poder repetir el experimento.
• Empieza con un baseline trivial: la media o la clase mayoritaria.
• Guarda el preprocesamiento en un Pipeline para que train y test reciban el mismo trato.
• No toques el test hasta el final; si lo miras diez veces, estarás eligiendo el modelo que mejor encaja con él.

Ejercicios

from sklearn.model_selection import train_test_split

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

print(len(X_train), len(X_test))

Soluciones explicadas

En el primer ejercicio importa la frontera, no el bucle: X contiene solo información disponible al decidir, e y contiene la decisión. Una columna como «marcado como spam por el usuario» sería una fuga, porque existe después de la decisión.

En el segundo, la validación sale del bloque de entrenamiento, no del test. Ese detalle explica por qué el test no se desgasta: se toca una vez. Con conjuntos pequeños una sola división es ruidosa; ahí conviene la validación cruzada.

Resumen

• Un modelo aprende una regla de ejemplos; generalizar es acertar en datos no vistos.
• X son las características e y la etiqueta: con n filas y d columnas, X mide (n, d).
• Supervisado usa etiquetas; regresión predice números y clasificación, categorías.
• El MSE castiga los errores grandes; el MAE es más robusto y está en las unidades de y.
• Divide antes de cualquier transformación y reserva el test para el informe final.
• Subajuste falla en ambos conjuntos; sobreajuste triunfa en entrenamiento y cae en prueba.

Evaluación