<jupyter_start><jupyter_text>Ejemplo de regresión lineal con regularización 1. DelitosPredecir el número de crímenes violentos a partir de un conjunto de aspectos poblacionales: porcentaje de la población considerada urbana y el ingreso familiar medio, y la participación de las fuerzas del orden público, como el número per cápita de agentes de policía y el porcentaje de agentes asignados a las unidades de drogas, etc.https://archive.ics.uci.edu/ml/datasets/Communities+and+Crime<jupyter_code>import pandas as pd
import utilis

import matplotlib.pyplot as plt
from matplotlib import style
import seaborn as sns

from sklearn.model_selection import train_test_split
from sklearn.metrics import mean_squared_error
from sklearn.linear_model import LinearRegression, Ridge, Lasso, RidgeCV, LassoCV, ElasticNetCV
from sklearn.preprocessing import StandardScaler
from sklearn.datasets import make_regression
from sklearn.preprocessing import PolynomialFeatures
from sklearn.linear_model import LogisticRegression, LogisticRegressionCV

plt.rcParams['image.cmap'] = "bwr"
plt.rcParams['savefig.bbox'] = "tight"
style.use('ggplot') or plt.style.use('ggplot')


import warnings
warnings.filterwarnings('ignore')<jupyter_output><empty_output><jupyter_text>Conjunto de datosSe tiene 122 variables explicativas y una variable respuesta **crímenes violentos**.<jupyter_code># descargamos los datos
url = 'http://archive.ics.uci.edu/ml/machine-learning-databases/communities/communities.data'
crime = pd.read_csv(url, header=None, na_values=['?'])
crime.head()
# eliminamos los primeras 5 columnas informativas, y los valores faltantess
crime.drop([0, 1, 2, 3, 4], axis=1, inplace=True)
crime.dropna(inplace=True)
# define X and y
X = crime.drop(127, axis=1)
y = crime[127]
X.shape
y.shape
# matriz de correlacion
corr_matrix = np.corrcoef(X.T)
# mapa de calor
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6, 6))
sns.heatmap(corr_matrix, square=True, ax=ax)
ax.set_title("Matriz de correlación")
plt.show()<jupyter_output><empty_output><jupyter_text>Muchas de las variables están altamente correlacionadas (correlación absoluta $> 0.8$), lo que supone un problema a la hora de emplear modelos de regresión lineal.  Modelación<jupyter_code># division de los datos en train y test
X_train, X_test, y_train, y_test = train_test_split(X, y, train_size=0.7, random_state=19970808)<jupyter_output><empty_output><jupyter_text>Mínimos cuadrados (OLS)<jupyter_code># ajustamos el modelo
reg = LinearRegression(normalize=True)
reg.fit(X = X_train, y = y_train)

# creamos el dataframe de coefficientes
rmse_ols = graficar_coeficientes_y_rmse(reg, "Regresion")<jupyter_output>El error (rmse) de test es: 0.30798558936771414<jupyter_text>RigdeBusqueda de nuestro hiperparametro de regularización.<jupyter_code>rigde = RidgeCV(alphas=np.logspace(-4, 2, 200), fit_intercept=True, normalize=True, store_cv_values=True)

_ = rigde.fit(X = X_train, y = y_train)
alphas = rigde.alphas
coefs = []

for alpha in alphas:
    modelo_temp = Ridge(alpha=alpha, fit_intercept=False, normalize=True)
    modelo_temp.fit(X_train, y_train)
    coefs.append(modelo_temp.coef_)

fig, ax = plt.subplots(figsize=(12, 4.5))
ax.plot(alphas, coefs)
ax.set_xscale('log')
ax.set_xlabel('alpha')
ax.set_ylabel('coeficientes')
ax.set_title('Coeficientes del modelo en función de la regularización Ridge');
plt.axis('tight')
plt.show()
graficar_rmse_evolucion(rigde, "Ridge")
print(f"Mejor valor de alpha encontrado: {rigde.alpha_}")

rmse_ridge = graficar_coeficientes_y_rmse(rigde, "Ridge")<jupyter_output>Mejor valor de alpha encontrado: 0.33700643292719284
El error (rmse) de test es: 0.17746209028303883<jupyter_text>LASSO<jupyter_code>?np.logspace
lasso = LassoCV(alphas=np.logspace(-4, 1, 200), normalize=True, cv = 10)
_ = lasso.fit(X = X_train, y = y_train)
alphas = lasso.alphas_
coefs = []
n_predictores = []

for alpha in alphas:
    modelo_temp = Lasso(alpha=alpha, fit_intercept=False, normalize=True)
    modelo_temp.fit(X_train, y_train)
    coefs.append(modelo_temp.coef_)
    coef_no_cero = np.sum(modelo_temp.coef_!= 0)
    n_predictores.append(coef_no_cero)

fig, ax = plt.subplots(figsize=(12, 4.5))
ax.plot(alphas, coefs)
ax.set_xscale('log')
ax.set_xlabel('alpha')
ax.set_ylabel('coeficientes')
ax.set_title('Coeficientes del modelo en función de la regularización LASSO');
fig, ax = plt.subplots(figsize=(12, 4.5))
ax.plot(alphas, n_predictores)
ax.set_xscale('log')
ax.set_xlabel('alpha')
ax.set_ylabel('nº predictores')
ax.set_title('Predictores incluidos en función de la regularización');
graficar_rmse_evolucion(lasso, "LASSO")

print(f"Mejor valor de alpha encontrado: {lasso.alpha_}")
rmse_lasso = graficar_coeficientes_y_rmse(lasso, "Lasso")<jupyter_output>El error (rmse) de test es: 0.16563275654685422<jupyter_text>Elastic Net<jupyter_code>elas_net = ElasticNetCV(l1_ratio=[0, 0.1, 0.5, 0.7, 0.9, 0.95, 0.99], alphas=np.logspace(-10, 3, 200),
                        normalize=True, cv=10, n_jobs=-1)
_ = elas_net.fit(X = X_train, y = y_train)
print(f"Mejor valor de alpha encontrado: {elas_net.alpha_}")
print(f"Mejor valor de l1_ratio encontrado: {elas_net.l1_ratio_}")
rmse_elastic = graficar_coeficientes_y_rmse(elas_net, "Elastic net")<jupyter_output>El error (rmse) de test es: 0.17631549076778055<jupyter_text>Comparación de los errores<jupyter_code>df_comparacion = pd.DataFrame({
                    'modelo': ['OLS', 'Ridge', 'Lasso', "Elastic_net"],
                    'test rmse': [rmse_ols, rmse_ridge, rmse_lasso, rmse_elastic]
                 })

fig, ax = plt.subplots(figsize=(12, 5))
df_comparacion.set_index('modelo').plot(kind='barh', ax=ax)
ax.set_xlabel('rmse')
ax.set_ylabel('modelo')
ax.set_title('Comparación de modelos');<jupyter_output><empty_output><jupyter_text>2. Contenido de grasa en carne El departamento de calidad de una empresa de alimentación se encarga de medir el contenido en grasa de la carne que comercializa. Este estudio se realiza mediante técnicas de analítica química, un proceso relativamente costoso en tiempo y recursos. Una alternativa que permitiría reducir costes y optimizar tiempo es emplear un espectrofotómetro (instrumento capaz de detectar la absorbancia que tiene un material a diferentes tipos de luz en función de sus características) e inferir el contenido en grasa a partir de sus medidas.Antes de dar por válida esta nueva técnica, la empresa necesita comprobar qué margen de error tiene respecto al análisis químico. Para ello, se mide el espectro de absorbancia a 100 longitudes de onda en 215 muestras de carne, cuyo contenido en grasa se obtiene también por análisis químico, y se entrena un modelo con el objetivo de predecir el contenido en grasa a partir de los valores dados por el espectrofotómetro.<jupyter_code>datos = pd.read_csv('data/meatspec.csv')
datos = datos.drop(columns = datos.columns[0])
datos.info()

X = datos.drop(columns='fat')
y = datos['fat']
# matriz de correlacion
corr_matrix = np.corrcoef(X.T)

# mapa de calor
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(10, 10))
sns.heatmap(corr_matrix, square=True, ax=ax)
ax.set_title("Matriz de correlación")
plt.show()
# modificamos los algunos datos
col_prueba = ["V{}".format(i) for i in range(80,100)]
X[col_prueba]= X[col_prueba]*10000
## partimos el conjunto de datos
X_train, X_test, y_train, y_test = train_test_split(X, y.values.reshape(-1,1), train_size=0.7, random_state=19970808)
# ajustamos los modelos
# Regresión lineal
reg = LinearRegression(normalize=False)
reg.fit(X = X_train, y = y_train)
predicciones = reg.predict(X=X_test)
rmse_ols = mean_squared_error(y_true=y_test, y_pred=predicciones, squared=False)

# LASSO
lasso = LassoCV(alphas=np.logspace(-7, 3, 200), normalize=False, cv = 10, n_jobs=-1)
_ = lasso.fit(X = X_train, y = y_train)
predicciones = lasso.predict(X=X_test)
rmse_lasso = mean_squared_error(y_true=y_test, y_pred=predicciones, squared=False)

# Ridge
rigde = RidgeCV(alphas=np.logspace(-7, 2, 200), fit_intercept=True, normalize=False, store_cv_values=True)
_ = rigde.fit(X = X_train, y = y_train)
predicciones = rigde.predict(X=X_test)
rmse_ridge = mean_squared_error(y_true=y_test, y_pred=predicciones, squared=False)

# Elastic net
elas_net = ElasticNetCV(l1_ratio=[0, 0.1, 0.5, 0.7, 0.9, 0.95, 0.99], alphas=np.logspace(-10, 3, 200),
                        normalize=True, cv=10, n_jobs=-1)
_ = elas_net.fit(X = X_train, y = y_train)
predicciones = elas_net.predict(X=X_test)
rmse_elas_net = mean_squared_error(y_true=y_test, y_pred=predicciones, squared=False)
df_comparacion = pd.DataFrame({
                    'modelo': ['OLS', 'Ridge', 'Lasso', "Elastic_net"],
                    'test_rmse': [rmse_ols, rmse_ridge, rmse_lasso, rmse_elas_net],
                    'data': ["original", "original", "original", "original"]
                 })

fig, ax = plt.subplots(figsize=(12, 5))
df_comparacion.set_index('modelo').plot(kind='barh', ax=ax)
ax.set_xlabel('rmse')
ax.set_ylabel('modelo')
ax.set_title('Comparación de modelos');
# ajustamos los modelos
# estandarizamos.
std = StandardScaler()
X_train = std.fit_transform(X_train)
X_test = std.transform(X_test)

# Regresión lineal
reg = LinearRegression(normalize=False)
reg.fit(X = X_train, y = y_train)
predicciones = reg.predict(X=X_test)
rmse_ols = mean_squared_error(y_true=y_test, y_pred=predicciones, squared=False)

# LASSO
lasso = LassoCV(alphas=np.logspace(-1, 3, 200), normalize=False, cv = 10, n_jobs=-1)
_ = lasso.fit(X = X_train, y = y_train)
predicciones = lasso.predict(X=X_test)
rmse_lasso = mean_squared_error(y_true=y_test, y_pred=predicciones, squared=False)

# Ridge
rigde = RidgeCV(alphas=np.logspace(-7, 2, 200), fit_intercept=True, normalize=False, store_cv_values=True)
_ = rigde.fit(X = X_train, y = y_train)
predicciones = rigde.predict(X=X_test)
rmse_ridge = mean_squared_error(y_true=y_test, y_pred=predicciones, squared=False)

# Elastic net
elas_net = ElasticNetCV(l1_ratio=[0, 0.1, 0.5, 0.7, 0.9, 0.95, 0.99], alphas=np.logspace(-10, 3, 200),
                        normalize=True, cv=10, n_jobs=-1)
_ = elas_net.fit(X = X_train, y = y_train)
predicciones = elas_net.predict(X=X_test)
rmse_elas_net = mean_squared_error(y_true=y_test, y_pred=predicciones, squared=False)
df_comparacion2 = pd.DataFrame({
                    'modelo': ['OLS', 'Ridge', 'Lasso', "Elastic_net"],
                    'test_rmse': [rmse_ols, rmse_ridge, rmse_lasso, rmse_elas_net],
                    "data": ["estandarizado", "estandarizado", "estandarizado", "estandarizado"]
                 })


df_comparacion_new = pd.concat([df_comparacion, df_comparacion2])

fig, ax = plt.subplots(figsize=(12, 5))
ax = sns.barplot(x="modelo", y="test_rmse", hue="data", data=df_comparacion_new)
variables = ["V{}".format(i) for i in range(X.shape[1])]
# creamos un dataframe con los coeficientes
df_coeficientes = pd.DataFrame({'predictor': variables, 'coef': lasso.coef_})
df_coeficientes2 = pd.DataFrame({'predictor': variables, 'coef': rigde.coef_[0]})
df_coeficientes3 = pd.DataFrame({'predictor': variables, 'coef': reg.coef_[0]})

# graficamos los coeficientes
fig, ax = plt.subplots(nrows=3, figsize=(13, 4.5))
fig.subplots_adjust(left=0, right=1, bottom=0, top=1, hspace=.5, wspace=2)

ax[0].stem(df_coeficientes.predictor, df_coeficientes.coef, markerfmt=' ')    
ax[0].set_xticks([])
ax[0].set_xlabel(' ')
ax[0].set_ylabel('coeficientes')
ax[0].set_title('Coeficientes del modelo de {}'.format("LASSO"))

ax[1].stem(df_coeficientes2.predictor, df_coeficientes2.coef, markerfmt=' ')    
ax[1].set_xticks([])
ax[1].set_xlabel(' ')
ax[1].set_ylabel('coeficientes')
ax[1].set_title('Coeficientes del modelo de {}'.format("Ridge"))

ax[2].stem(df_coeficientes3.predictor, df_coeficientes3.coef, markerfmt=' ')    
plt.xticks(rotation=90, ha='right', size=10)
ax[2].set_xlabel('variable')
ax[2].set_ylabel('coeficientes')
ax[2].set_title('Coeficientes del modelo de {}'.format("Regresion Lineal"))
plt.show()
sum(lasso.coef_!=0)
sum(rigde.coef_[0]!=0)
sum(reg.coef_[0]!=0)<jupyter_output><empty_output>
{'fraction_non_alphanumeric': 0.12810294728102947, 'fraction_numerical': 0.028393524283935243, 'mean_word_length': 5.844318181818182, 'pattern_counts': {'":': 1, '<': 33, '<?xml version=': 0, '>': 34, 'https://': 1, 'lorem ipsum': 0, 'www.': 0, 'xml': 0}, 'pii_count': 0, 'substrings_counts': 0, 'word_list_counts': {'cursed_substrings.json': 0, 'profanity_word_list.json': 0, 'sexual_word_list.json': 0, 'zh_pornsignals.json': 0}}
{'chain_length': '9', 'dir': 'jupyter-structured-clean-dedup', 'id': '186793', 'license': 'MIT', 'n_tokens_mistral': 4944, 'n_tokens_neox': 4705, 'n_words': 999, 'path': '2do_semestre/Ciencia_de_datos/Proyecto_final/example_regularized_linear_regression.ipynb', 'repo_name': 'Enriquesec/Maestria_Computo_Estadistico_CIMAT', 'size': '12045'}