![Screenshot 2024-11-27 at 2.15.56 PM.png](Screenshot%202024-11-27%20at%202.15.56%E2%80%AFPM.png) WATER QUALITY POTABILIBITY What is the Benefits of predicting the water quality? Information about the features or factors contributing to the quality of water, basically answering the question if the water is portable or not. From the data prediction,the knowledge of the results derived can help reduce risk in terms of spread of harmful bacterias and diseases. Visualising the features and prediction results will give more inisght into the data The features for Predicting Water quality potability and their description is listed below: ph: pH of 1. water (0 to 14). Hardness: Capacity of water to precipitate soap in mg/L. Solids: Total dissolved solids in ppm. Chloramines: Amount of Chloramines in ppm. Sulfate: Amount of Sulfates dissolved in mg/L. Conductivity: Electrical conductivity of water in μS/cm. Organic_carbon: Amount of organic carbon in ppm. Trihalomethanes: Amount of Trihalomethanes in μg/L. Turbidity: Measure of light emiting property of water in NTU. Potability: Indicates if water is safe for human consumption. Potable means 1 and Not potable 0 ph pH of water Hardness Capacity of water to precipitate soap in mg/L Solids Total dissolved solids in ppm Chloramines Amount of Chloramines in ppm Sulfate Amount of Sulfates dissolved in mg/L An Overview of the water prediction can be found here [Link text](https://github.com/casselscott/Water-Quality-Machine-Learning/deployments) #Exploratory Data Analysis and Plotting Libraries ```python import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns #Plots to appear inside the notebook %matplotlib inline #Models from scitkit-learn that will be used for this project from sklearn.linear_model import LogisticRegression from sklearn.neighbors import KNeighborsClassifier from sklearn.ensemble import RandomForestClassifier #Model Evaluations libraries from sklearn.model_selection import train_test_split from sklearn.model_selection import cross_val_score from sklearn.model_selection import RandomizedSearchCV, GridSearchCV from sklearn.metrics import confusion_matrix from sklearn.metrics import classification_report from sklearn.metrics import precision_score, recall_score, f1_score from sklearn.metrics import RocCurveDisplay from sklearn.metrics import roc_auc_score #Reading into the dataset css file with pandas df=pd.read_csv("water_potability.csv") The size of the dataset (rows and columns) df.shape (3276,10) #The top of the data df.head ``` ![Screenshot 2024-11-27 at 10.06.55 AM.png](Screenshot%202024-11-27%20at%2010.06.55%E2%80%AFAM.png) From the data displayed we can visually see there are missing values in some rows. To create a good model and to acheive a better prediction accuracy this missing values has to be filled. ```python #Lets find out what the total number is in each class (0 and 1) df["Potability"].value_counts() Potability 0 1998 1 1278 Name: count, dtype: int64 ``` ```python #Visualising the the total number in each class (0 and 1) for the Potability Column in the dataset df ["Potability"].value_counts().plot (kind="bar", color=["orange", "blue"]) plt.title("Water Quality Potability", size=20, weight='bold') plt.annotate(text="Not safe for Human consumption", xytext=(0.5,1750),xy=(0.2,1250), arrowprops =dict(arrowstyle="->", color='orange', connectionstyle="angle3,angleA=0,angleB=90"), color='black') plt.annotate(text="Safe for Human consumption", xytext=(0.8,1500),xy=(1.2,1000), arrowprops =dict(arrowstyle="->", color='blue', connectionstyle="angle3,angleA=0,angleB=90"), color='black') plt.ylabel("Numbers"); ``` ![Screenshot 2024-11-27 at 10.12.14 AM.png](Screenshot%202024-11-27%20at%2010.12.14%E2%80%AFAM.png) ```python #How many missing values are there in the dataset? df.isna().sum() ph 491 Hardness 0 Solids 0 Chloramines 0 Sulfate 781 Conductivity 0 Organic_carbon 0 Trihalomethanes 162 Turbidity 0 Potability 0 dtype: int64 From the result above, the rows missing data are ph- missing 491 values, Sulfate - missing 781 values, and Trihalomethanes - missing 162 values. I will be using the mean of the each of the features that contains missing values to populate the column. #Replace NaN values based on the group sample mean df['ph']=df['ph'].fillna(df.groupby(['Potability'])['ph'].transform('mean')) df['Sulfate']=df['Sulfate'].fillna(df.groupby(['Potability'])['Sulfate'].transform('mean')) df['Trihalomethanes']=df['Trihalomethanes'].fillna(df.groupby(['Potability'])['Trihalomethanes'].transform('mean')) #Check if there are still missing values df.isna().sum() ph 0 Hardness 0 Solids 0 Chloramines 0 Sulfate 0 Conductivity 0 Organic_carbon 0 Trihalomethanes 0 Turbidity 0 Potability 0 dtype: int64 All missing values have been populated. The information about the dataset (mean, std, min,max, Q1,Q2,Q3) df.describe() ``` ![Screenshot 2024-11-27 at 10.19.30 AM.png](Screenshot%202024-11-27%20at%2010.19.30%E2%80%AFAM.png) ```python #Information about the dataframe df.info() ``` ![Screenshot 2024-11-27 at 10.20.50 AM.png](Screenshot%202024-11-27%20at%2010.20.50%E2%80%AFAM.png) FINDING THE PATTERNS IN THE DATASET How the Independent variables relates to the Dependent variable ```python # Comparing one feature to the potabilty feature. pd.crosstab(df.Potability, df.Sulfate ``` ![Screenshot 2024-11-27 at 10.24.20 AM.png](Screenshot%202024-11-27%20at%2010.24.20%E2%80%AFAM.png) ```python #Comparing two features to the potability feature. pd.crosstab(df.Hardness [df.Potability==0], df.Sulfate [df.Potability==0]) ``` ![Screenshot 2024-11-27 at 10.26.07 AM.png](Screenshot%202024-11-27%20at%2010.26.07%E2%80%AFAM.png) ```python # Checking for the hardness with data frame df.hardness 0. 204.890455 1 129.422921 2 224.236259 3 214.373394 4 181.101509 ... 3271 193.681735 3272 193.553212 3273 175.762646 3274 230.603758 3275 195.102299 Name: Hardness, Length: 3276, dtype: float64 ``` ```python #Creating a Scattter Plot with results above where 1 = Potable, 0 = Not Potable plt.scatter (df.Hardness [df.Potability==1], df.Sulfate [df.Potability==1], color="Salmon") plt.scatter (df.Hardness [df.Potability==0], df.Sulfate [df.Potability==0], color="lightblue") plt.title("Relationship between Hardness, Sulfate and Potability Features", size=20, weight='bold') plt.legend (["Potable", "Not Portable", ""]) plt.xlabel("Number") plt.ylabel("Amount (Mg/L)"; ``` ![Screenshot 2024-11-27 at 10.30.53 AM.png](Screenshot%202024-11-27%20at%2010.30.53%E2%80%AFAM.png) ```python # Check the distribution of another feature ( Chloramines) with a histogram df. Chloramines.plot.hist() plt.ylabel("Amount (Mg/L)") plt.title("Chloramines Feature", size=20, weight='bold') ![Screenshot 2024-11-27 at 11.27.45 AM.png](Screenshot%202024-11-27%20at%2011.27.45%E2%80%AFAM.png) ``` After finding patterns in the dataset, understanding how all the features relates to each other is derived through correlation matrix. ```python #Correlation function df.corr ``` ![Screenshot 2024-11-27 at 11.28.40 AM.png](Screenshot%202024-11-27%20at%2011.28.40%E2%80%AFAM.png) ```python # Making Correlation more visual for better understanding fig=plt.figure(figsize=(15,10)) sns.heatmap(df.corr(), annot=True, fmt='0.2f', square=True) plt.title("Correlation Matrixs", size=20, weight='bold') Text(0.5, 1.0, 'Correlation Matrixs') ``` ![Screenshot 2024-11-27 at 10.36.34 AM.png](Screenshot%202024-11-27%20at%2010.36.34%E2%80%AFAM.png) The 1.0 in the diagonal is given a perfect correlation which means the feature is equal from both x and y. This also shows how the Independent variables contributes to the dependent variable. Preparing the Data for Machine Learning Modelling Going back to the problem statement, which is, Can a machine learning model be created to predict water potabilty with at least a 95% accuracy? ```python #View all the top row data df.head() ``` ![Screenshot 2024-11-27 at 10.39.47 AM.png](Screenshot%202024-11-27%20at%2010.39.47%E2%80%AFAM.png) ```python # Split Data into X and Y X= df.drop("Potability", axis=1) Y= df["Potability"] #Let's see what X rows and columns looks like X ``` ![Screenshot 2024-11-27 at 10.41.52 AM.png](Screenshot%202024-11-27%20at%2010.41.52%E2%80%AFAM.png) From the dataframe above, the Potability row is longer visible. and we have a length of 3,276 rows and 9 columns ```python #Let's see what Y row and column looks like Y ``` ![Screenshot 2024-11-27 at 10.43.27 AM.png](Screenshot%202024-11-27%20at%2010.43.27%E2%80%AFAM.png) From the above dataframe we have just 1 column (Potability) and a total length of 3276. To create a good model, the dataset has to be spilt into test and train, simply because we want to be able to use the test data to see how well the model performs. ```python #Spilt data into train and test sets where 80% of the data is for training and 20% is for testing np.random.seed(42) X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.20) #Get the length of both X train and Y train X_train, len(Y_train) ``` ![Screenshot 2024-11-27 at 10.46.48 AM.png](Screenshot%202024-11-27%20at%2010.46.48%E2%80%AFAM.png) From the dataframe above we can see that there is 2620 rows with 9 Columns which is equal to 80% of the total dataset. ```python #Get length of the X test and Y test X_test, len(Y_test) ``` ![Screenshot 2024-11-27 at 10.49.51 AM.png](Screenshot%202024-11-27%20at%2010.49.51%E2%80%AFAM.png) From the above dataframe we can see that there is a total of 656 rows with 9 columns which is equal to 20% of the dataset From the Exploratory Data Analysis (EDA), there was a total of 3275, after spiltting the dataset into train and test. There is a total of 2620 for the training set. The training dataset will be used to find patterns and the test set will be used to test the model created. To find a suitable model for this project, Three different machine learning models will be used to determine the model with a good accuracy that meets the problem statement requirement which is at least a 95% accuracy. The machine learning models are as follows: K-Nearest Neighbor Random Forest Classifier Logistic Regression Now, we have fit the training dataset with all three models, let's see accuracy result for each of the model. ```python #Model Dictionary models = {"Logistic Regression": LogisticRegression(), "KNN":KNeighborsClassifier(), "Random Forest": RandomForestClassifier()} models {'Logistic Regression': LogisticRegression(), 'KNN': KNeighborsClassifier(), 'Random Forest': RandomForestClassifier()} ``` ```python #Creating a function called potability_fit_score def potability_fit_score(models, X_train, X_test, Y_train, Y_test): """ fits and evaluates given machine learning models. Models: A dict of different Scikit-learn machine learning models. X_train: Training data (with training labels) X_test: Testing data (No labels) Y_train: Training data (with training labels) Y_test: Testing data (No labels) """ np.random.seed(42) #set randon seed modelfit_scores = {} #Loop through the models #fit the model to train data #Evaluate the model and append the score to the model_scores for name, model in models.items(): model.fit(X_train, Y_train) model_scores[name]=model.score(X_train, Y_train) return model_scores model_RandomForest = RandomForestClassifier() model_RandomForest.fit(X_train, Y_train) ``` ![Screenshot 2024-11-27 at 10.56.38 AM.png](Screenshot%202024-11-27%20at%2010.56.38%E2%80%AFAM.png) ```python model_RandomForest.score(X_train, Y_train) 1.0 ``` From the above result there is a 100% accuracy when the training dataset was used for Random Forest Machine Learning Model The next model I am going to use is the K Nearest Neighbour The next model I am going to use is the K Neighbour ```python model_KNN =KNeighborsClassifier() model_KNN.fit(X_train, Y_train) model_KNN. 0.7145038167 #From the above result, there is a 71% accuracy when the training dataset was used for the KNearest Neighbor Machine Learning model ``` The final model i will be using is the Logistic Regression Model. ```python model_LogisticRegression = LogisticRegression() model_LogisticRegression.fit(X_train, Y_train) model_LogisticRegression.score(X_train, Y_train) 0.6061068702290077 From the above result, there is a 60% accuracy when the training dataset was used for the KNearest Neighbor Machine Learning model ``` Lets look at the model results in a bar chart ```python fig, ax =plt.subplots() models =['','LogisticRegression', 'KNN', 'RandomForest'] models_labels =['','red','blue', 'green'] models_result = ['','0.60', '0.71', '1.0'] bar_colors= ['tab:red','tab:blue', 'tab:green'] ax.bar(models, models_result, label=models_labels, color=bar_colors) ax.set_ylabel("Number") ax.set_xlabel("Model Name") ax.set_title("Model Comparison", size=20, weight='bold') ax.legend(['Random Forest','Logistic Regression','KNN',]) plt.show() ``` ![Screenshot 2024-11-26 at 3.51.42 PM.png](Screenshot%202024-11-26%20at%203.51.42%E2%80%AFPM.png) From the visualisation Bar Chart, we can see that Random Forest has a high accuracy for the prediction of the water quality and potability. TUNING AND IMPROVING THE MODELS After getting the baseline for the models, Hyperparameters can be tuned to improve the models, Feature importance, confusion matrix, Cross-validation, Precision, recall, F1 score, Classification report Roc curve, Area under curve (AUC) ```python # Tuning and Improving the baseline score train_scores=[] test_scores=[] #Create a list of different values for the n-neighbors neighbors=range(1,21) #setup the KNN instance knn= KNeighborsClassifier() #Loop through different K-neighbors for i in neighbors: knn.set_params(n_neighbors=i) knn.fit(X_train, Y_train) train_scores.append(knn.score(X_train,Y_train)) test_scores.append(knn.score(X_test, Y_test)) knn.fit(X_train, Y_train) knn.score(X_train, Y_train) 0.6339694656488549 ``` From the hyperparameter tuning, the accuracy for K Nearest Neighbor Machine learning model is 60% and still does not meet the problem statement requirement. Let's compare how KNearest Neighbor did before Hyper Tuning and after Hyper Tuning ```python # Visualise the Knearest Neighbor model before and after hyperparameter tuning plt.plot(neighbors, train_scores, label="Train Score") plt.plot(neighbors, test_scores, label="Test Score") plt.xlabel ("Number of neighbors") plt.xlabel("model Score") plt.title("Train and Test Score", size=20, weight='bold') plt.legend() plt.ylabel("Model Accuracy") print (f"Maximum KNN score on the test data: {max(test_scores)*100:2f} %") Maximum KNN score on the test data: 61.432927 % ``` ![Screenshot 2024-11-26 at 4.01.02 PM.png](Screenshot%202024-11-26%20at%204.01.02%E2%80%AFPM.png) From the graph shown above, The Knearest Neighbor did better in the training dataset that it did with the test dataset. Tuning the following models using Randomized Search CV: Logistic Regression() ```python # Creating a Parameter Grid for Logistics Regression log_reg_grid= {"C": np.logspace(-4,4,20), "solver": ["liblinear"]} np.logspace(-4,4,20) array([1.00000000e-04, 2.63665090e-04, 6.95192796e-04, 1.83298071e-03, 4.83293024e-03, 1.27427499e-02, 3.35981829e-02, 8.85866790e-02, 2.33572147e-01, 6.15848211e-01, 1.62377674e+00, 4.28133240e+00, 1.12883789e+01, 2.97635144e+01, 7.84759970e+01, 2.06913808e+02 5..45559478e+02, 1.43844989e+03, 3.79269019e+03, 1.00000000e+04]) After setting up the hyper parameters grids, I am going to tune them using the Randomised Search CV Tune Logistic Regression np.random.seed(42) #Setup random hyperparameter search for logistic Regression rs_log_reg=RandomizedSearchCV (LogisticRegression(), param_distributions=log_reg_grid, cv=5,n_iter=20, verbose=True) #fit randomized search hyperparameter for Logistic Regression Model for train datasets rs_log_reg.fit(X_train,Y_train) rs_log_reg.best_params_ Fitting 5 folds for each of 20 candidates, totalling 100 fits {'solver': 'liblinear', 'C': 0.0006951927961775605} fit randomized search hyperparameter for Logistic Regression for scoring the test datasets rs_log_reg.score (X_test,Y_test) 0.6280487804878049 ``` After tuning using the Randomized Search CV we still get a 62% accuracy for Logistic Regression Tuning the Logistic Regression Hyperparameter model using GridSearchCV ```python # Different Parameters for logistic regression model log_reg_grid= {"C": np.logspace (-4, 4, 30), "solver": ["liblinear"]} #setting up grid hyperparameter search for Logistic Regression gs_log_reg = GridSearchCV (LogisticRegression(), param_grid=log_reg_grid, cv=5, verbose=True) #Fit grid hyperparameter gs_log_reg.fit(X_train, Y_train) Fitting 5 folds for each of 30 candidates, totalling of 150 fits GridSearchCV(cv=5, estimator=LogisticRegression(), param_grid={'C': array([1.00000000e-04, 1.88739182e-04, 3.56224789e-04, 6.72335754e-04, 1.26896100e-03, 2.39502662e-03, 4.52035366e-03, 8.53167852e-03, 1.61026203e-02, 3.03919538e-02, 5.73615251e-02, 1.08263673e-01, 2.04335972e-01, 3.85662042e-01, 7.27895384e-01, 1.37382380e+00, 2.59294380e+00, 4.89390092e+00, 9.23670857e+00, 1.74332882e+01, 3.29034456e+01, 6.21016942e+01, 1.17210230e+02, 2.21221629e+02, 4.17531894e+02, 7.88046282e+02, 1.48735211e+03, 2.80721620e+03, 5.29831691e+03, 1.00000000e+04]), 'solver': ['liblinear']}, verbose=True) #check for the best hyperparameters gs_log_reg.best_params_ {'C': 0.0006723357536499335, 'solver': #Evaluate the grid search cv gs_log_reg.score(X_test, Y_test) 0.6280487804878049 ``` When RandomizedSearchCV was used to tune the hyperparameters we derived a 62% accuracy Also, after tuning with GrisSearchCV a 62% accuracy ![Screenshot 2024-11-27 at 11.04.06 AM.png](Screenshot%202024-11-27%20at%2011.04.06%E2%80%AFAM.png) After Hyper Tuning the other model parameters i still did not meet the criteria for the problem statement and ince a 100% accuracy was acheived with Random Forest Classification. I will be evaluating the model for the following: 1.Accuracy 2.ROC Curve 3.Confusion Matrix 4.Classification matrix 5.Precision 6. Recall 7.F1_Score 8.Cross-validation ```python # To evaluate the Random Forest Classifier model, I will utilize the test data for prediction model_RandomForest.fit(X_test, Y_test) RandomForestClassifier() y_preds=model_model_RandomForest.predict(X_test) array([0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 1, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 1, 0, 1, 1, 1, 1, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1, 1, 1, 0, 0, 0, 1, 1, 1, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 1, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 1, 1, 0, 0, 0, 0, 1, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 1, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 0, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 0, 0, 0, 1, 1, 0, 0, 1, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 1, 0, 1, 0, 1, 0, 1, 1, 0, 1, 1, 0, 0, 0, 0, 0, 1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 1, 0, 0, 1, 0, 1, 0, 1, 0, 1, 0, 0, 1, 1, 0, 0, 0, 1, 1, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 1, 0, 1, 1, 0, 1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 1, 0], dtype=int64) ``` #The array of numbers above shows the prediction of water potability using the test data where 1 represents 1 safe for consumption and 0 represents not potable. ```python Y_test 2947 0 2782 1 1644 0 70 0 2045 1 .. 208 0 1578 1 565 0 313 1 601 0 Name: Potability, Length: 656, dtype: in ``` The Test dataset that had 9 columns (X_Test) was used to predict the Potabilty column (Y_Test) as shown above ```python Computing a confusion matrix anatomy to know how well the model performed in predicting. print (confusion_matrix (Y_test, y_preds)) [[412 0] [ 0, 244]] ``` From the confusion matrix we can see that the Y_test data had 412 values that was = 0, but after using the model to predict we got a total of 244 values = 0 ```python #Plot confusion matrix using a function def plot_conf_mat(Y_test,Y_preds): """" Plots a nice looking confusion matrix using a seaborn's heatmap() """ fig, ax = plt.subplots(figsize=(3,3)) ax=sns.heatmap (confusion_matrix(Y_test, y_preds), annot=True, cbar=False) plt.xlabel("True label") plt.ylabel("Predicted label") bottom, top = ax.get_ylim() ax.set_ylim(bottom +0.5, top -0.5) plot_conf_mat(Y_test, y_preds) ``` ![Screenshot 2024-11-26 at 4.28.14 PM.png](Screenshot%202024-11-26%20at%204.28.14%E2%80%AFPM.png) Confusion Matrix Analogy True positive = model predicts 1 when the Truth is 1 False positive = model predicts 1 when the Truth is 0 True Negative = model predicts 0 when truth is 1 False Negative= model predicts 0 when the truth is 1 After the confusion matrix analogy, I want to also get a classification report as well as a cross validated precision, recall and f1-score. ```python #Classification report print(classification_report(Y_test, y_preds) ``` ![Screenshot 2024-11-26 at 4.29.54 PM.png](Screenshot%202024-11-26%20at%204.29.54%E2%80%AFPM.png) What the classification report represents is: Precision: No false positive Recalls: Proportion of actual positive f1-score: This is a combination of precision and recall Support: Which shows the number of samples the report used to calculate. Finding the highest and least features that contributed to the predictions. ```python # Displaying X_test data ``` ![Screenshot 2024-11-27 at 11.08.43 AM.png](Screenshot%202024-11-27%20at%2011.08.43%E2%80%AFAM.png) ```python #Save X_test into a css df_X_test=pd.DataFrame (X_test) df_X_test ``` ![Screenshot 2024-11-27 at 11.10.48 AM.png](Screenshot%202024-11-27%20at%2011.10.48%E2%80%AFAM.png) ```python #This will save the X_test to a csv file. df_X_test. to_csv ("X_test") #Creates the feature importance between the Test dataset features. feature_importance=df_X_test.corr() feature_importance ``` ![Screenshot 2024-11-27 at 11.13.37 AM.png](Screenshot%202024-11-27%20at%2011.13.37%E2%80%AFAM.png) ```python #Creating a dictionary for the features and values. dict= {"ph":1.000000, "Hardness":0.069999, "Solids":-0.129438, "Chloramines":-0.028890, "Sulfate":0.005391, "Conductivity":0.005391, "Organic_carbon":0.053269, "Trihalomethanes":0.054734, "Turbidity":-0.030013}; dict {'ph': 1.0, 'Hardness': 0.069999, 'Solids': -0.129438, 'Chloramines': -0.02889, 'Sulfate': 0.005391, 'Conductivity': 0.005391, 'Organic_carbon': 0.053269, 'Trihalomethanes': 0.054734, 'Turbidity': -0.30013} #visualising the feature importance features_df = pd.DataFrame(dict, index=[0]) features_df.T.plot.barh(title="Feature Importance", color="orange", legend=False, ylabel="Features", xlabel="Importance Number"); ``` ![Screenshot 2024-11-27 at 11.17.06 AM.png](Screenshot%202024-11-27%20at%2011.17.06%E2%80%AFAM.png) From the above visualisation we can see that the most important feature that contributed to the prediction for the water consumption was ph. Also, the least feature that contributed to the prediction of the dataset was Sulfate and Conductivity. Going back to our problem statement which was: I wanted to find out Information about the features or factors contributing to the quality of water and from the visualising above Ph, Hardness, Organic carbon, Trihalomethanes all contribute to the quality of water. With Ph having a high contributing factor of 1.0. From the data prediction,the knowledge of the results derived can help reduce risk in terms of spread of harmful bacterias and diseases. I have been able to get more inisght into the water quality potability dataset by exploring the patterns. DISCLAIMER All Derived Results from this machine learning model was derived based on the Water Potability Dataset gotten from Kaggle.