En el módulo 2 dejamos los datos entendidos y limpios. Ahora sí: entrenamos el primer modelo. Y no vamos a partir por lo más nuevo o lo más de moda, sino por los dos modelos que son la base de todo ML supervisado y que siguen resolviendo una enormidad de problemas reales en producción: la regresión lineal y la regresión logística. Son simples, rápidos y —su superpoder— interpretables: te dicen cuánto pesa cada variable en la decisión.

La tesis del módulo

La regresión lineal traza la recta que mejor pasa entre tus datos para predecir un número; la logística aprieta esa recta con la sigmoide para predecir una probabilidad y clasificar. Ambas aprenden lo mismo —cuánto pesa cada feature— y ambas te lo muestran en la cara. Empezar por acá no es empezar por lo fácil, es empezar por lo que entiendes.

Regresión lineal: predecir un número

La idea es la más intuitiva de todo el ML. Tienes puntos y quieres trazar la recta que mejor los atraviesa, para luego usarla y predecir. Con una sola variable de entrada, el modelo es la recta del colegio:

precio = w · metros + b

Donde w (el coeficiente o peso) es cuánto sube el precio por cada metro cuadrado extra, y b (el intercepto) es el punto de partida. Con varias variables (metros, dormitorios, comuna), cada una tiene su propio peso w, y el modelo suma todos los aportes. Nada más.

 precio
   │                              ●
   │                        ●   ╱
   │                    ●    ╱ ●
   │              ●    ╱  ●
   │         ●     ╱ ●
   │      ●    ╱ ●
   │    ● ╱ ●
   │  ╱ ●
   └──────────────────────────────►  metros
        la recta que mejor ajusta los puntos

El peso w es la pendiente de esa recta: qué tan inclinada va. El modelo busca los w y el b que dejan la recta lo más cerca posible de todos los puntos.

Regresión logística: clasificar

¿Y si la respuesta no es un número sino un sí/no? “¿Este cliente se va a ir?” no se responde con 320, sino con una probabilidad entre 0 y 1. El problema de una recta pura es que se dispara al infinito, y una probabilidad no puede pasar de 1 ni bajar de 0.

La solución de la regresión logística es tomar la recta de siempre y pasarla por la sigmoide: una función con forma de S que aplasta cualquier número al rango 0–1. Es la misma sigmoide que vimos en el módulo 2 de Redes Neuronales. El resultado se lee como probabilidad: si sale 0,82, el modelo cree que hay 82% de chance de que sea de la clase positiva. Luego un umbral (típicamente 0,5) decide la etiqueta final.

 prob
  1 │            ___________
    │         ╱
    │       ╱
0.5 │─────●─────  ◄── umbral de decisión
    │   ╱
    │ ╱
  0 │___________
    └───────────────────────►  recta (w·x + b)
       la sigmoide aplasta todo al rango 0 a 1

Ojo: el nombre engaña. La regresión logística no hace regresión: clasifica. Se llama así por la recta que lleva adentro, pero su salida es una categoría, no un número libre. Es el clasificador base de toda la industria.

Cómo se entrenan: pérdida y descenso de gradiente

¿Cómo encuentra el modelo los pesos correctos? Igual que una red neuronal, y por la misma mecánica que vimos en Cómo aprende una red: pérdida y descenso. En corto:

Se define una función de pérdida (loss): un número que mide qué tan mal predice el modelo. Para regresión lineal, típicamente el error cuadrático (cuánto se aleja la recta de los puntos).
Se ajustan los pesos poco a poco para que esa pérdida baje, usando descenso de gradiente (dar pasos en la dirección que más reduce el error).
Se repite hasta que la pérdida deja de bajar. Ahí el modelo “convergió”.

La buena noticia: con scikit-learn no programas nada de esto. El método fit lo hace por dentro. Pero saber que ahí abajo hay una pérdida que se minimiza te deja entender por qué a veces un modelo no aprende bien.

En código con scikit-learn

scikit-learn es la librería estándar de ML clásico en Python. Su gracia es que todos los modelos se usan igual: creas el modelo, llamas fit para entrenar y predict para predecir. Regresión lineal primero:

from sklearn.linear_model import LinearRegression

# X = features (columnas de entrada), y = lo que queremos predecir (el número)
modelo = LinearRegression()
modelo.fit(X_train, y_train)      # entrena: encuentra los pesos

pred = modelo.predict(X_test)     # predice números para datos nuevos

# Lo interpretable: cuánto pesa cada feature
print(modelo.coef_)               # un coeficiente w por columna
print(modelo.intercept_)          # el b (punto de partida)

Ahora regresión logística. Casi idéntico, pero con un método extra clave, predict_proba, que entrega la probabilidad en vez de solo la etiqueta:

from sklearn.linear_model import LogisticRegression

modelo = LogisticRegression(max_iter=1000)
modelo.fit(X_train, y_train)      # y_train aquí son categorías (0/1)

# La etiqueta final (0 o 1), ya aplicando el umbral 0.5
pred = modelo.predict(X_test)

# La probabilidad de cada clase: [prob_clase_0, prob_clase_1]
proba = modelo.predict_proba(X_test)

# Los coeficientes: cuánto empuja cada feature hacia la clase positiva
print(modelo.coef_)

Fíjate en el patrón fit / predict: es idéntico entre los dos modelos, y será idéntico para los árboles, el random forest y XGBoost de los próximos módulos. Aprendiste una API que vale para todo scikit-learn.

Lineal vs logística, lado a lado

	Regresión lineal	Regresión logística
Predice	Un número continuo	Una categoría (vía probabilidad)
Tarea	Regresión	Clasificación
Salida	Cualquier valor real	Probabilidad 0 a 1, luego etiqueta
Pieza clave	La recta	La recta + sigmoide
Método extra	—	`predict_proba`
Ejemplo	Precio de una casa	¿El cliente se va o no?

Escalar las features

Un detalle práctico que muerde a los principiantes: estos modelos son sensibles a la escala de las variables. Si “ingreso” va en millones y “edad” en decenas, el modelo puede darle importancia falsa a la de números grandes solo por su magnitud. La solución es escalar (llevar todas las features a un rango comparable) con StandardScaler:

from sklearn.preprocessing import StandardScaler

scaler = StandardScaler()
X_train_esc = scaler.fit_transform(X_train)   # aprende y transforma
X_test_esc = scaler.transform(X_test)         # solo transforma

Ojo: el scaler se ajusta (fit) solo con los datos de entrenamiento. Al test se le aplica el mismo ajuste con transform, nunca un fit nuevo. Ajustar con el test es filtrar información y engañarte a ti mismo. En el módulo 8 esto se automatiza con pipelines.

Errores comunes

Pensar que “regresión logística” predice números. No: clasifica. El nombre viene de la recta interna, pero su trabajo es decidir categorías.
No escalar las features. Sin escalar, la variable con números más grandes domina por magnitud, no por importancia real. Escala antes de entrenar.
Hacer fit del scaler con el test. El scaler aprende solo del train; al test se le aplica transform. Lo contrario es hacerse trampa.
Ignorar los coeficientes. Su gran ventaja sobre modelos más complejos es que coef_ te dice cuánto pesa cada feature. Desperdiciarlo es tirar la interpretabilidad a la basura.
Forzar una recta a datos curvos. Si la relación no es lineal, estos modelos rinden mal. Ahí entran los árboles y el boosting de los módulos siguientes.

La frase para llevarse

“La regresión lineal traza la mejor recta para predecir un número; la logística la aprieta con la sigmoide para clasificar. Y ambas te dicen, en la cara, cuánto pesa cada variable.”

Qué viene

Módulo 4: evaluar un modelo. Entrenar es fácil; saber si el modelo sirve de verdad es el oficio. Veremos por qué no puedes confiar en el accuracy de entrenamiento, qué son el train/test split y el overfitting, y las métricas que de verdad importan —precision, recall, F1, ROC-AUC— y por qué el accuracy engaña cuando las clases están desbalanceadas.

Machine Learning — Módulo 3: tu primer modelo — regresión lineal y logística