Regresion con Scikit Learn

import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
import seaborn as sns

import datetime

automobile_df = pd.read_csv('https://raw.githubusercontent.com/mwaskom/seaborn-data/master/mpg.csv')

# Ver 5 registros aleatorios
automobile_df.sample(5)

#Tamaño del dataset
automobile_df.shape 

automobile_df.info()

automobile_df['horsepower'].unique()

automobile_df['horsepower'].isna().sum()

automobile_df = automobile_df.dropna()

automobile_df.shape

automobile_df.drop(['origin', 'name'], axis='columns', inplace=True)

automobile_df.sample(5)

automobile_df.info()

automobile_df['model_year'] = '19' + automobile_df['model_year'].astype(str)

automobile_df.sample(5)

automobile_df['age'] = datetime.datetime.now().year - pd.to_numeric(automobile_df['model_year'])

automobile_df.drop(['model_year'], axis='columns', inplace=True)

automobile_df.sample(5)

automobile_df.dtypes

automobile_df['horsepower'] = pd.to_numeric(automobile_df['horsepower'], errors='coerce')

automobile_df.describe()

fig, ax = plt.subplots(figsize=(12, 8))

plt.scatter(automobile_df['age'], automobile_df['mpg'])

plt.xlabel('Años')
plt.ylabel('Millas por galon');

fig, ax = plt.subplots(figsize=(12, 8))

plt.scatter(automobile_df['acceleration'], automobile_df['mpg'])

plt.xlabel('Aceleracion')
plt.ylabel('Millas por galon');

fig, ax = plt.subplots(figsize=(12, 8))

plt.scatter(automobile_df['weight'], automobile_df['mpg'])

plt.xlabel('Peso')
plt.ylabel('Millas por galon');

fig, ax = plt.subplots(figsize=(12, 8))

plt.scatter(automobile_df['displacement'], automobile_df['mpg'])

plt.xlabel('Desplazamiento')
plt.ylabel('Millas por galon');

fig, ax = plt.subplots(figsize=(12, 8))

plt.scatter(automobile_df['horsepower'], automobile_df['mpg'])

plt.xlabel('Caballos de fuerza')
plt.ylabel('Millas por galon');

fig, ax = plt.subplots(figsize=(12, 8))

plt.scatter(automobile_df['cylinders'], automobile_df['mpg'])

plt.xlabel('Cilindros')
plt.ylabel('Millas por galon');

automobile_corr = automobile_df.corr()

automobile_corr

fig, ax = plt.subplots(figsize=(12, 10))

sns.heatmap(automobile_corr, annot=True);

automobile_df = automobile_df.sample(frac=1).reset_index(drop=True)

automobile_df.head()

automobile_df.to_csv('auto-mpg-processed.csv', index=False)

from sklearn.model_selection import train_test_split

X = automobile_df[['horsepower']]
Y = automobile_df['mpg']

x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2) #20%

x_train.sample(5)

from sklearn.linear_model import LinearRegression

linear_model = LinearRegression().fit(x_train, y_train)

print('Puntaje Entrenamiento: ', linear_model.score(x_train, y_train))

y_pred = linear_model.predict(x_test)

from sklearn.metrics import r2_score

print('Puntaje Testing: ', r2_score(y_test, y_pred))

from sklearn.metrics import PredictionErrorDisplay
PredictionErrorDisplay.from_predictions(y_true=y_test,
                                        y_pred=y_pred,
                                        kind="actual_vs_predicted");

PredictionErrorDisplay.from_predictions(y_true=y_test,
                                        y_pred=y_pred,
                                        kind="residual_vs_predicted");

fig, ax = plt.subplots(figsize=(12, 8))

plt.scatter(x_test, y_test)
plt.plot(x_test, y_pred, color='r')

plt.xlabel('Caballos de Fuerza')
plt.ylabel('Mpg')
plt.show()

X = automobile_df[['age']]
Y = automobile_df['mpg']

x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)

linear_model = LinearRegression().fit(x_train, y_train)

print('Puntaje de entrenamiento: ', linear_model.score(x_train, y_train))

y_pred = linear_model.predict(x_test)

print('Puntaje de Testing: ', r2_score(y_test, y_pred))

PredictionErrorDisplay.from_predictions(y_true=y_test,
                                        y_pred=y_pred,
                                        kind="actual_vs_predicted");

PredictionErrorDisplay.from_predictions(y_true=y_test,
                                        y_pred=y_pred,
                                        kind="residual_vs_predicted");

fig, ax = plt.subplots(figsize=(12, 8))

plt.scatter(x_test, y_test)
plt.plot(x_test, y_pred, color='r')

plt.xlabel('Age')
plt.ylabel('Mpg')
plt.show()

# X = automobile_df[['displacement', 'horsepower', 'weight', 'acceleration', 'cylinders']]

X = automobile_df[['displacement', 'horsepower', 'weight']]
Y = automobile_df['mpg']

x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)

linear_model = LinearRegression().fit(x_train, y_train)

print('Training score: ', linear_model.score(x_train, y_train))

predictors = x_train.columns
coef = pd.Series(linear_model.coef_, predictors).sort_values()

print(coef)

y_pred = linear_model.predict(x_test)

print('Puntaje Testing', r2_score(y_test, y_pred))

PredictionErrorDisplay.from_predictions(y_true=y_test,
                                        y_pred=y_pred,
                                        kind="actual_vs_predicted");

PredictionErrorDisplay.from_predictions(y_true=y_test,
                                        y_pred=y_pred,
                                        kind="residual_vs_predicted");

#import statsmodels.api as sm

from sklearn.model_selection import train_test_split
from sklearn.metrics import r2_score
from sklearn.preprocessing import StandardScaler

from sklearn.linear_model import LinearRegression
from sklearn.linear_model import Lasso
from sklearn.linear_model import Ridge
from sklearn.linear_model import ElasticNet
from sklearn.linear_model import Lars
from sklearn.linear_model import SGDRegressor
from sklearn.svm import SVR
from sklearn.neighbors import KNeighborsRegressor
from sklearn.tree import DecisionTreeRegressor

import warnings
warnings.filterwarnings("ignore")

automobile_df = pd.read_csv('auto-mpg-processed.csv')

automobile_df.head()

result_dict = {}

def entrenar_modelo(modelo,                
                    name_of_y_col: str, 
                    names_of_x_cols: list,
                    dataset: pd.DataFrame,
                    test_frac:float=0.2,
                  ):
    
    """entrenar_modelo
    
    Funcion para entrenar y evaluar un modelo
        
    """
    
    X = dataset[names_of_x_cols]
    Y = dataset[name_of_y_col]

    x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=test_frac)
    
    model = modelo.fit(x_train, y_train)
    
    y_pred = model.predict(x_test)
    
    print("Entrenamiento_score : " , model.score(x_train, y_train))
    print("Prueba_score : ", r2_score(y_test, y_pred))

    return {
            'Entrenamiento_score': model.score(x_train, y_train),
            'Prueba_score': r2_score(y_test, y_pred)
           }     

# Funcion para comparar los resultados de los modelos
#se van a almacenar en un diccionario
def compare_results():
    for key in result_dict:
        print('Regresion: ', key)
        print('Entrenamiento score', result_dict[key]['Entrenamiento_score'])
        print('Prueba score', result_dict[key]['Prueba_score'])
        print()

result_dict['mpg ~ single_linear'] = entrenar_modelo(LinearRegression(),
                                                     'mpg',
                                                     ['weight'],
                                                     automobile_df)

result_dict['mpg ~ kitchen_sink_linear'] = entrenar_modelo(LinearRegression(),
                                                      'mpg',
                                                     ['cylinders',
                                                      'displacement',
                                                      'horsepower',
                                                      'weight',
                                                      'acceleration'],
                                                      automobile_df)

result_dict['mpg ~ parsimonius_linear'] = entrenar_modelo(LinearRegression(),
                                                          'mpg',
                                                          ['horsepower',
                                                           'weight'],
                                                           automobile_df)

compare_results()

result_dict['mpg ~ kitchen_sink_lasso'] = entrenar_modelo(Lasso(alpha=0.5),
                                                          'mpg',
                                                         ['cylinders',
                                                          'displacement',
                                                          'horsepower',
                                                          'weight',
                                                          'acceleration'],
                                                           automobile_df)

compare_results()

result_dict['mpg ~ kitchen_sink_ridge'] = entrenar_modelo(Ridge(alpha=0.5),
                                                                 'mpg',
                                                                ['cylinders',
                                                                 'displacement',
                                                                 'horsepower',
                                                                 'weight',
                                                                 'acceleration'],
                                                                  automobile_df)

compare_results()

result_dict['mpg ~ kitchen_sink_elastic_net_ols'] = entrenar_modelo(ElasticNet(alpha=1, l1_ratio=0.5,
                                                                              max_iter= 100000, 
                                                                              warm_start= True),
                                                               'mpg',
                                                              ['cylinders',
                                                               'displacement',
                                                               'horsepower',
                                                               'weight',
                                                               'acceleration'],
                                                                automobile_df)

compare_results()

result_dict['mpg ~ kitchen_sink_svr'] = entrenar_modelo(SVR(kernel='linear',
                                                            epsilon=0.05,
                                                            C=0.3),
                                                    'mpg',
                                                   ['cylinders',
                                                    'displacement',
                                                    'horsepower',
                                                    'weight',
                                                    'acceleration'],
                                                     automobile_df)

compare_results()

result_dict['mpg ~ kitchen_sink_kneighbors'] = entrenar_modelo(KNeighborsRegressor(n_neighbors=10),
                                                                'mpg',
                                                               ['cylinders',
                                                                'displacement',
                                                                'horsepower',
                                                                'weight',
                                                                'acceleration'],
                                                                automobile_df)

compare_results()

# Este momdelo necesita qeu los datos esten standarizados para un buen desempeño

from sklearn.pipeline import Pipeline
SGDRegressor_pipe = Pipeline([('StandardScaler', StandardScaler()),
                              ('SGDRegressor', SGDRegressor(max_iter=10000,
                                                            tol=1e-3))
                             ])

result_dict['mpg ~ kitchen_sink_sgd'] = entrenar_modelo(SGDRegressor_pipe,
                                                   'mpg',
                                                  ['cylinders',
                                                   'displacement',
                                                   'horsepower',
                                                   'weight',
                                                   'acceleration'],
                                                    automobile_df)

compare_results()

result_dict['mpg ~ kitchen_sink_decision_tree'] = entrenar_modelo(DecisionTreeRegressor(max_depth=2),
                                                             'mpg',
                                                            ['cylinders',
                                                             'displacement',
                                                             'horsepower',
                                                             'weight',
                                                             'acceleration'],
                                                              automobile_df)

compare_results()

result_dict['mpg ~ kitchen_sink_lars'] = entrenar_modelo(Lars(n_nonzero_coefs=4),
                                                    'mpg',
                                                   ['cylinders',
                                                    'displacement',
                                                    'horsepower',
                                                    'weight',
                                                    'acceleration'],
                                                     automobile_df)

compare_results()

# Crear un diccionario solo con los resultados de prueba de cada modelo
nombre_modelos = result_dict.keys()
resultados_prueba = {} # crear diccionario vacio
for nombre in nombre_modelos:
    resultados_prueba[nombre] = result_dict[nombre]['Prueba_score']

plt.figure(figsize = (12,10)) # tamaño de la figura
plt.barh(range(len(resultados_prueba)), list(resultados_prueba.values()), 
        align='center', );
plt.title("Resultados en el dataset de pruebas de cada modelo")
plt.yticks(range(len(resultados_prueba)), list(resultados_prueba.keys()));

# lista para almacenar cada uno los modelos seleccionados para el cross validation
models = []

# Alamcenando los modelos como una tupla (nombre, modelo)
models.append(('kitchen_sink_linear',LinearRegression()))
models.append(('kitchen_sink_lasso',Lasso(alpha=0.5)))
models.append(('kitchen_sink_elastic_net',ElasticNet(alpha=1,
                                                     l1_ratio=0.5, 
                                                    max_iter= 100000, 
                                                    warm_start= True)))
models.append(('kitchen_sink_kneighbors',KNeighborsRegressor(n_neighbors=10)))
models.append(('kitchen_sink_decision_tree',DecisionTreeRegressor(max_depth=2)))
models.append(('kitchen_sink_svr',SVR(kernel='linear', epsilon=0.05, C=0.3)))

# Grabar los resultados de cada modelo
from sklearn import model_selection

#Semilla para obtener los mismos resultados de pruebas
seed = 2
results = []
names = []
scoring = 'r2'
for name, model in models:
    # Kfold cross validation for model selection
    kfold = model_selection.KFold(n_splits=5, shuffle=True, random_state=seed)
    #X train , y train
    cv_results = model_selection.cross_val_score(model, x_train, y_train, cv=kfold, scoring=scoring)
    results.append(cv_results)
    names.append(name)
    msg = f"({name}, {cv_results.mean()}, {cv_results.std()}"
    print(msg)

plt.figure(figsize = (15,8)) 
result_df = pd.DataFrame(results, index=names).T
result_df.boxplot()
plt.title("Resultados de Cross Validation");

from scipy.stats import f_oneway

model1 = result_df['kitchen_sink_linear']
model2 = result_df['kitchen_sink_lasso']
model3 = result_df['kitchen_sink_elastic_net']
model4 = result_df['kitchen_sink_kneighbors']
model5 = result_df['kitchen_sink_decision_tree']
model6 = result_df['kitchen_sink_svr']

statistic, p_value = f_oneway(model1, model2, model3, model4, model5, model6)

print(f'Statistic: {statistic}')
print(f'p_value: {p_value}')

alpha = 0.05  # nivel de significancia

if p_value < alpha:
    print("Existe una diferencia estadísticamente significativa en los resultados de cross-validation de los modelos.")
else:
    print("No Existe una diferencia estadísticamente significativa en los resultados de cross-validation de los modelos.")

from sklearn.metrics import r2_score
from sklearn.model_selection import GridSearchCV

import warnings
warnings.filterwarnings("ignore")

automobile_df = pd.read_csv('auto-mpg-processed.csv')

automobile_df.head()

X = automobile_df.drop(['mpg', 'age'], axis=1)

Y = automobile_df['mpg']

x_train, x_test, y_train, y_test = train_test_split(X, Y, test_size=0.2)

parameters = {'alpha': [0.2, 0.4, 0.6, 0.7, 0.8, 0.9, 1.0]}

grid_search = GridSearchCV(Lasso(), parameters, cv=3, return_train_score=True)
grid_search.fit(x_train, y_train)