import pandas as pd
df = pd.read_csv(
'https://archive.ics.uci.edu/ml/machine-learning-databases/housing/housing.data',
header=None, # especificamos que el dataset no tiene headers.
sep='\s+') # especificamos que la separacion esta hecha por espacios y no por comas.
df.columns = ["CRIM","ZN","INDUS" , "CHAS" ,"NOX","RM" ,"AGE","DIS", "RAD","TAX", "PTRATIO", "B" , "LSTAT" , "MEDV"]
df.head()
import seaborn as sns
import matplotlib.pyplot as plt
# Configuramos la apariencia de los graficos
sns.set(style='whitegrid', context='notebook')
# Seleccionamos los features que mas nos interesa para ver la correlacion entre las variables
cols = ["DIS", "INDUS", "CRIM", "RM","MEDV"]
# Graficamos con un pairplot las variables de interes para ver sus relaciones
sns.pairplot(df[cols], height=1.75);
sns.heatmap(
data=df[cols].corr(),
cbar=True, annot=True, yticklabels=cols, xticklabels=cols)
# Guardamos los datos de interes en una variable x e y
x = df['RM'].values.reshape(-1,1) # variable independiente
y = df['MEDV'].values.reshape(-1,1) # variable dependiente
from sklearn.preprocessing import StandardScaler
# instanciamos el modelo de escalamiento
sc_x = StandardScaler()
sc_y = StandardScaler()
# estandarizamos los datos z=(x-u)/std
x_standard = sc_x.fit_transform(x)
y_standard = sc_y.fit_transform(y)
from sklearn.linear_model import LinearRegression
# Instanciamos y ajustamos el modelo de regresión lineal
slr = LinearRegression() # Standar Linear Regression (slr)
slr.fit(x_standard,y_standard)
# Graficamos los datos estandarizados
plt.scatter(x_standard, y_standard)
# Graficamos la linea de regresion ajustada
plt.plot(x_standard, slr.predict(x_standard), color='red')
plt.xlabel("Promedio de habitaciones (RM)")
plt.ylabel("Mediana del precio de las casas x1000 (MEDV)")
import numpy as np
# Representamos el numero de habitaciones de la casa que queremos predecir
num_habitaciones = 5
# Estandarizamos sc_x para predecir el predio de la casa
num_habitaciones_standard = sc_x.transform(np.array([num_habitaciones]).reshape(-1,1))
# Usamos la transformada inversa en el resultado para volver a la escala original
result = sc_y.inverse_transform(slr.predict(num_habitaciones_standard))
print("El precio de una casa con 5 habitaciones en Boston es de", result*1000)
import numpy as np
# Se definen los datos de entrada
x=np.array([1.2, 2,3.2,2.5,5,6,4,8])
y=np.array([2,3,3.4,3.1,4,4.7,3.8,7])
# Se calcula el tamaño del conjunto de datos
n = len(x)
# Se calculan las sumas de los productos de los elementos de x e y, x^2, y las sumas de los elementos de x e y
xy = np.sum((x*y),axis=0)
x_2 = np.sum((x**2), axis=0)
sum_x = np.sum(x, axis=0)
sum_y = np.sum(y, axis=0)
# Se define la función para calcular la pendiente de la recta de regresión lineal
def m():
numerador = (n*xy) - (sum_x * sum_y)
denominador = (n*x_2) - (sum_x)**2
return np.divide(numerador,denominador)
# Se calcula la pendiente m
m = m()
# Se define la función para calcular la intercepción de la recta de regresión lineal
def b():
numerador = sum_y - (m * sum_x)
denominador = n
return np.divide(numerador, denominador)
# Se calcula la intercepción b
b = b()
# Se define la función para calcular la predicción y' utilizando la recta de regresión lineal
def f():
return (m*x)+b
# Se calcula la predicción y'
y_prima = f()
# Se calcula la suma de las predicciones y'
sum_y_prima = np.sum(y_prima, axis=0)
# Se define la función para calcular el MSE
def MSE():
return (1/n) * np.sum((y - y_prima)**2, axis=0)
# Se calcula el MSE
mse = MSE()
plt.plot(x,y_prima)
plt.scatter(x,y)
df_mse = pd.DataFrame.from_dict({
"x" :x,
"y" :y,
"y_prima" :y_prima,
"xy" :xy,
"x_2" :x_2,
"sum_x" :sum_x,
"sum_y" :sum_y,
"m" :m,
"b" :b,
"mse" :mse
},)
df_mse
sns.heatmap(
data=df[cols].corr(),
cbar=True, annot=True, yticklabels=cols, xticklabels=cols)
# StandardScaler acepta arreglos de 2 dimensiones por lo cual ya no usamos el reshape(-1,1) con la variable independiente (X)
X = df[['RM', 'INDUS']].values
y = df['MEDV'].values.reshape(-1,1)
from sklearn.preprocessing import StandardScaler
sc_x = StandardScaler()
sc_y = StandardScaler()
X_standard = sc_x.fit_transform(X)
y_standard = sc_y.fit_transform(y)
from sklearn.linear_model import LinearRegression
slr = LinearRegression()
slr.fit(X_standard,y_standard)
import numpy as np
# definir el rango de valores para la variable predictiva "RM"
x1_range = np.arange(
df['RM'].min(),
df['RM'].max())
# definir el rango de valores para la variable predictiva "INDUS"
x2_range = np.arange(
df['INDUS'].min(),
df['INDUS'].max())
# crear una malla de puntos que cubra los rangos de valores de ambas variables predictoras
X1, X2 = np.meshgrid(x1_range, x2_range)
# crear un dataframe con todas las combinaciones posibles de valores de ambas variables predictoras
plano = pd.DataFrame(
{
'RM':X1.ravel(),
'INDUS':X2.ravel()
})
plano.T
# utilizar los coeficientes y la intercepción del modelo de regresión lineal múltiple ajustado para hacer predicciones en el plano creado
pred = slr.predict(plano).reshape(X1.shape)
# escalar las predicciones inversamente utilizando el objeto sc_y para obtener los valores reales de la variable de respuesta "MEDV"
pred = sc_y.inverse_transform(pred)
import plotly.express as px
import plotly.graph_objects as go
# PLOTTING
mesh_size = .02
margin = 0
fig = px.scatter_3d(df, x='RM', y='INDUS', z='MEDV')
fig.update_traces(marker=dict(size=5))
fig.add_traces(go.Surface(x=X1, y=X2, z=pred, name='pred_surface'))
fig.show()
!pip install setuptools==58 # para que no haya conflictos con la libreria regressors
!pip install regressors
import pandas as pd
import seaborn as sns
import numpy as np
import matplotlib.pyplot as plt
sns.set(style='whitegrid', context='notebook')
df = pd.read_csv('./insurance.csv')
df.head().append(df.tail())
print(df.shape)
df.charges.hist(bins =40)
from scipy import stats
z = np.abs(stats.zscore(df.charges))
df[z>3]
df = df[z<3]
df
sns.pairplot(df, hue='smoker', height=3.5);
df_dummy = pd.get_dummies(df, columns=['sex','smoker','region'],drop_first=True)
df_dummy_corr = df_dummy.corr()
plt.figure(figsize=(18,2))
sns.heatmap(df_dummy_corr.iloc[3:4,:],annot=True);
from sklearn.preprocessing import StandardScaler # se utilizará para estandarizar los datos numéricos y la librería
from sklearn.linear_model import LinearRegression # para crear el modelo de regresión lineal. Además, se importa la librería
from sklearn.model_selection import train_test_split # para dividir los datos en conjuntos de entrenamiento y prueba.
# Seleccionamos las variables predictoras (todas excepto la variable objetivo)
X_cols = list(set(df_dummy.columns)-set(['charges']))
# Seleccionamos la variable objetivo
y_col = ['charges']
# Separamos los datos en conjuntos de entrenamiento y prueba
X = df_dummy[X_cols].values
y = df_dummy[y_col].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
# Estandarizamos las variables predictoras y objetivo en ambos conjuntos
sc_x = StandardScaler()
X_train = sc_x.fit_transform(X_train)
X_test = sc_x.transform(X_test)
sc_y = StandardScaler()
y_train = sc_y.fit_transform(y_train)
y_test = sc_y.transform(y_test)
# Creamos y entrenamos el modelo de regresión lineal
model = LinearRegression()
model.fit(X_train, y_train)
# Realizamos predicciones sobre el conjunto de prueba utilizando nuestro modelo entrenado
y_pred = model.predict(X_test)
y_pred.shape
from sklearn.metrics import mean_absolute_error, mean_squared_error, r2_score
print('MAE:', mean_absolute_error(y_test, y_pred).round(4))
print('MSE:', mean_squared_error(y_test, y_pred).round(4))
print('R^2:', r2_score(y_test, y_pred).round(4))
from regressors import stats
model.intercept_ = model.intercept_[0]
model.coef_ = model.coef_.reshape(-1)
y_test = y_test.reshape(-1)
print('='*16,'Summary','='*16)
stats.summary(model, X_test, y_test, X_cols)
residuals = np.subtract(y_test, y_pred.reshape(-1))
plt.scatter(y_pred, residuals)
plt.axhline(0,0,color='red')
plt.xlabel('Valores predichos ')
plt.ylabel('Residuos')
plt.plot();
df_second = df_dummy.copy(deep=True)
df_second['age2'] = df_second.age ** 2
df_second['sobrepeso'] = (df_second.bmi >= 30).astype(int)
df_second['sobrepeso_fumador'] = df_second.sobrepeso * df_second.smoker_yes
plt.figure(figsize=(15,1.5))
sns.heatmap(df_second.corr().iloc[3:4,:],annot=True)
# Seleccionamos las variables predictoras (todas excepto la variable objetivo)
X_cols = list(set(df_second.columns)-set(['charges']))
# Seleccionamos la variable objetivo
y_col = ['charges']
# Separamos los datos en conjuntos de entrenamiento y prueba
X = df_second[X_cols].values
y = df_second[y_col].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
# Estandarizamos las variables predictoras y objetivo en ambos conjuntos
sc_x = StandardScaler()
X_train = sc_x.fit_transform(X_train)
X_test = sc_x.transform(X_test)
sc_y = StandardScaler()
y_train = sc_y.fit_transform(y_train)
y_test = sc_y.transform(y_test)
# Creamos y entrenamos el modelo de regresión lineal
model = LinearRegression()
model.fit(X_train, y_train)
# Realizamos predicciones sobre el conjunto de prueba utilizando nuestro modelo entrenado
y_pred = model.predict(X_test)
print('MAE:', mean_absolute_error(y_test, y_pred).round(4))
print('MSE:', mean_squared_error(y_test, y_pred).round(4))
print('R^2:', r2_score(y_test, y_pred).round(4))
model.intercept_ = model.intercept_[0]
model.coef_ = model.coef_.reshape(-1)
y_test = y_test.reshape(-1)
print('='*16,'Summary','='*16)
stats.summary(model, X_test, y_test, X_cols)
residuals = np.subtract(y_test, y_pred.reshape(-1))
plt.scatter(y_pred, residuals)
plt.axhline(0,0,color='red')
plt.axhline(0.25,0,color='green')
plt.axhline(-0.25,0,color='green')
plt.xlabel('Valores predichos ')
plt.ylabel('Residuos')
plt.plot();
# Seleccionamos las variables predictoras (todas excepto la variable objetivo)
X_cols = ['sobrepeso_fumador','smoker_yes','children','age2']
# Seleccionamos la variable objetivo
y_col = ['charges']
# Separamos los datos en conjuntos de entrenamiento y prueba
X = df_second[X_cols].values
y = df_second[y_col].values
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.25, random_state=42)
# Estandarizamos las variables predictoras y objetivo en ambos conjuntos
sc_x = StandardScaler()
X_train = sc_x.fit_transform(X_train)
X_test = sc_x.transform(X_test)
sc_y = StandardScaler()
y_train = sc_y.fit_transform(y_train)
y_test = sc_y.transform(y_test)
# Creamos y entrenamos el modelo de regresión lineal
model = LinearRegression(fit_intercept=False)
model.fit(X_train, y_train)
# Realizamos predicciones sobre el conjunto de prueba utilizando nuestro modelo entrenado
y_pred = model.predict(X_test)
print('MAE:', mean_absolute_error(y_test, y_pred).round(4))
print('MSE:', mean_squared_error(y_test, y_pred).round(4))
print('R^2:', r2_score(y_test, y_pred).round(4))
# model.intercept_ = model.intercept_[0]
model.coef_ = model.coef_.reshape(-1)
y_test = y_test.reshape(-1)
print('='*16,'Summary','='*16)
stats.summary(model, X_test, y_test, X_cols)
residuals = np.subtract(y_test, y_pred.reshape(-1))
plt.scatter(y_pred, residuals)
plt.axhline(0,0,color='red')
plt.axhline(0.25,0,color='green')
plt.axhline(-0.25,0,color='green')
plt.xlabel('Valores predichos ')
plt.ylabel('Residuos')
plt.plot();