sync to remote

app.py

@@ -0,0 +1,322 @@
+import streamlit as st
+import pandas as pd
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import OneHotEncoder, StandardScaler
+from sklearn.impute import SimpleImputer
+from sklearn.linear_model import LogisticRegression
+from sklearn.naive_bayes import GaussianNB
+from sklearn.svm import SVC
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier
+from sklearn.neural_network import MLPClassifier
+from sklearn.metrics import confusion_matrix, classification_report
+import matplotlib.pyplot as plt
+import seaborn as sns
+from huggingface_hub import login
+from datasets import load_dataset
+import io
+from contextlib import redirect_stdout
+import os
+
+# Streamlit UI
+dataset_name = "louiecerv/diabetes_dataset"
+
+# Retrieve Hugging Face token from environment variable
+hf_token = os.getenv("HF_TOKEN")
+
+if not hf_token:
+    st.error("HF_TOKEN environment variable is not set. Please set it before running the app.")
+    st.stop()
+
+# Login to Hugging Face Hub
+login(token=hf_token)
+
+# Load dataset
+try:
+    with st.spinner("Loading dataset..."):
+        dataset = load_dataset(dataset_name)
+        st.success("Dataset loaded successfully.")
+except ValueError:
+    st.error("Dataset not found or incorrect dataset name. Please check the dataset identifier.")
+    st.stop()
+except PermissionError:
+    st.error("Authentication failed. Check if your Hugging Face token is correct.")
+    st.stop()
+except Exception as e:
+    st.error(f"Unexpected error: {e}")
+    st.stop()
+
+data = dataset["train"].to_pandas()
+
+# Set the title of the Streamlit app
+st.title("Diabetes Prediction App")
+
+with st.expander("About This App"):
+    st.markdown("""
+    ## Dataset Description
+
+    This app uses a dataset containing medical and lifestyle information about patients, 
+    along with their diabetes status (positive or negative). The goal is to predict 
+    whether a patient has diabetes based on their provided features.
+
+    The dataset includes the following features:
+
+    | Column          | Description                               | Type    |
+    |-----------------|-------------------------------------------|---------|
+    | gender          | The gender of the patient                 | Object  |
+    | age             | The age of the patient                    | Float   |
+    | hypertension    | Whether the patient has hypertension (1 for yes, 0 for no) | Integer |
+    | heart_disease   | Whether the patient has heart disease (1 for yes, 0 for no) | Integer |
+    | smoking_history | The smoking history of the patient        | Object  |
+    | bmi             | The body mass index of the patient        | Float   |
+    | HbA1c_level     | The HbA1c level of the patient            | Float   |
+    | blood_glucose_level | The blood glucose level of the patient  | Integer |
+    | diabetes        | Whether the patient has diabetes (1 for yes, 0 for no) | Integer |
+
+    ## Preprocessing Tasks
+
+    The following preprocessing steps were performed on the data:
+
+    *   **Handle Missing Values:** Missing values were checked and imputed using appropriate methods.
+    *   **Encode Categorical Features:** Categorical features (gender, smoking_history) were converted 
+        into numerical representations using one-hot encoding.
+    *   **Scale Numerical Features:** Numerical features (age, bmi, HbA1c_level, blood_glucose_level) 
+        were scaled to a standard range.
+    *   **Split Data:** The dataset was divided into training and testing sets.
+    *   **Handle Class Imbalance (if present):** Techniques like oversampling or undersampling were used if needed.
+
+    ## ML Model Recommendation
+
+    This app utilizes a machine learning model for binary classification.  Suitable models for this type of prediction include:
+
+    *   Logistic Regression
+    *   Support Vector Machines (SVM)
+    *   Decision Trees
+    *   Random Forest
+    *   Gradient Boosting Machines (GBM)
+
+    Created by Louie F. Cervantes, M.Eng. (Information Engineering)
+    """)
+
+# Display the dataset in a dataframe
+st.subheader("Dataset")
+st.write(data)
+
+# Show the statistics of the dataset
+st.subheader("Dataset Statistics")
+st.write(data.describe())
+
+# Visualizations of the data
+st.subheader("Data Visualizations")
+
+# Histogram of age
+st.write("Histogram of Age")
+fig, ax = plt.subplots()
+ax.hist(data['age'], bins=10)
+ax.set_xlabel('Age')
+ax.set_ylabel('Frequency')
+st.pyplot(fig)
+
+# Bar chart of gender
+st.write("Bar Chart of Gender")
+fig, ax = plt.subplots()
+ax.bar(data['gender'].value_counts().index, data['gender'].value_counts().values)
+ax.set_xlabel('Gender')
+ax.set_ylabel('Count')
+st.pyplot(fig)
+
+# Preprocessing
+st.subheader("Data Preprocessing")
+
+# Check for null values
+st.write("Null Values:")
+st.write(data.isnull().sum())
+
+# Handle null values
+imputer = SimpleImputer(strategy='mean')
+data['bmi'] = imputer.fit_transform(data[['bmi']])
+
+# Check for consistency of data types
+st.write("Data Types:")
+
+# Create a buffer to capture the output of df.info()
+buffer = io.StringIO()
+
+# Redirect the output of df.info() to the buffer
+with redirect_stdout(buffer):
+    data.info()
+
+# Get the captured output from the buffer
+info_string = buffer.getvalue()
+
+# Split the output string into lines
+lines = info_string.splitlines()
+
+# Extract column names and their data types
+columns = []
+cname = []
+counts = []
+nulls = []
+dtypes = []
+for line in lines[5:-2]:  # Skip header and footer lines
+    col_info = line.split()
+    columns.append(col_info[0])    
+    cname.append(col_info[1])
+    counts.append(col_info[2])
+    nulls.append(col_info[3])
+    dtypes.append(col_info[4])
+
+# Create a DataFrame
+info_df = pd.DataFrame({'Column': columns, 
+                        'Name': cname, 
+                        'Count': counts,
+                        'Null': nulls,
+                        'Data Type': dtypes})
+
+# Display the DataFrame in Streamlit
+st.dataframe(info_df)
+
+# Identify numeric and categorical data
+numeric_features = data.select_dtypes(include=['int64', 'float64']).columns
+categorical_features = data.select_dtypes(include=['object']).columns
+st.write("Numeric Features:", numeric_features)
+st.write("Categorical Features:", categorical_features)
+
+# One-hot encoding for categorical data
+encoder = OneHotEncoder(handle_unknown='ignore')
+encoded_data = encoder.fit_transform(data[categorical_features])
+encoded_df = pd.DataFrame(encoded_data.toarray())
+data = data.drop(categorical_features, axis=1)
+data = pd.concat([data, encoded_df], axis=1)
+
+# Split data into training and testing sets
+X = data.drop('diabetes', axis=1)
+y = data['diabetes']
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Redefine numeric_features after one-hot encoding and after dropping the target column
+numeric_features = X.select_dtypes(include=['int64', 'float64']).columns
+
+# Convert all column names to strings
+X_train.columns = X_train.columns.astype(str)
+X_test.columns = X_test.columns.astype(str)
+
+# Scale numeric features
+scaler = StandardScaler()
+
+# Save column names before scaling
+X_train_df = X_train  # Save as DataFrame before scaling
+X_test_df = X_test    # Save as DataFrame before scaling
+feature_names = X_train_df.columns  # Store feature names separately
+
+# Apply StandardScaler (returns a NumPy array)
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+# Convert back to DataFrame after scaling
+X_train = pd.DataFrame(X_train, columns=feature_names)
+X_test = pd.DataFrame(X_test, columns=feature_names)
+
+# Initialize session state for model training flag
+if 'models_trained' not in st.session_state:
+    st.session_state['models_trained'] = False
+
+# ML Models
+st.subheader("Machine Learning Models")
+
+# Initialize session state for models
+if 'models' not in st.session_state:
+    st.session_state['models'] = {
+        "Logistic Regression": LogisticRegression(),
+        "Naive Bayes": GaussianNB(),
+        "SVM": SVC(),
+        "Decision Tree": DecisionTreeClassifier(),
+        "Random Forest": RandomForestClassifier(),
+        "Gradient Boosting": GradientBoostingClassifier(),
+        "MLP Neural Network": MLPClassifier()
+    }
+
+# Create tabs for different models
+model_tabs = st.tabs(st.session_state['models'].keys())
+
+# Train the models and store them in session state
+if not st.session_state['models_trained']:
+    with st.spinner("Training Models..."):
+        for i, (model_name, model) in enumerate(st.session_state['models'].items()):
+            with model_tabs[i]:
+                st.write(model_name)
+                model.fit(X_train, y_train)
+                y_pred = model.predict(X_test)
+                st.write("Confusion Matrix:")
+                st.write(confusion_matrix(y_test, y_pred))
+                cr = classification_report(y_test, y_pred, output_dict=True)
+                # Display classification report as dataframe
+                cr_df = pd.DataFrame(cr).transpose()
+                st.write(f"Classification Report - {model_name}")
+                st.write(cr_df)                
+    st.session_state['models_trained'] = True
+
+# Diabetes Prediction
+st.subheader("Diabetes Prediction")
+
+# Select the trained model to use
+selected_model_name = st.selectbox("Select Trained Model", list(st.session_state['models'].keys()))
+selected_model = st.session_state['models'][selected_model_name]
+
+# Input Fields
+gender = st.selectbox("Gender", ["Female", "Male", "Other"])
+age = st.number_input("Age", min_value=0, max_value=120, value=30)
+hypertension = st.selectbox("Hypertension", ['0', '1'])
+heart_disease = st.selectbox("Heart Disease", ['0', '1'])
+smoking_history = st.selectbox("Smoking History", ['never', 'No Info', 'current', 'former', 'ever', 'not current'])
+bmi = st.number_input("BMI", min_value=0.0, value=25.0)
+hba1c_level = st.number_input("HbA1c Level", min_value=0.0, value=6.0)
+blood_glucose_level = st.number_input("Blood Glucose Level", min_value=0, value=100)
+
+if st.button("Predict Diabetes"):
+    # Create a DataFrame for the user input
+    input_data = pd.DataFrame({
+        'gender': [gender],
+        'age': [age],
+        'hypertension': [int(hypertension)],  # Convert categorical numerical features to int
+        'heart_disease': [int(heart_disease)],
+        'smoking_history': [smoking_history],
+        'bmi': [bmi],
+        'HbA1c_level': [hba1c_level],
+        'blood_glucose_level': [blood_glucose_level]
+    })
+
+    # Ensure encoding is applied correctly
+    encoded_input = encoder.transform(input_data[['gender', 'smoking_history']])
+    encoded_input_df = pd.DataFrame(encoded_input.toarray(), columns=encoder.get_feature_names_out())
+
+    # Drop the original categorical columns and concatenate the encoded features
+    input_data = input_data.drop(['gender', 'smoking_history'], axis=1)
+    input_data = pd.concat([input_data, encoded_input_df], axis=1)
+
+    # Ensure that the input data has the same columns as training data
+    missing_cols = set(X_train.columns) - set(input_data.columns)  # ✅ Corrected line
+    for col in missing_cols:
+        input_data[col] = 0  # Add missing columns with zero values
+
+    # Reorder columns to match training data
+    input_data = input_data.reindex(columns=X_train.columns, fill_value=0)
+
+    # Convert all column names to strings
+    input_data.columns = input_data.columns.astype(str)
+
+    # Scale the user input (convert back to DataFrame after transformation)
+    input_data_scaled = scaler.transform(input_data)
+    input_data_scaled = pd.DataFrame(input_data_scaled, columns=input_data.columns)  # Convert back to DataFrame
+
+    # Make prediction using the selected model
+    prediction = selected_model.predict(input_data_scaled)
+
+    # Display the prediction
+    st.write("Prediction:")
+    if prediction[0] == 0:
+        st.info("The model predicts that you do not have diabetes.")
+    else:
+        st.warning("The model predicts that you have diabetes.")
+    

requirements.txt

@@ -0,0 +1,7 @@
+streamlit
+pandas
+scikit-learn
+matplotlib
+seaborn
+datasets
+huggingface_hub