Updated Jupyter notebook with new changes

diabetes_prediction_rbl_new_ (1).py

@@ -0,0 +1,530 @@
+# -*- coding: utf-8 -*-
+"""diabetes prediction rbl  new .ipynb
+
+Automatically generated by Colab.
+
+Original file is located at
+    https://colab.research.google.com/drive/1jWjkh5_Y4EdvjYNtxFcXhFR3sc7Hv3oG
+
+Importing libraries
+"""
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import seaborn as sns
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split
+from sklearn import svm
+from sklearn.metrics import accuracy_score
+from sklearn.impute import SimpleImputer
+from sklearn.metrics import precision_score, recall_score, f1_score
+from sklearn.metrics import classification_report
+from sklearn.metrics import precision_score, recall_score, f1_score, roc_auc_score, roc_curve, ConfusionMatrixDisplay
+
+"""Data collection and Analysis
+
+PIMA Diabetes Dataset(for females)
+"""
+
+#loading dataset to pandas dataframe
+diabetes_dataset=pd.read_csv('/content/diabetes_prediction_dataset_male female.csv')
+
+#pd.read_csv?
+
+diabetes_dataset.head()
+
+#getting number of rows and columns in dataset
+diabetes_dataset.shape
+
+#getting the statistical measures of the data
+diabetes_dataset.describe()
+
+# checking how many outcomes(column=diabetes) are there
+# 0=not diabetic
+# 1=diabetic
+diabetes_dataset['diabetes'].value_counts()
+
+"""Labelling
+(for column=diabetes)
+0--->Non-Diabetic   
+1--->Diabetic
+
+------------------------------------------------------------
+
+(for column=gender)
+0--->Male   
+1--->Female
+
+------------------------------------------------------------
+
+(for column=smoking_history)
+0---> no info  
+2---> current
+3---> ever
+4---> former
+5---> never
+6---> not current
+
+"""
+
+#associating  'male' as 0 and 'female' as 1
+gender_mapping = {'Male': 0, 'Female': 1}
+diabetes_dataset['gender'] = diabetes_dataset['gender'].map(gender_mapping)
+
+#grouping the dataset on basis of column=gender
+#diabetes_dataset.groupby('gender').mean()
+
+#associating  'no info' as 0, 'current' as 1, 'ever' as 2, 'former' as 3, 'never' as 4 and 'not current' as 5
+smoking_history_mapping = {'no info': 0, 'current': 1, 'ever': 2, 'former': 3, 'never': 4, 'not current': 5}
+diabetes_dataset['smoking_history'] = diabetes_dataset['smoking_history'].map(smoking_history_mapping)
+
+#grouping the dataset on basis of column=smoking_history
+diabetes_dataset.groupby('smoking_history').mean()
+
+#grouping the dataset on basis of column=diabetes
+diabetes_dataset.groupby('diabetes').mean()
+
+#finding null values of column=smoking_history
+diabetes_dataset['smoking_history'].isnull().sum()  #here null values=='no info'
+
+#separating the data and labels
+X=diabetes_dataset.drop(columns='diabetes',axis=1)
+Y=diabetes_dataset['diabetes']
+
+print(X)
+
+print(Y)
+
+diabetes_dataset['smoking_history'].isnull().sum()
+print(diabetes_dataset[diabetes_dataset['smoking_history']=='0'])
+
+scalar=StandardScaler()
+
+#fitting data in scalar variable
+scalar.fit(X)
+
+#transforming the data
+standardized_data=scalar.transform(X)
+
+#now printing standardised data
+print(standardized_data)
+
+#adding standardized data back to X
+X=standardized_data
+Y=diabetes_dataset['diabetes']
+
+#print(Y.isnull().sum())
+#diabetes_dataset = diabetes_dataset.dropna(subset=['diabetes'])
+
+# Assuming X is a NumPy array
+row_to_drop = 0  # Change this to the index of the row you want to drop
+
+# Create a copy of the original array
+X_original = X.copy()
+
+# Drop the specified row
+X = np.delete(X, row_to_drop, axis=0)
+
+# If you want to revert and get back the original X
+#X = X_original.copy()
+
+#dropped one row from 'X' due to data inconsistancy
+
+"""Data visualisation
+
+"""
+
+# Plotting age vs BMI
+plt.figure(figsize=(10, 5))
+plt.scatter(diabetes_dataset['age'], diabetes_dataset['bmi'], color='blue', alpha=0.5)
+plt.title('Age vs BMI')
+plt.xlabel('Age')
+plt.ylabel('BMI')
+plt.grid(True)
+plt.show()
+
+# Plotting age vs blood glucose levels
+plt.figure(figsize=(10, 5))
+plt.scatter(diabetes_dataset['age'], diabetes_dataset['blood_glucose_level'], color='red', alpha=0.5)
+plt.title('Age vs Blood Glucose Level')
+plt.xlabel('Age')
+plt.ylabel('Blood Glucose Level')
+plt.grid(True)
+plt.show()
+
+# Calculate statistics for age, bmi, and blood glucose level
+statistics = {
+    'Feature': ['age', 'bmi', 'blood_glucose_level'],
+    'Mean': [diabetes_dataset['age'].mean(), diabetes_dataset['bmi'].mean(), diabetes_dataset['blood_glucose_level'].mean()],
+    'Median': [diabetes_dataset['age'].median(), diabetes_dataset['bmi'].median(), diabetes_dataset['blood_glucose_level'].median()],
+    'Std Dev': [diabetes_dataset['age'].std(), diabetes_dataset['bmi'].std(), diabetes_dataset['blood_glucose_level'].std()]
+}
+
+# Create DataFrame
+statistics_df = pd.DataFrame(statistics)
+
+# Print the DataFrame
+print(statistics_df)
+
+# Pairplot for comparative analysis
+sns.pairplot(diabetes_dataset[['age', 'bmi', 'blood_glucose_level']])
+plt.show()
+
+# Correlation matrix
+correlation_matrix = diabetes_dataset[['age', 'bmi', 'blood_glucose_level']].corr()
+print("Correlation Matrix:")
+print(correlation_matrix)
+
+"""Splitting into training data and test data"""
+
+# Adding a row of zeros to X
+new_row = np.zeros((1, X.shape[1]))
+X = np.vstack([X, new_row])
+
+# Now checking the shapes again
+print(X.shape, Y.shape)
+
+#stratify=Y       means that all the Y dataset(Outcome values) will be randomly split in X_train and X_test
+#random_state=2   this replicates the randomness with which the values will be split
+X_train,X_test,Y_train,Y_test=train_test_split(X,Y,test_size=0.2,stratify=Y,random_state=2)
+
+#printing how the values are split
+print(X.shape,X_train.shape,X_test.shape)
+
+"""Training the model"""
+
+#declaring variable classifier to use the svm
+#A linear kernel implies that the decision boundary between classes will be a straight line in the feature space.
+classifier=svm.SVC(kernel='linear')
+
+from sklearn.impute import SimpleImputer
+from sklearn.svm import SVC
+
+# Define your classifier
+classifier = SVC(kernel='linear' , probability=True)
+
+# Creating an imputer object with a strategy to fill NaN values with the mean of each feature
+imputer = SimpleImputer(strategy='mean')
+
+# Fiting the imputer on the training data and transform both the training and testing data
+X_train_imputed = imputer.fit_transform(X_train)
+X_test_imputed = imputer.transform(X_test)
+
+# Now, training the model using the imputed training data
+classifier.fit(X_train_imputed, Y_train)
+
+"""Model Evaluation
+
+Accuracy Score
+"""
+
+#accuracy score on the training data
+X_train_accuracy=classifier.predict(X_train_imputed)
+training_data_accuracy=accuracy_score(X_train_accuracy,Y_train)
+
+print('Accuracy score of the training data:',training_data_accuracy)
+
+# Fiting the imputer on the training data and transform the testing data
+X_test_imputed = imputer.transform(X_test)
+#checking if test data has nan values
+print(np.isnan(X_test_imputed).sum())
+
+# Accuracy score on the test data
+X_test_accuracy = classifier.predict(X_test_imputed)
+test_data_accuracy = accuracy_score(X_test_accuracy, Y_test)
+print('Accuracy score of the test data:', test_data_accuracy)
+
+#accuracy score on the test data
+#X_test_accuracy=classifier.predict(X_test)
+#test_data_accuracy=accuracy_score(X_test_accuracy,Y_test)
+
+"""Labelling (for column=diabetes) 0--->Non-Diabetic
+1--->Diabetic
+
+(for column=gender) 0--->Male
+1--->Female
+
+(for column=smoking_history) 0---> no info
+2---> current 3---> ever 4---> former 5---> never 6---> not current
+"""
+
+diabetes_dataset.head()
+
+"""Making predictive system"""
+
+input_data=(1,25,0,1,3,36.38,4,158) #input_data is a sample data array to test predictive system
+
+#changing the input_data to numpy array
+input_data_as_numpy_array=np.asarray(input_data)
+
+#reshaping the array so that we are predicting for only one instance
+input_data_reshaped=input_data_as_numpy_array.reshape(1,-1)
+
+#standardising the input_data
+std_data=scalar.transform(input_data_reshaped)
+print(std_data)
+
+#predicting based on the standardised input_data (std_data)
+prediction=classifier.predict(std_data)
+
+#to find if the person is diabetic or not
+if (prediction[0]==0):    #prediction[0] means taking the first value from variable prediction
+  print(prediction)
+  print('The person is not diabetic')
+else:
+  print(prediction)
+  print('The person is diabetic')
+
+# Predict probabilities
+predicted_probabilities = classifier.predict_proba(X_test_imputed)
+
+# Get the probability of the positive class (class 1)
+diabetes_probability = predicted_probabilities[:, 1]
+
+# Convert the probability to percentage
+diabetes_percentage = diabetes_probability * 100
+
+# Print the likelihood of the person to get diabetes as a percentage
+if (prediction[0] == 1):
+    print('Likelihood of the person to get diabetes: {:.2f}%'.format(diabetes_percentage[0]))
+else:
+    print('Likelihood of the person not to get diabetes: {:.2f}%'.format(100 - diabetes_percentage[0]))
+
+#Using Logistic Regression
+from sklearn.linear_model import LogisticRegression
+
+# Defining logistic regression classifier
+logistic_regression_classifier = LogisticRegression()
+
+# Training the logistic regression model using the imputed training data
+logistic_regression_classifier.fit(X_train_imputed, Y_train)
+
+# Accuracy score on the training data
+training_data_accuracy_logistic = logistic_regression_classifier.score(X_train_imputed, Y_train)
+print('Accuracy score of the training data (Logistic Regression):', training_data_accuracy_logistic)
+
+# Accuracy score on the test data
+test_data_accuracy_logistic = logistic_regression_classifier.score(X_test_imputed, Y_test)
+print('Accuracy score of the test data (Logistic Regression):', test_data_accuracy_logistic)
+
+# Making predictive statement
+# Assuming input_data is the same as before
+# Predicting based on the standardized input_data (std_data)
+prediction_logistic = logistic_regression_classifier.predict(std_data)
+
+# Predicting probabilities
+predicted_probabilities_logistic = logistic_regression_classifier.predict_proba(X_test_imputed)
+
+# the probability of the positive class (class 1)
+diabetes_probability_logistic = predicted_probabilities_logistic[:, 1]
+
+# Converting the probability to percentage
+diabetes_percentage_logistic = diabetes_probability_logistic * 100
+
+# Printing the likelihood of the person to get diabetes as a percentage
+if prediction_logistic[0] == 1:
+    print('Likelihood of the person to get diabetes (Logistic Regression): {:.2f}%'.format(diabetes_percentage_logistic[0]))
+else:
+    print('Likelihood of the person not to get diabetes (Logistic Regression): {:.2f}%'.format(100 - diabetes_percentage_logistic[0]))
+
+#Random Forest
+from sklearn.ensemble import RandomForestClassifier
+
+# Define your Random Forest classifier
+random_forest_classifier = RandomForestClassifier()
+
+# Train the Random Forest model using the imputed training data
+random_forest_classifier.fit(X_train_imputed, Y_train)
+
+# Accuracy score on the training data
+training_data_accuracy_rf = random_forest_classifier.score(X_train_imputed, Y_train)
+print('Accuracy score of the training data (Random Forest):', training_data_accuracy_rf)
+
+# Accuracy score on the test data
+test_data_accuracy_rf = random_forest_classifier.score(X_test_imputed, Y_test)
+print('Accuracy score of the test data (Random Forest):', test_data_accuracy_rf)
+
+# Making predictive statement
+# Predicting based on the standardized input_data (std_data)
+prediction_rf = random_forest_classifier.predict(std_data)
+
+# Predict probabilities
+predicted_probabilities_rf = random_forest_classifier.predict_proba(X_test_imputed)
+
+# Get the probability of the positive class (class 1)
+diabetes_probability_rf = predicted_probabilities_rf[:, 1]
+
+# Convert the probability to percentage
+diabetes_percentage_rf = diabetes_probability_rf * 100
+
+# Print the likelihood of the person to get diabetes as a percentage
+if prediction_rf[0] == 1:
+    print('Likelihood of the person to get diabetes (Random Forest): {:.2f}%'.format(diabetes_percentage_rf[0]))
+else:
+    print('Likelihood of the person not to get diabetes (Random Forest): {:.2f}%'.format(100 - diabetes_percentage_rf[0]))
+
+#Gradient Boosting
+from sklearn.ensemble import GradientBoostingClassifier
+
+# Define your Gradient Boosting classifier
+gradient_boosting_classifier = GradientBoostingClassifier()
+
+# Train the Gradient Boosting model using the imputed training data
+gradient_boosting_classifier.fit(X_train_imputed, Y_train)
+
+# Accuracy score on the training data
+training_data_accuracy_gb = gradient_boosting_classifier.score(X_train_imputed, Y_train)
+print('Accuracy score of the training data (Gradient Boosting):', training_data_accuracy_gb)
+
+# Accuracy score on the test data
+test_data_accuracy_gb = gradient_boosting_classifier.score(X_test_imputed, Y_test)
+print('Accuracy score of the test data (Gradient Boosting):', test_data_accuracy_gb)
+
+# Making predictive statement
+# Predicting based on the standardized input_data (std_data)
+prediction_gb = gradient_boosting_classifier.predict(std_data)
+
+# Predict probabilities
+predicted_probabilities_gb = gradient_boosting_classifier.predict_proba(X_test_imputed)
+
+# Get the probability of the positive class (class 1)
+diabetes_probability_gb = predicted_probabilities_gb[:, 1]
+
+# Convert the probability to percentage
+diabetes_percentage_gb = diabetes_probability_gb * 100
+
+# Print the likelihood of the person to get diabetes as a percentage
+if prediction_gb[0] == 1:
+    print('Likelihood of the person to get diabetes (Gradient Boosting): {:.2f}%'.format(diabetes_percentage_gb[0]))
+else:
+    print('Likelihood of the person not to get diabetes (Gradient Boosting): {:.2f}%'.format(100 - diabetes_percentage_gb[0]))
+
+# Making predictive statement using Gradient Boosting
+# Predicting based on the standardized input_data (std_data)
+prediction_gb = gradient_boosting_classifier.predict(std_data)
+
+# Predict probabilities
+predicted_probabilities_gb = gradient_boosting_classifier.predict_proba(std_data)
+
+# Get the probability of the positive class (class 1)
+diabetes_probability_gb = predicted_probabilities_gb[:, 1]
+
+# Convert the probability to percentage
+diabetes_percentage_gb = diabetes_probability_gb * 100
+
+# Print the likelihood of the person to get diabetes as a percentage
+if prediction_gb[0] == 1:
+    print('Likelihood of the person to get diabetes (Gradient Boosting): {:.2f}%'.format(diabetes_percentage_gb[0]))
+else:
+    print('Likelihood of the person not to get diabetes (Gradient Boosting): {:.2f}%'.format(100 - diabetes_percentage_gb[0]))
+
+# Check the shape of Y_test
+print('Shape of Y_test:', Y_test.shape)
+
+# Check the shape of prediction_gb
+print('Shape of prediction_gb:', prediction_gb.shape)
+
+# Import necessary libraries
+from sklearn.linear_model import LogisticRegression
+from sklearn.ensemble import RandomForestClassifier
+from sklearn.metrics import precision_score, recall_score, f1_score, roc_auc_score, confusion_matrix
+from collections import Counter
+from sklearn.model_selection import train_test_split
+
+# Assuming X_train_imputed, Y_train, X_test_imputed, and Y_test are already defined
+# Step 1: Check class distribution
+print("Class Distribution in Training Set:", Counter(Y_train))
+
+# Step 2: Define models with class weights balanced
+logistic_regression_classifier = LogisticRegression(class_weight='balanced', random_state=42)
+random_forest_classifier = RandomForestClassifier(class_weight='balanced', random_state=42)
+
+# Step 3: Train the models
+logistic_regression_classifier.fit(X_train_imputed, Y_train)
+random_forest_classifier.fit(X_train_imputed, Y_train)
+
+# Step 4: Check Training Accuracy
+log_reg_train_accuracy = logistic_regression_classifier.score(X_train_imputed, Y_train)
+rf_train_accuracy = random_forest_classifier.score(X_train_imputed, Y_train)
+print(f"Logistic Regression Training Accuracy: {log_reg_train_accuracy:.2f}")
+print(f"Random Forest Training Accuracy: {rf_train_accuracy:.2f}")
+
+# Step 5: Make Predictions on Test Set
+log_reg_predictions = logistic_regression_classifier.predict(X_test_imputed)
+rf_predictions = random_forest_classifier.predict(X_test_imputed)
+
+# Step 6: Evaluate Models
+def evaluate_model(y_true, y_pred, model_name):
+    print(f"\nEvaluation for {model_name}:")
+    precision = precision_score(y_true, y_pred)
+    recall = recall_score(y_true, y_pred)
+    f1 = f1_score(y_true, y_pred)
+    auc = roc_auc_score(y_true, y_pred)
+    cm = confusion_matrix(y_true, y_pred)
+
+    print(f"Precision: {precision:.2f}")
+    print(f"Recall: {recall:.2f}")
+    print(f"F1 Score: {f1:.2f}")
+    print(f"AUC: {auc:.2f}")
+    print("Confusion Matrix:")
+    print(cm)
+
+# Evaluate Logistic Regression
+evaluate_model(Y_test, log_reg_predictions, "Logistic Regression")
+
+# Evaluate Random Forest
+evaluate_model(Y_test, rf_predictions, "Random Forest")
+
+# #cosine similarity
+
+# from sklearn.metrics.pairwise import cosine_similarity
+# import numpy as np
+
+# # Input data (high-risk patient sample)
+# diabetic_sample = np.array([1, 65, 3, 2, 3, 35.5, 7.2, 180])
+
+# # Input from the user (new patient sample)
+# test_input = input("Enter your features according to the format: gender, age, hypertension, heart_disease, smoking_history, bmi, HbA1c_level, blood_glucose_level:  ")
+# user_input = np.array(test_input.split(","))
+# #user_input = np.array([1, 50, 2, 1, 2, 28.5, 5.5, 160])
+
+# # Reshaping the data to match cosine similarity input shape
+# diabetic_sample = diabetic_sample.reshape(1, -1)
+# user_input = user_input.reshape(1, -1)
+
+# # Calculate cosine similarity
+# similarity = cosine_similarity(diabetic_sample, user_input)[0][0]
+
+# # Convert cosine similarity to probability (inverted logic)
+# probability_of_diabetes = similarity * 100  # Inverted to reflect probability
+
+# # Output the results
+# print("Cosine Similarity:", similarity)
+# print("Probability of Diabetes: {:.2f}%".format(probability_of_diabetes))
+
+# #euclidean distance
+
+# import numpy as np
+# from math import sqrt
+
+# # Diabetic sample features (this represents a high-risk patient)
+# diabetic_sample = np.array([1, 65, 3, 2, 3, 35.5, 7.2, 180])
+
+# # User input for testing
+# user_input = input("Enter your features according to the format: gender, age, hypertension, heart_disease, smoking_history, bmi, HbA1c_level, blood_glucose_level: ")
+# user_features = np.array([float(x) for x in user_input.split(',')])
+
+# # Euclidean distance calculation
+# euclidean_distance = np.sqrt(np.sum((diabetic_sample - user_features) ** 2))
+# print(f"Euclidean Distance: {euclidean_distance}")
+
+# # Converting the Euclidean distance into a probability
+# # The greater the distance, the lower the probability of diabetes
+# # You can adjust the scaling factor based on your data distribution to better fit your problem
+
+# max_distance = np.linalg.norm(diabetic_sample)  # Maximum possible distance (diabetic sample vs. zero)
+# probability_diabetes = (1 - (euclidean_distance / max_distance)) * 100
+# probability_diabetes = max(0, min(100, probability_diabetes))  # Keep it in the 0-100 range
+
+# print(f"Probability of Diabetes: {probability_diabetes:.2f}%")