Spaces:
Sleeping
Sleeping
import streamlit as st | |
import pandas as pd | |
import numpy as np | |
import matplotlib.pyplot as plt | |
from sklearn.model_selection import train_test_split | |
from sklearn.ensemble import GradientBoostingRegressor | |
from sklearn.ensemble import RandomForestRegressor, VotingRegressor | |
from sklearn.tree import DecisionTreeRegressor | |
from sklearn.linear_model import LinearRegression | |
from sklearn.neighbors import KNeighborsRegressor | |
from sklearn.svm import SVR | |
from sklearn.metrics import mean_squared_error, mean_absolute_error, r2_score | |
from sklearn.neural_network import MLPRegressor | |
from lightgbm import LGBMRegressor | |
from xgboost import XGBRegressor | |
import math | |
st.title('Liver Disease Prediction Application') | |
st.write(''' | |
Please fill in the attributes below, then hit the Predict button | |
to get your results. | |
''') | |
st.header('Input Attributes') | |
age = st.slider('Your Age (Years)', min_value=0.0, max_value=100.0, value=50.0, step=1.0) | |
st.write(''' ''') | |
gen = st.radio("Your Gender", ('Male', 'Female')) | |
st.write(''' ''') | |
tb = st.slider('Total Bilirubin (TB)', min_value=0.0, max_value=100.0, value=50.0, step=0.1) | |
st.write(''' ''') | |
db = st.slider('Direct Bilirubin (DB)', min_value=0.0, max_value=20.0, value=10.0, step=0.1) | |
st.write(''' ''') | |
aap = st.slider('Alkphos Alkaline Phosphotase', min_value=0.0, max_value=2400.0, value=1200.0, step=1.0) | |
st.write(''' ''') | |
sgpt = st.slider('SGPT Alamine Aminotransferase', min_value=0.0, max_value=2400.0, value=1200.0, step=1.0) | |
st.write(''' ''') | |
sgot = st.slider('SGOT Aspartate Aminotransferase', min_value=0.0, max_value=5000.0, value=2500.0, step=1.0) | |
st.write(''' ''') | |
tp = st.slider('Total Protiens (TP)', min_value=0.0, max_value=10.0, value=5.0, step=0.1) | |
st.write(''' ''') | |
alb = st.slider('ALB Albumin', min_value=-0.0, max_value=10.0, value=5.0, step=0.1) | |
st.write(''' ''') | |
ag = st.slider('A/G Ratio Albumin and Globulin Ratio', min_value=0.0, max_value=10.0, value=5.0, step=0.1) | |
st.write(''' ''') | |
selected_models = st.multiselect("Choose Regressor Models", ('Random Forest', | |
'Linear Regression', | |
'K-Nearest Neighbors', | |
'Decision Tree', | |
'Support Vector Machine', | |
'Gradient Boosting Regression', | |
'XGBoost Regression', | |
'LightGBM Regression')) | |
st.write(''' ''') | |
# Initialize an empty list to store the selected models | |
models_to_run = [] | |
# Check which models were selected and add them to the models_to_run list | |
if 'Random Forest' in selected_models: | |
models_to_run.append(RandomForestRegressor()) | |
if 'Linear Regression' in selected_models: | |
models_to_run.append(LinearRegression()) | |
if 'K-Nearest Neighbors' in selected_models: | |
models_to_run.append(KNeighborsRegressor()) | |
if 'Decision Tree' in selected_models: | |
models_to_run.append(DecisionTreeRegressor()) | |
if 'Support Vector Machine' in selected_models: | |
models_to_run.append(SVR()) | |
if 'Gradient Boosting Regression' in selected_models: | |
models_to_run.append(GradientBoostingRegressor()) | |
if 'XGBoost Regression' in selected_models: | |
models_to_run.append(XGBRegressor()) | |
if 'LightGBM Regression' in selected_models: | |
models_to_run.append(LGBMRegressor()) | |
if 'Neural Network (MLP) Regression' in selected_models: | |
models_to_run.append(MLPRegressor()) | |
# gender conversion | |
if gen == "Male": | |
gender = 1 | |
else: | |
gender = 0 | |
user_input = np.array([age, gender, tb, db, aap, sgpt, sgot, tp, | |
alb, ag]).reshape(1, -1) | |
# import dataset | |
def get_dataset(): | |
data = pd.read_csv('Liver.csv', encoding='unicode_escape') | |
# delete Nan value | |
data = data.dropna() | |
# Mapping 'Male' to 1 and 'Female' to 0 in the 'Gender of the patient' column | |
data['Gender of the patient'] = data['Gender of the patient'].map({'Male': 1, 'Female': 0}) | |
# No liver disease then:=0 for having liver disease then:=1 | |
data['Result'] = data['Result'].map({1: 1, 2: 0}) | |
return data | |
def generate_model_labels(model_names): | |
model_labels = [] | |
for name in model_names: | |
words = name.split() | |
if len(words) > 1: | |
# Multiple words, use initials | |
label = "".join(word[0] for word in words) | |
else: | |
# Single word, take the first 3 letters | |
label = name[:3] | |
model_labels.append(label) | |
return model_labels | |
if st.button('Submit'): | |
df = get_dataset() | |
# fix column names | |
df.columns = (["age", "gender", "tb", "db", "aap", | |
"sgpt", "sgot", "tp", "alb", | |
"ag", "result"]) | |
# Split the dataset into train and test | |
X = df.drop('result', axis=1) | |
y = df['result'] | |
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=1337) | |
# Create two columns to divide the screen | |
left_column, right_column = st.columns(2) | |
# Left column content | |
with left_column: | |
# Create a VotingRegressor with the selected models | |
ensemble = VotingRegressor( | |
estimators=[('rf', RandomForestRegressor()), ('xg', XGBRegressor()), ('dt', DecisionTreeRegressor())] | |
) | |
# Fit the voting regressor to the training data | |
ensemble.fit(X_train, y_train) | |
# Make predictions on the test set | |
ensemble_predictions = ensemble.predict(user_input) | |
# Evaluate the model's performance on the test set | |
ensemble_r2 = r2_score(y_test, ensemble.predict(X_test)) | |
ensemble_mse = mean_squared_error(y_test, ensemble.predict(X_test)) | |
ensemble_mae = mean_absolute_error(y_test, ensemble.predict(X_test)) | |
ensemble_rmse = np.sqrt(ensemble_mse) | |
st.write(f'According to Ensemble Model, Your Liver Disease Risk Score is: {ensemble_predictions[0]:.1f}') | |
st.write('Ensemble Model R-squared (R2) Score:', ensemble_r2) | |
st.write('Ensemble Model Root Mean Squared Error (RMSE):', ensemble_rmse) | |
st.write('Ensemble Model Mean Squared Error (MSE):', ensemble_mse) | |
st.write('Ensemble Model Mean Absolute Error (MAE):', ensemble_mae) | |
st.write('------------------------------------------------------------------------------------------------------') | |
# Right column content | |
with right_column: | |
# Initialize lists to store model names and their respective performance metrics | |
model_names = ['Ensemble'] | |
r2_scores = [ensemble_r2] | |
rmses = [ensemble_rmse] | |
mses = [ensemble_mse] | |
maes = [ensemble_mae] | |
for model in models_to_run: | |
# Train the selected model | |
model.fit(X_train, y_train) | |
# Make predictions on the test set | |
model_predictions = model.predict(user_input) | |
# Evaluate the model's performance on the test set | |
model_r2 = r2_score(y_test, model.predict(X_test)) | |
model_mse = mean_squared_error(y_test, model.predict(X_test)) | |
model_mae = mean_absolute_error(y_test, model.predict(X_test)) | |
model_rmse = np.sqrt(model_mse) | |
st.write(f'According to {type(model).__name__} Model, Your Liver Disease Risk Score is: {model_predictions[0]:.2f}') | |
st.write(f'{type(model).__name__} Model R-squared (R2) Score:', model_r2) | |
st.write(f'{type(model).__name__} Model Root Mean Squared Error (RMSE):', model_rmse) | |
st.write(f'{type(model).__name__} Model Mean Squared Error (MSE):', model_mse) | |
st.write(f'{type(model).__name__} Model Mean Absolute Error (MAE):', model_mae) | |
st.write('------------------------------------------------------------------------------------------------------') | |
# Append model metrics to lists | |
model_names.append(type(model).__name__) | |
r2_scores.append(model_r2) | |
rmses.append(model_rmse) | |
mses.append(model_mse) | |
maes.append(model_mae) | |
# Create a DataFrame to store the performance metrics | |
metrics_df = pd.DataFrame({ | |
'Model': model_names, | |
'R-squared (R2)': r2_scores, | |
'Root Mean Squared Error (RMSE)': rmses, | |
'Mean Squared Error (MSE)': mses, | |
'Mean Absolute Error (MAE)': maes | |
}) | |
# Get the model labels | |
model_labels = generate_model_labels(metrics_df['Model']) | |
# Plot the comparison graphs | |
plt.figure(figsize=(12, 10)) | |
# R-squared (R2) score comparison | |
plt.subplot(2, 2, 1) | |
plt.bar(model_labels, metrics_df['R-squared (R2)'], color='skyblue') | |
plt.title('R-squared (R2) Score Comparison') | |
plt.ylim(0, 1) | |
# Root Mean Squared Error (RMSE) comparison | |
plt.subplot(2, 2, 2) | |
plt.bar(model_labels, metrics_df['Root Mean Squared Error (RMSE)'], color='orange') | |
plt.title('Root Mean Squared Error (RMSE) Comparison') | |
# Mean Squared Error (MSE) comparison | |
plt.subplot(2, 2, 3) | |
plt.bar(model_labels, metrics_df['Mean Squared Error (MSE)'], color='green') | |
plt.title('Mean Squared Error (MSE) Comparison') | |
# Mean Absolute Error (MAE) comparison | |
plt.subplot(2, 2, 4) | |
plt.bar(model_labels, metrics_df['Mean Absolute Error (MAE)'], color='purple') | |
plt.title('Mean Absolute Error (MAE) Comparison') | |
# Adjust layout to prevent overlapping of titles | |
plt.tight_layout() | |
# Display the graphs in Streamlit | |
st.pyplot() | |