File size: 10,058 Bytes
50099c1 a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 923683e a15635f 2e432dd a15635f 5f242a8 a15635f 2e432dd a15635f 50099c1 a15635f 50099c1 a15635f 50099c1 a15635f 50099c1 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 | from tab_extra import add_extra_tabs
import pandas as pd
import numpy as np
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
from sklearn.model_selection import train_test_split
#load dataset
data = pd.read_csv("waterQuality1.csv")
#CHECK FOR MISSING VALUES
for col in data.columns:
print(col, data[col].unique()[:10])
#CHCK FOR OBJECT COLUMNS
print(data.info())
#preprocessing (convert object colums into float, and !NUM value to mean)
data.replace(['#NUM!', '?', '', 'NA', 'NULL'], np.nan, inplace=True)
data = data.apply(pd.to_numeric, errors='coerce')
data = data.fillna(data.mean())
#separating input and target columns
X = data.drop('is_safe', axis=1)
y_safe = data['is_safe']
#Normalization
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
#K means implementation
inertia = []
K_range = range(1, 10)
#for optimal k
for k in K_range:
kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
kmeans.fit(X_scaled)
inertia.append(kmeans.inertia_)
optimal_k = 4
#train by setting k
kmeans = KMeans(n_clusters=optimal_k, random_state=42, n_init=10)
clusters = kmeans.fit_predict(X_scaled)
#add extra column of cluster and anomaly into dataset
data['cluster'] = clusters
#train-test split
X_train, X_test, y_train, y_test = train_test_split(
X, y_safe, test_size=0.2, random_state=42
)
#mean of each cluster
cluster_summary = data.groupby('cluster').mean()
print("\nCluster Summary:")
print(cluster_summary[['is_safe']])
#presentation of each cluster with label
ranked_clusters = cluster_summary['is_safe'].sort_values().index.tolist()
labels = [
"Heavily contaminated group",
"Contaminated group",
"Borderline group",
"Clean water group"
]
cluster_label_map = dict(zip(ranked_clusters, labels))
# Apply labels
data['cluster_label'] = data['cluster'].map(cluster_label_map)
print("\nCluster Counts (Numeric + Label):")
print(data.groupby(['cluster', 'cluster_label']).size())
print("\nFirst 10 rows:")
print(data[['cluster', 'cluster_label']].head(10))
# Preparing Data for ANN
X_scaled_df = pd.DataFrame(X_scaled, columns=X.columns)
X_scaled_df['cluster'] = clusters
# Convert y_safe to integer type for classification
y_safe_int = y_safe.astype(int)
# Split the data into training and testing sets for the ANN
X_train_ann, X_test_ann, y_train_ann, y_test_ann = train_test_split(
X_scaled_df, y_safe_int, test_size=0.2, random_state=42
)
print("Shape of X_train_ann:", X_train_ann.shape)
print("Shape of X_test_ann:", X_test_ann.shape)
print("Shape of y_train_ann:", y_train_ann.shape)
print("Shape of y_test_ann:", y_test_ann.shape)
# Artificial Neural Network (ANN) Implementation
from sklearn.neural_network import MLPClassifier
from sklearn.metrics import accuracy_score, classification_report
# Initialize the MLPClassifier (ANN)
mlp = MLPClassifier(
hidden_layer_sizes=(100, 50), # Two hidden layers with 100 and 50 neurons respectively
max_iter=500, # Maximum number of iterations for the solver to converge
activation='relu', # Rectified Linear Unit activation function
solver='adam', # Adam optimizer
random_state=42, # For reproducibility
verbose=True # To see the training progress
)
# Train the ANN
mlp.fit(X_train_ann, y_train_ann)
# Make predictions on the test set
y_pred_ann = mlp.predict(X_test_ann)
# Evaluate the ANN
print("\nANN Accuracy:", accuracy_score(y_test_ann, y_pred_ann))
print("\nANN Classification Report:\n", classification_report(y_test_ann, y_pred_ann))
# Gradio Implementation
import gradio as gr
# The column order is important for consistent input to the model
feature_columns = X.columns.tolist()
def predict_water_safety(*args):
# Create a DataFrame from the input arguments, ensuring correct column order
input_data = pd.DataFrame([args], columns=feature_columns)
# Scale the input features using the already fitted scaler
input_scaled = scaler.transform(input_data)
# Predict the cluster for the input data
predicted_cluster = kmeans.predict(input_scaled)[0]
# Convert the scaled input to a DataFrame and add the cluster ID
input_scaled_df = pd.DataFrame(input_scaled, columns=feature_columns)
input_scaled_df['cluster'] = predicted_cluster
# Make prediction using the trained ANN
ann_prediction = mlp.predict(input_scaled_df)[0]
ann_proba = mlp.predict_proba(input_scaled_df)[0]
# Get the cluster label
cluster_label = cluster_label_map.get(predicted_cluster, "Unknown Cluster")
# Interpret the ANN prediction
safety_status = "Safe to Drink" if ann_prediction == 1 else "Not Safe to Drink"
confidence = ann_proba[ann_prediction] * 100
return f"Predicted Cluster Type: {cluster_label}", f"Water Safety Status: {safety_status} (Confidence: {confidence:.2f}%)"
# Define the examples list
examples_data = [
# WHO-safe sample
[0.2, 0.5, 0.01, 0.7, 0.003, 4.0, 0.05, 2.0, 1.5,
0.0, 0.0, 0.01, 10.0, 1.0, 0.006, 0.015, 5.0, 0.04, 0.1, 0.03],
## Heavily contaminated sample
[3.5, 29.8, 0.4, 1.5, 0.04, 8.6, 0.8, 2.0, 1.5,
0.9, 0.8, 0.18, 18.0, 2.93, 0.01, 0.08, 7.99, 0.1, 0.45, 0.05],
# Another heavily contaminated sample (expected: Not Safe to Drink)
[3.5, 29.8, 0.5, 1.5, 0.08, 8.6, 0.8, 2.0, 1.5,
1.0, 1.0, 0.2, 18.0, 2.93, 0.01, 0.08, 7.99, 0.1, 0.45, 0.08],
# Clean water sample (from original data, cluster 2)
[1.65, 9.08, 0.04, 2.85, 0.007, 4.0, 0.05, 2.0, 1.5,
0.0, 0.0, 0.01, 10.0, 1.0, 0.006, 0.015, 5.0, 0.04, 0.1, 0.03]
]
from sklearn.decomposition import PCA
from sklearn.metrics import confusion_matrix, ConfusionMatrixDisplay
def get_algo_plots():
# 1. K-Means Elbow Method
fig1 = plt.figure(figsize=(6, 4))
plt.plot(list(K_range), inertia, marker='o', color='b')
plt.xlabel("Number of Clusters (k)")
plt.ylabel("Inertia")
plt.title("K-Means Elbow Method")
plt.grid(True)
# 2. PCA Scatter Plot
pca = PCA(n_components=2)
X_pca = pca.fit_transform(X_scaled)
fig2 = plt.figure(figsize=(6, 4))
# Map colors from high risk (red) to clean (blue)
color_map = {
"Heavily contaminated group": "#d62728", # red
"Contaminated group": "#ff7f0e", # orange
"Borderline group": "#bcbd22", # yellow-green
"Clean water group": "#1f77b4" # blue
}
unique_clusters = np.unique(clusters)
for cid in unique_clusters:
idx = clusters == cid
label = cluster_label_map.get(cid, f"Cluster {cid}")
color = color_map.get(label, 'grey')
plt.scatter(X_pca[idx, 0], X_pca[idx, 1], label=label, alpha=0.6, s=15, color=color)
plt.xlabel("Principal Component 1")
plt.ylabel("Principal Component 2")
plt.title("PCA Cluster Visualization")
plt.legend(title='Water Profiles', fontsize='small', loc='best')
plt.tight_layout()
# 3. ANN Training Loss Curve
fig3 = plt.figure(figsize=(6, 4))
plt.plot(mlp.loss_curve_, color='red', linewidth=2)
plt.xlabel("Epochs")
plt.ylabel("Training Loss")
plt.title("ANN Training Loss Curve")
plt.grid(True)
# 4. ANN Confusion Matrix
fig4, ax4 = plt.subplots(figsize=(6, 4))
cm = confusion_matrix(y_test_ann, y_pred_ann)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=["Not Safe", "Safe"])
disp.plot(ax=ax4, cmap=plt.cm.Blues)
plt.title("ANN Confusion Matrix")
plt.tight_layout()
return fig1, fig2, fig3, fig4
with gr.Blocks(title="Water Quality Analysis") as iface:
gr.Markdown("# 💧 Detailed Water Quality Prediction System")
gr.Markdown("Analyze water parameters using K-Means Clustering and an Artificial Neural Network.")
with gr.Tabs():
with gr.TabItem("🔍 Predict"):
with gr.Row():
with gr.Column(scale=2):
gr.Markdown("### 1. Enter Water Parameters")
input_components = []
# Create a 4-column layout for the inputs
with gr.Row():
cols = [gr.Column() for _ in range(4)]
for i, col in enumerate(feature_columns):
with cols[i % 4]:
inp = gr.Slider(minimum=float(X[col].min()), maximum=float(X[col].max()), label=col)
input_components.append(inp)
with gr.Row():
predict_btn = gr.Button("Predict Safety Status", variant="primary")
gr.Examples(
examples=examples_data,
inputs=input_components,
label="Quick Presets"
)
with gr.Column(scale=1):
gr.Markdown("### 2. Prediction Results")
out_cluster = gr.Textbox(label="Predicted Cluster Type")
out_safety = gr.Textbox(label="Water Safety Status")
predict_btn.click(
fn=predict_water_safety,
inputs=input_components,
outputs=[out_cluster, out_safety]
)
gr.Markdown("---")
gr.Markdown("### Algorithm Insights")
with gr.Row():
plot1 = gr.Plot(label="Elbow Method")
plot2 = gr.Plot(label="PCA Cluster Visualization")
with gr.Row():
plot3 = gr.Plot(label="ANN Loss Curve")
plot4 = gr.Plot(label="ANN Confusion Matrix")
iface.load(fn=get_algo_plots, inputs=None, outputs=[plot1, plot2, plot3, plot4])
add_extra_tabs()
# Launch the interface
iface.launch(debug=True, share=True) |