La misma regresión en scikit-learn

En 2007, un estudiante de doctorado llamado David Cournapeau empezó un proyecto de verano para añadir algoritmos de aprendizaje automático a Python. Lo llamó scikit-learn, y hoy es la librería que más gente usa en el mundo para construir modelos que predicen. Lo curioso es que no ganó por tener los mejores algoritmos: ganó por una decisión de diseño tan simple que parece obvia una vez la ves. Todos sus modelos, desde el más tonto hasta el más sofisticado, se usan con las dos mismas instrucciones: fit (aprende de estos datos) y predict (ahora dime qué pasa con estos otros). Esa uniformidad es la que te deja cambiar de un modelo a otro sin reaprender nada, y es la razón por la que vas a vivir dentro de sklearn durante el resto de tu formación en predicción. Pero antes de eso, hoy la vas a conocer con algo que ya dominas: la regresión lineal.

Has pasado todo el módulo en el oficio de explicar, con una herramienta pensada para eso. Ahora cruzas la frontera. Vas a ajustar exactamente la misma recta que ya sabes ajustar, sobre los mismos datos, pero con la herramienta del otro oficio. Y vas a comprobar dos cosas que juntas resumen todo el módulo: que el coeficiente sale idéntico al céntimo (porque la matemática de la recta es la misma), y que sklearn no te da ni p-valores ni intervalos de confianza (porque no le interesan: está hecha para acertar, no para explicar). Entender ese contraste de primera mano es lo que te deja listo para lo que viene.

## La forma de pensar de sklearn: fit y predict

statsmodels piensa como un investigador: le describes una relación con una fórmula ("precio en función de superficie") y te devuelve un informe lleno de incertidumbre, para que entiendas la relación. scikit-learn piensa como una máquina de acertar: le das unas entradas y una respuesta, le dices "aprende", y luego le das entradas nuevas y le dices "predice". No hay fórmula escrita en texto, no hay informe. Hay dos verbos: fit, que es cuando el modelo aprende de los datos que ya tienes, y predict, que es cuando le pides el valor de casos que todavía no conoce.

Esa separación entre aprender y predecir no es un capricho: es el corazón del oficio de predecir. Un modelo que explica se juzga sobre los datos con los que se construyó (¿son creíbles sus coeficientes?). Un modelo que predice se juzga sobre datos que NO vio al aprender (¿acierta en lo nuevo?). Tener dos verbos separados, uno para enseñarle y otro para examinarle, es lo que hace natural ese examen honesto: entrenas con unos datos y mides el acierto en otros. Lo verás en profundidad más adelante; por ahora quédate con que fit y predict son dos momentos distintos a propósito.

La uniformidad va más lejos de lo que parece, y conviene apreciarla ahora que la ves por primera vez con un modelo que ya entiendes. En sklearn, una regresión lineal, un árbol de decisión y un modelo sofisticado de los que verás más adelante se usan exactamente con el mismo código: construyes el objeto, llamas a fit con los datos, llamas a predict con casos nuevos. Cambiar de modelo es cambiar una palabra, el nombre de la clase, y nada más. Eso significa que todo lo que aprendas hoy sobre cómo se trabaja con sklearn (cómo se pasan los datos, cómo se separa entrenar de predecir, cómo se encadenan pasos) te va a servir para cualquier modelo que uses en el futuro. No estás aprendiendo la regresión en sklearn: estás aprendiendo sklearn, usando la regresión como excusa amable.

Y hay una pieza más de ese diseño que vas a usar sin parar: el escalado y la preparación de los datos también siguen el patrón fit/predict. Un objeto que normaliza los datos aprende, con fit, cuál es la media y la dispersión de tus datos de entrenamiento, y luego las aplica a datos nuevos. Esto, que parece un detalle, es la defensa principal contra la fuga de datos de la que tanto has oído hablar: si el escalador aprende solo del entrenamiento, nunca contamina sus cálculos con información del examen. La herramienta está construida para que lo correcto sea también lo cómodo, y por eso se la quiere tanto.

## La misma recta, en sklearn

Hay una diferencia práctica al pasar los datos. statsmodels aceptaba una fórmula de texto y un DataFrame. scikit-learn quiere los números crudos: una tabla de entradas (que por convención se llama X, en mayúscula, y es siempre bidimensional, aunque solo tengas una variable) y una lista de respuestas (que se llama y, en minúscula). Esa X bidimensional despista al principio: aunque tengas una sola variable, sklearn la quiere como una tabla de una columna, no como una lista plana. Es una convención para que el mismo código valga con una variable o con cien.

1import numpy as np
2import pandas as pd
3from sklearn.linear_model import LinearRegression
4
5# Viviendas: superficie en m2 y precio en euros
6rng = np.random.default_rng(21)
7n = 100
8superficie = rng.uniform(40, 150, n)
9precio = 20000 + 1500 * superficie + rng.normal(0, 15000, n)
10df = pd.DataFrame({"superficie": superficie, "precio": precio})
11
12# sklearn quiere X (tabla de entradas) e y (respuestas)
13X = df[["superficie"]].values   # doble corchete: tabla de UNA columna
14y = df["precio"].values
15
16modelo = LinearRegression().fit(X, y)   # aprende
17print(f"Coeficiente (euros por m2): {modelo.coef_[0]:.2f}")
18print(f"Origen: {modelo.intercept_:.2f}")

Esa X en mayúscula y esa y en minúscula no son un adorno: son una convención que vas a ver en todo el código de predicción que leas, y vale la pena entender por qué. La mayúscula de X indica que es una matriz, una tabla de dos dimensiones (filas que son casos, columnas que son variables), incluso cuando solo hay una columna. La minúscula de y indica que es un vector, una sola columna de respuestas. La distinción importa porque los modelos aceptan muchas variables de entrada (muchas columnas en X) pero predicen una sola cosa (una columna en y). Cuando veas ese código, lee X como "todo lo que sé de cada caso" e y como "lo que quiero adivinar".

## El momento revelador: el coeficiente coincide

Aquí viene la comprobación que lo aclara todo. Si ajustas la misma recta sobre los mismos datos con statsmodels y con sklearn, el coeficiente sale idéntico, hasta el último decimal. No es casualidad ni suerte: las dos librerías resuelven el mismo problema matemático (la recta que minimiza los errores al cuadrado), así que llegan al mismo número. La recta no sabe para qué oficio la quieres: es la misma línea pase lo que pase. Lo que cambia no es la recta, es lo que cada herramienta te cuenta sobre ella.

1import numpy as np
2import pandas as pd
3import statsmodels.formula.api as smf
4from sklearn.linear_model import LinearRegression
5
6rng = np.random.default_rng(21)
7n = 100
8superficie = rng.uniform(40, 150, n)
9precio = 20000 + 1500 * superficie + rng.normal(0, 15000, n)
10df = pd.DataFrame({"superficie": superficie, "precio": precio})
11
12# statsmodels: el oficio de explicar
13ms = smf.ols("precio ~ superficie", data=df).fit()
14print(f"statsmodels coef: {ms.params['superficie']:.2f}")
15ic = ms.conf_int().loc["superficie"]
16print(f"statsmodels IC 95%: [{ic[0]:.2f}, {ic[1]:.2f}]  <- esto SOLO lo da statsmodels")
17
18# sklearn: el oficio de predecir
19X = df[["superficie"]].values
20y = df["precio"].values
21lr = LinearRegression().fit(X, y)
22print(f"sklearn coef:     {lr.coef_[0]:.2f}  <- identico")

Que coincidan hasta el último decimal tiene una consecuencia tranquilizadora: no hay magia en ninguna de las dos librerías. La recta de mínimos cuadrados es un objeto matemático con una única solución, igual que la media de unos números es un único valor por mucho que la calcules con una calculadora o con los dedos. Cuando dos herramientas resuelven el mismo problema bien planteado, dan el mismo resultado. Si alguna vez te salen coeficientes distintos en statsmodels y sklearn para la misma regresión, no es que una esté "mejor afinada": es que no les estás pasando lo mismo (una tiene una variable extra, otra trata los datos de otra forma, una incluye el origen y la otra no). El resultado idéntico es el comportamiento normal, y la diferencia es la señal de que algo no cuadra.

## Qué ganas y qué pierdes

Si el coeficiente es el mismo, ¿por qué cambiar de herramienta? Porque cada una está optimizada para su oficio, y lo que ganas con sklearn no es un mejor coeficiente, es todo lo que viene después del coeficiente. Ganas el flujo fit/predict, que es idéntico para la regresión lineal y para los modelos más potentes que verás luego: aprender un modelo nuevo será aprender un nombre, no una forma distinta de trabajar. Ganas poder encadenar pasos (preparar los datos, escalarlos, modelarlos) en una tubería que se ajusta solo con los datos de entrenamiento, que es como se evita la fuga de datos de la que tanto se habla. Y ganas acceso al ecosistema entero de la predicción: validación, búsqueda de modelos, decenas de algoritmos, todos con los mismos dos verbos.

Lo que pierdes es justo lo que has usado todo el módulo: la inferencia de serie. sklearn no te da p-valores, ni intervalos de confianza de los coeficientes, ni un summary que interrogar. No es un olvido ni una carencia: es una decisión de diseño coherente con su oficio. Para predecir el precio de la siguiente casa, la incertidumbre del coeficiente de la superficie no sirve de nada; lo que sirve es el número para multiplicar. sklearn te da exactamente lo que el oficio de predecir necesita y nada más. Si lo que quieres es explicar, estás en la herramienta equivocada, y ningún truco la convierte en la correcta.

Es tentador pensar "pero si tengo el coeficiente, puedo calcularle yo el intervalo a mano". Técnicamente se puede, y hasta hay librerías que lo añaden por encima de sklearn. Pero esa tentación esconde el error de fondo: si lo que necesitas es la incertidumbre del coeficiente, es que estás haciendo el oficio de explicar, y para explicar ya existe una herramienta que te lo da todo bien calculado y de serie. Rehacer a mano lo que statsmodels te regala es trabajo extra y una fuente de errores. La regla sana no es "a sklearn le falta la inferencia", es "si necesitas inferencia, no estás en el problema de sklearn". Cada herramienta brilla en su oficio; forzarla en el ajeno es pelear contra su diseño.

Hay un matiz que conviene dejar claro para que no te lleves una idea equivocada: sklearn SÍ sabe medir cómo de bien predice, solo que lo mide de otra manera. Tiene formas de calcular el error en datos nuevos, de comparar modelos, de elegir el mejor. Lo que no tiene es la inferencia sobre los coeficientes individuales, que es una pregunta del oficio de explicar. Dicho de otro modo: sklearn te dice con toda precisión "este modelo acierta así de bien", pero no te dice "este coeficiente concreto es tan fiable". Lo primero es su especialidad; lo segundo no es su trabajo. No confundas "no da inferencia de coeficientes" con "no sabe evaluarse": sabe, y muy bien, a su manera.

## Por qué este puente, y no otro orden

Podrías preguntarte por qué has aprendido primero statsmodels y solo ahora conoces sklearn, cuando sklearn es la herramienta que más vas a usar de aquí en adelante. La respuesta es la misma que daba la primera lección del módulo, y ahora la entiendes de primera mano. Si hubieras empezado por sklearn, habrías aprendido que un modelo es una caja con dos botones (fit y predict) que escupe predicciones, y nadie te habría enseñado a interrogarlo, porque sklearn no invita a interrogar: invita a predecir. Habrías llegado al mundo de la predicción sin el reflejo de desconfiar de un coeficiente, de mirar los residuos, de preguntar si un efecto se distingue del cero.

Al venir de statsmodels, llegas a sklearn con ese reflejo ya puesto. Sabes que un número bonito puede ser mentira, sabes que un modelo que acierta no es un modelo que entiendes, y sabes que el acierto hay que medirlo en datos que el modelo no vio. Esa cabeza desconfiada es lo que distingue a quien usa sklearn con criterio de quien lo usa como una caja mágica. La herramienta es la misma para los dos; la diferencia la pones tú, y la pusiste en las cinco lecciones anteriores. Por eso el puente va en este sentido y no en el otro: primero se aprende a dudar, y luego se aprende a predecir.

## Dónde estás ahora

Has recorrido el oficio de explicar de punta a punta. Sabes distinguir cuándo quieres entender y cuándo quieres acertar. Sabes ajustar una recta y leerla como un efecto con su incertidumbre, no como una línea bonita. Sabes desconfiar de un coeficiente cuando dos variables compiten, y detectarlo con el VIF. Sabes pasar de la recta a la curva cuando el resultado es un sí o un no, y leer el odds ratio sin caer en su trampa. Y sabes que ningún summary se cree sin mirar antes los residuos. Todo eso es el trabajo de alguien que no se traga un modelo porque acierte: lo interroga primero.

Lo que viene ahora es la otra mitad. Hasta aquí has construido modelos para entenderlos; a partir de ahora vas a construir modelos para acertar, y la herramienta va a ser la que acabas de conocer. Cambiará la pregunta (de "¿cuánto, y cuánto me fío?" a "¿acierta en lo que no vio?"), cambiará cómo se valida (separando datos que el modelo no tocará) y cambiará lo que te juegas (ya no la credibilidad de un coeficiente, sino el acierto en el mundo real). Pero la desconfianza que has aprendido aquí viaja contigo: en el oficio de predecir, el adversario sigue siendo creerte tu propio resultado, solo que con trampas nuevas. Y a cazarlas vas con una ventaja que no todo el mundo tiene: aprendiste a interrogar un modelo antes de aprender a quererlo.