Regresión Lineal

La regresión lineal es un modelo estadístico que se utiliza para predecir el valor de una variable continua (dependiente) basado en una o varias variables independientes. Es uno de los modelos mas simples, pero a su vez, poderoso para entender y predecir modelos lineales.

En librerias como scikit-learn, la regresión lineal se implementa en la clase LinearRegression.

example.py
1
2
3
4
5
6
7
8
9
10
11
12
13
import numpy as numpy
from sklearn.linear_model import LinearRegression
 
X = np.array([[1, 1], [1, 2], [2, 2], [2, 3]])
 
# y = 1 * x_0 + 2 * x_1 + 3
 
y = np.dot(X, np.array([1, 2])) + 3
reg = LinearRegression().fit(X, y)
reg.score(X, y) # 1.0
reg.coef_ # [1.0, 2.0]
reg.intercept_ # 3.0
reg.predict(np.array([[3, 5]])) # ([16.0])

Minerva también implementa la regresión lineal en la clase LinearRegression

Example.java
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
import com.minerva.core.primitives.Matrix;
import com.minerva.core.primitives.Vector;
import com.minerva.models.regression.impl.LinearRegression;
 
public class Main {
    public static void main(String[] args) {
 
        Matrix X = new Matrix(new double[][] {
                { 1.0, 1.0 },
                { 1.0, 2.0 },
                { 2.0, 2.0 },
                { 2.0, 3.0 }
        });
 
        Vector y = new Vector(new double[] { 6.0, 8.0, 9.0, 11.0 });
 
        LinearRegression model = new LinearRegression();
        model.fit(X, y);
 
 
        System.out.println("=== Parámetros Aprendidos ===");
        System.out.println("Intercept: " + model.getIntercept());
        System.out.println("Coeficientes: " + model.getCoefficients());
        
 
        Matrix XNueva = new Matrix(new double[][] {
                { 3.0, 5.0 }
        });
 
        Vector prediccion = model.predict(XNueva);
        System.out.println("\n=== Predicción ===");
        System.out.println("Entrada: x₀=3, x₁=5");
        System.out.println("Predicción: " + prediccion);
        System.out.println("Valor esperado: 16.0");
    }
}
java Main
=== Parámetros Aprendidos ===
Intercept: 3.0
Coeficientes: [1.0, 2.0]
=== Predicción ===
Entrada: x₀=3, x₁=5
Predicción: [16.0]
Valor esperado: 16.0

API Reference

Constructor

Example.java
1
LinearRegression model = new LinearRegression();

Métodos

fit(Matrix X, Vector y)

Entrena el modelo usando los datos proporcionados.

Example.java
1
model.fit(X, y);
ParámetroTipoDescripción
XMatrixMatriz de diseño (n_samples × n_features)
yVectorValores objetivo (n_samples)

predict(Matrix X)

Genera predicciones para nuevas muestras.

Example.java
1
Vector predictions = model.predict(XNew);
ParámetroTipoDescripción
XMatrixNuevas muestras (n_samples × n_features)

Retorna: Vector con las predicciones

getIntercept()

Retorna el término independiente (β0\beta_0).

Example.java
1
double intercept = model.getIntercept();  // ej: 3.0

getCoefficients()

Retorna los coeficientes para cada feature.

Example.java
1
Vector coefs = model.getCoefficients();  // ej: [1.0, 2.0]

getWeights()

Retorna todos los pesos combinados [intercept, coef₁, coef₂, ...].

Example.java
1
Vector weights = model.getWeights();  // ej: [3.0, 1.0, 2.0]

Manejo de Errores

ExcepciónCuándoCausa
IllegalArgumentExceptionfit()X.rows() != y.size()
ArithmeticExceptionfit()Columnas colineales
IllegalStateExceptionpredict()Modelo no entrenado

Casos de Uso

Regresión Simple (1 variable)

Example.java
1
2
3
4
5
6
7
8
9
10
Matrix X = new Matrix(new double[][] {
    {1.0}, {2.0}, {3.0}, {4.0}
});
Vector y = new Vector(new double[] {2.0, 4.0, 6.0, 8.0});
 
LinearRegression model = new LinearRegression();
model.fit(X, y);
 
System.out.println("Slope: " + model.getCoefficients());  // [2.0]
System.out.println("Intercept: " + model.getIntercept()); // 0.0

Múltiples Predicciones

Example.java
1
2
3
4
5
6
7
Matrix XTest = new Matrix(new double[][] {
    {5.0, 6.0},
    {7.0, 8.0},
    {9.0, 10.0}
});
 
Vector predictions = model.predict(XTest);

Integración con RegressionMetrics

Minerva proporciona métricas de regresión para evaluar el modelo:

  • MAE — Mean Absolute Error
  • MSE — Mean Squared Error
  • RMSE — Root Mean Squared Error
  • R² — Coeficiente de determinación
  • R² Ajustado — R² penalizado por número de features
Example.java
1
2
3
4
5
6
7
8
9
10
11
12
import com.minerva.metrics.RegressionMetrics.RegressionMetrics;
 
LinearRegression model = new LinearRegression();
model.fit(X, y);
Vector yPred = model.predict(X);
 
RegressionMetrics metrics = new RegressionMetrics();
double mae  = metrics.MAE(y, yPred);
double mse  = metrics.MSE(y, yPred);
double rmse = metrics.RMSE(y, yPred);
double r2   = metrics.R2(y, yPred);
double r2adj = metrics.R2adj(y, yPred, X.cols());