def linear_regression_summary(lr_type='LinearRegression', data=df):
# Define the input and output variables
X = data.iloc[:, :-1]
y = data.iloc[:, -1]
scaler = StandardScaler()
# Split the data into training and testing sets
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# Split the training data into training and validation sets
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.25, random_state=42)
# Apply StandardScaler Transformation
X_train_std = pd.DataFrame(scaler.fit_transform(X_train), columns=X_train.columns)
X_val_std = pd.DataFrame(scaler.transform(X_val), columns=X_val.columns)
X_test_std = pd.DataFrame(scaler.transform(X_test), columns=X_test.columns)
if lr_type in ['ridge', 'lasso']:
# Define the range of alpha values to test
alphas = [0.1, 0.5, 1, 5, 10] if lr_type == 'ridge' else [0.0001, 0.001, 0.01, 0.1, 0.5, 1]
# Initialize lists to store the results
train_scores = []
val_scores = []
# Loop through each alpha value
for alpha in alphas:
# Fit the Ridge regression model on the training data
if lr_type == 'ridge':
model = Ridge(alpha=alpha).fit(X_train_std, y_train)
else:
model = Lasso(alpha=alpha).fit(X_train_std, y_train)
# Predict on the training and validation data
y_train_pred = model.predict(X_train_std)
y_val_pred = model.predict(X_val_std)
# Calculate the mean squared error for the training and validation data
train_mse = mean_squared_error(y_train, y_train_pred)
val_mse = mean_squared_error(y_val, y_val_pred)
# Append the scores to the lists
train_scores.append(train_mse)
val_scores.append(val_mse)
# Find the best alpha value based on the validation scores
best_alpha = alphas[np.argmin(val_scores)]
# Fit the Ridge regression model on the training data using the best alpha value
if lr_type == 'ridge':
model = Ridge(alpha=best_alpha).fit(X_train_std, y_train)
elif lr_type == 'lasso':
model = Lasso(alpha=best_alpha).fit(X_train_std, y_train)
else:
model = LinearRegression().fit(X_train_std, y_train)
# Get metrics Training
metrics_train = get_metrics(y_train, model.predict(X_train_std), X.shape[1])
metrics_val = get_metrics(y_val, model.predict(X_val_std), X.shape[1])
metrics_test = get_metrics(y_test, model.predict(X_test_std), X.shape[1])
df_coef = pd.DataFrame(['Intercept'] + list(model.feature_names_in_), columns=['Predictors'])
df_coef['Weights'] = [model.intercept_.round(3)] + list(model.coef_.round(3))
df_coef['VIF'] = np.array([0] + [variance_inflation_factor(X_train_std.values, i) for i in range(X_train_std.shape[1])]).round(2)
print('-'*40)
print(f'Regression Model: {lr_type}')
if lr_type in ['ridge', 'lasso']:
print(f"Best alpha: {best_alpha}\n")
else:
print()
print('Train Data Metrics: ')
print(f"\tMAE: {metrics_train['mean_absolute_error']}\tRMSE: {metrics_train['rmse']}\tR2: {metrics_train['r2_score']}\tR2_adj: {metrics_train['adj_r2']}")
print('Validation Data Metrics: ')
print(f"\tMAE: {metrics_val['mean_absolute_error']}\tRMSE: {metrics_val['rmse']}\tR2: {metrics_val['r2_score']}\tR2_adj: {metrics_val['adj_r2']}")
print('Test Data Metrics: ')
print(f"\tMAE: {metrics_test['mean_absolute_error']}\tRMSE: {metrics_test['rmse']}\tR2: {metrics_test['r2_score']}\tR2_adj: {metrics_test['adj_r2']}\n")
print('Model Parameters: ')
print(df_coef)
print('-'*40)
y_train_pred = model.predict(X_train_std)
residuals = y_train-y_train_pred
print(f"Residuals Metrics \n\tMean: {np.array(residuals).mean():.2e} \tShapiroWilk_pval: {stats.shapiro(residuals)[1]:2e}")
fig = plt.figure()
ax1 = plt.subplot(2, 1, 1)
ax2 = plt.subplot(2, 1, 2)
sns.histplot(ax=ax1, x= residuals, kde=True)
ax1.set_xlabel('Residuals')
sns.scatterplot(ax=ax2, x=y_train_pred, y=residuals)
ax2.set_xlabel('Admit Chance Predicted (Training Data)')
ax2.set_ylabel('Residuals')
fig.suptitle('Check Normality of Residuals and Homoscedasticity')
# fig.set_size_inches((5, 5))
fig.tight_layout()
plt.plot()
return model, X_train_std, y_train, X_val_std, y_val, X_test_std, y_test
