wp

app.py

@@ -0,0 +1,160 @@
+import streamlit as st
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+import os
+from sklearn.model_selection import train_test_split, cross_val_score
+from sklearn.preprocessing import StandardScaler
+from sklearn.ensemble import RandomForestClassifier, GradientBoostingClassifier, AdaBoostClassifier, ExtraTreesClassifier
+from sklearn.linear_model import LogisticRegression
+from sklearn.svm import SVC
+from sklearn.tree import DecisionTreeClassifier
+from sklearn.neighbors import KNeighborsClassifier
+from sklearn.naive_bayes import GaussianNB
+from sklearn.metrics import accuracy_score
+from imblearn.over_sampling import SMOTE
+import joblib
+import time
+
+# Load dataset
+@st.cache_data
+def load_data():
+    df = pd.read_csv("water_potability.csv")
+    return df
+
+df = load_data()
+
+# Data Cleaning
+st.title("Water Potability Prediction(Supervised)")
+st.write("This is a supervised machine learning application to predict water potability based on various variables. Note that the accuracy level of the models may not be ideal for practical usage. The essence is to demonstrate the performance comparison of different machine learning models on a particular dataset. To achieve better accuracy, further data preprocessing, feature engineering, hyperparameter tuning, etc., need to be performed.")
+st.subheader("Dataset Overview")
+st.write("Original Dataset:")
+st.write(df.head())
+
+df.fillna(df.median(), inplace=True)
+st.write("Dataset after handling missing values:")
+st.write(df.head())
+
+# Data Visualization
+st.subheader("Data Visualization")
+fig, ax = plt.subplots(figsize=(10, 5))
+sns.heatmap(df.corr(), annot=True, cmap='coolwarm', ax=ax)
+st.pyplot(fig)
+
+# Feature Importance Analysis
+X = df.drop("Potability", axis=1)
+y = df["Potability"]
+
+# Handle class imbalance
+smote = SMOTE()
+X, y = smote.fit_resample(X, y)
+
+# Train-test split
+X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
+
+# Feature scaling
+scaler = StandardScaler()
+X_train = scaler.fit_transform(X_train)
+X_test = scaler.transform(X_test)
+
+# Define models
+models = {
+    "Logistic Regression": LogisticRegression(),
+    "Random Forest": RandomForestClassifier(n_estimators=200, max_depth=20),
+    "SVM": SVC(kernel='rbf', C=1, probability=True),
+    "Decision Tree": DecisionTreeClassifier(max_depth=10),
+    "KNN": KNeighborsClassifier(n_neighbors=5),
+    "Naive Bayes": GaussianNB(),
+    "Gradient Boosting": GradientBoostingClassifier(n_estimators=100, learning_rate=0.1),
+    "AdaBoost": AdaBoostClassifier(n_estimators=100),
+    "Extra Trees": ExtraTreesClassifier(n_estimators=150)
+}
+
+st.subheader("Model Performance with Cross-Validation")
+results = {}
+loading_status = st.empty()
+
+# File names for persistence
+model_filename = "best_model.pkl"
+model_name_filename = "best_model_name.txt"
+model_accuracy_filename = "best_model_accuracy.txt"
+all_model_accuracies_filename = "all_model_accuracies.txt"
+
+if os.path.exists(model_filename) and os.path.exists(model_name_filename) and os.path.exists(model_accuracy_filename):
+    with open(model_name_filename, "r") as f:
+        best_model_name = f.read().strip()
+    with open(model_accuracy_filename, "r") as f:
+        best_model_accuracy = float(f.read().strip())
+    st.success(f"Best model ({best_model_name}) already exists. Skipping training.")
+
+    # Display saved model accuracies
+    if os.path.exists(all_model_accuracies_filename):
+        st.subheader("Saved Model Accuracies")
+        with open(all_model_accuracies_filename, "r") as f:
+            saved_accuracies = f.read()
+        st.text(saved_accuracies)
+else:
+    loading_status.text("Training models...")
+    time.sleep(1)  # Simulate loading time
+    with open(all_model_accuracies_filename, "w") as f:
+        for name, model in models.items():
+            scores = cross_val_score(model, X_train, y_train, cv=5)
+            accuracy = scores.mean()
+            results[name] = accuracy
+            st.write(f"{name}: Accuracy = {accuracy:.2f}")
+            f.write(f"{name}: {accuracy:.2f}\n")
+
+    # Select and train the best model
+    best_model_name = max(results, key=results.get)
+    best_model_accuracy = results[best_model_name]
+    best_model = models[best_model_name]
+    best_model.fit(X_train, y_train)
+    joblib.dump(best_model, model_filename)
+    with open(model_name_filename, "w") as f:
+        f.write(best_model_name)
+    with open(model_accuracy_filename, "w") as f:
+        f.write(str(best_model_accuracy))
+    st.success(f"Best Model: {best_model_name} trained and saved!")
+
+# Model Testing with User Input
+st.subheader("Test the Model")
+st.write("Tips: Based on the data correlation heatmap ph, hardness, and sulfate has a higher relation to each other. (POTABLE = lower ph || higher hardness || higher sulfate)")
+user_input = {}
+
+for col in X.columns:
+    # Persist user input values across interactions
+    if col not in st.session_state:
+        st.session_state[col] = float(X[col].mean())
+
+    user_input[col] = st.number_input(
+        f"{col}",
+        float(X[col].min()),
+        float(X[col].max()),
+        st.session_state[col],
+        key=col
+    )
+
+# Prediction button
+if st.button("Predict Water Potability"):
+    loading_status.text("Testing model...")
+
+    # Load best model
+    model = joblib.load(model_filename)
+
+    with open(model_name_filename, "r") as f:
+        best_model_name = f.read().strip()
+    with open(model_accuracy_filename, "r") as f:
+        best_model_accuracy = float(f.read().strip())
+
+    # Convert user input to DataFrame
+    input_df = pd.DataFrame([user_input])
+    input_df = scaler.transform(input_df)  # Apply scaling
+
+    # Predict
+    prediction = model.predict(input_df)[0]
+    label = "Potable" if prediction == 1 else "Not Potable"
+
+    # Display results
+    st.write(f"Predicted Potability: {label}")
+    st.write(f"Model Used in Prediction: {best_model_name} (Accuracy: {best_model_accuracy:.2f})")
+    loading_status.text("")

requirements.txt

@@ -0,0 +1,8 @@
+streamlit
+pandas
+numpy
+matplotlib
+seaborn
+scikit-learn
+joblib
+imblearn