Implementación de Ridge Regression from Scratch usando Python

requisitos previos:

Regresión lineal
Descenso de gradiente

Introducción:
La Regresión Ridge (o Regularización L2) es una variación de la Regresión Lineal. En Regresión lineal, minimiza la Suma residual de cuadrados (o RSS o función de costo) para adaptarse a los ejemplos de entrenamiento lo más perfectamente posible. La función de costo también está representada por J.

Función de costo para regresión lineal:

$\frac{1}{m} \sum_{i=1}^{m}\left(y^{(i)}-h\left(x^{(i)}\right)\right)^{2}$

Aquí, representa la función hipotética para la predicción. representa el valor de la variable de destino para el i-ésimo ejemplo. es el número total de ejemplos de entrenamiento en el conjunto de datos dado.h(x⁽ⁱ⁾)y⁽ⁱ⁾
m

La regresión lineal trata todas las características por igual y encuentra pesos imparciales para minimizar la función de costo. Esto podría plantear el problema del sobreajuste (o un modelo no funciona bien con nuevos datos). La regresión lineal tampoco puede manejar los datos colineales (la colinealidad se refiere al evento cuando las características están altamente correlacionadas). En resumen, la Regresión Lineal es un modelo con alta varianza. Entonces, Ridge Regression viene al rescate. En Ridge Regression, hay una penalización adicional de l2 (cuadrado de la magnitud de los pesos) en la función de costo de Regresión lineal. Esto se hace para que el modelo no sobreajuste los datos. La función de costo modificada para la regresión de Ridge se da a continuación:

$\frac{1}{m}\left[\sum_{i=1}^{m}\left(y^{(i)}-h\left(x^{(i)}\right)\right)^{2}+\lambda \sum_{j=1}^{n} w_{j}^{2}\right]$

Aquí, representa el peso de la j-ésima característica. es el número de características en el conjunto de datos.w_j
n

Intuición matemática:
durante la optimización del descenso de gradiente de su función de costo, l2el término de penalización adicional lleva a reducir los pesos del modelo a cero o cerca de cero. Debido a la penalización de los pesos, nuestra hipótesis se vuelve más simple, más generalizada y menos propensa al sobreajuste. Todos los pesos se reducen por el mismo factor lambda. Podemos controlar la fuerza de la regularización mediante el hiperparámetro lambda.

Diferentes casos para ajustar valores de lambda.

Si lambda se establece en 0, la regresión de cresta es igual a la regresión lineal
Si lambda se establece en infinito, todos los pesos se reducen a cero.

Entonces, deberíamos establecer lambda en algún lugar entre 0 e infinito.

Implementación desde cero:
el conjunto de datos utilizado en esta implementación se puede descargar desde el enlace
Tiene 2 columnas: » Años de experiencia » y » Salario » para 30 empleados en una empresa. Entonces, en esto, entrenaremos un modelo de regresión de Ridge para conocer la correlación entre la cantidad de años de experiencia de cada empleado y su salario respectivo. Una vez entrenado el modelo, podremos predecir el salario de un empleado en base a sus años de experiencia.

Código:

# Importing libraries
  
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
import matplotlib.pyplot as plt
  
# Ridge Regression
  
class RidgeRegression() :
      
    def __init__( self, learning_rate, iterations, l2_penality ) :
          
        self.learning_rate = learning_rate        
        self.iterations = iterations        
        self.l2_penality = l2_penality
          
    # Function for model training            
    def fit( self, X, Y ) :
          
        # no_of_training_examples, no_of_features        
        self.m, self.n = X.shape
          
        # weight initialization        
        self.W = np.zeros( self.n )
          
        self.b = 0        
        self.X = X        
        self.Y = Y
          
        # gradient descent learning
                  
        for i in range( self.iterations ) :            
            self.update_weights()            
        return self
      
    # Helper function to update weights in gradient descent
      
    def update_weights( self ) :           
        Y_pred = self.predict( self.X )
          
        # calculate gradients      
        dW = ( - ( 2 * ( self.X.T ).dot( self.Y - Y_pred ) ) +               
               ( 2 * self.l2_penality * self.W ) ) / self.m     
        db = - 2 * np.sum( self.Y - Y_pred ) / self.m 
          
        # update weights    
        self.W = self.W - self.learning_rate * dW    
        self.b = self.b - self.learning_rate * db        
        return self
      
    # Hypothetical function  h( x ) 
    def predict( self, X ) :    
        return X.dot( self.W ) + self.b
      
# Driver code
  
def main() :
      
    # Importing dataset    
    df = pd.read_csv( "salary_data.csv" )
    X = df.iloc[:, :-1].values
    Y = df.iloc[:, 1].values    
  
    # Splitting dataset into train and test set
    X_train, X_test, Y_train, Y_test = train_test_split( X, Y, 
                                            
                                          test_size = 1 / 3, random_state = 0 )
      
    # Model training    
    model = RidgeRegression( iterations = 1000,                             
                            learning_rate = 0.01, l2_penality = 1 )
    model.fit( X_train, Y_train )
      
    # Prediction on test set
    Y_pred = model.predict( X_test )    
    print( "Predicted values ", np.round( Y_pred[:3], 2 ) )     
    print( "Real values      ", Y_test[:3] )    
    print( "Trained W        ", round( model.W[0], 2 ) )    
    print( "Trained b        ", round( model.b, 2 ) )
      
    # Visualization on test set     
    plt.scatter( X_test, Y_test, color = 'blue' )    
    plt.plot( X_test, Y_pred, color = 'orange' )    
    plt.title( 'Salary vs Experience' )    
    plt.xlabel( 'Years of Experience' )    
    plt.ylabel( 'Salary' )    
    plt.show()
      
if __name__ == "__main__" : 
    main()

Producción:

Predicted values  [ 40831.44 122898.14  65078.42]
Real values       [ 37731 122391  57081]
Trained W         9325.76
Trained b         26842.8

Visualización

Nota:
La regresión de cresta conduce a una reducción de la dimensionalidad, lo que la convierte en un modelo computacionalmente eficiente.

Publicación traducida automáticamente

Artículo escrito por mohit baliyan y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta Cancelar la respuesta