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() | |