Imports

import pandas as pd
import numpy as np
from sklearn.impute import SimpleImputer
from sklearn.model_selection import train_test_split
from sklearn.linear_model import LogisticRegression
import matplotlib.pyplot as plt
from sklearn.metrics import confusion_matrix
from sklearn.model_selection import cross_val_score

Data processing

file = "breast-cancer-data.csv"
dp = pd.read_csv(file)

missing_values = dp.isnull().sum()
print(missing_values)

Sample code number              0
Clump Thickness                 0
Uniformity of Cell Size         0
Uniformity of Cell Shape        0
Marginal Adhesion               0
Single Epithelial Cell Size     0
Bare Nuclei                    16
Bland Chromatin                 0
Normal Nucleoli                 0
Mitoses                         0
Class                           0
dtype: int64

inputer = SimpleImputer()

# transform empty cells to mean of column
inputed_data = pd.DataFrame(inputer.fit_transform(dp))
inputed_data.columns = dp.columns
missing_values = inputed_data.isnull().sum()

Work for Bland Chromatin

blandChromatinData=inputed_data[["Bland Chromatin"]]
y=inputed_data.Class

#Splitting
BC_train, BC_test, y_BC_train, y_BC_test = train_test_split(blandChromatinData, y, test_size = 0.225, random_state = 0)

#Fitting
classifierBC = LogisticRegression(random_state = 0)
classifierBC.fit(BC_train, y_BC_train)

#Predicting
y_BC_pred=classifierBC.predict(BC_test)

#Confusion Matrix
cBC = confusion_matrix(y_BC_test, y_BC_pred)

# K-fold cross validation
accuracies_BC = cross_val_score(estimator = classifierBC, X = BC_train, y = y_BC_train, cv = 10)

Work for Cell size

uniformity_of_cell_size = inputed_data[["Uniformity of Cell Size"]] # selecting uniformity_of_cell_size column
uocs = inputed_data["Class"] # class column will be the dependent variable

#Splitting
uniformity_of_cell_size_train, uniformity_of_cell_size_test, uocs_train, uocs_test = train_test_split(uniformity_of_cell_size,uocs,test_size=0.2, random_state=0) 

#Fitting
uniformity_of_cell_size_classifier = LogisticRegression(random_state=0) # create an instance of the logistic regression module
uniformity_of_cell_size_classifier.fit(uniformity_of_cell_size_train, uocs_train) #train the model

#predicting
uocs_pred = uniformity_of_cell_size_classifier.predict(uniformity_of_cell_size_test)

#confusion matrix
uniformity_of_cell_size_cm = confusion_matrix(uocs_test,uocs_pred)
# display(uniformity_of_cell_size_cm)

# K-fold cross validation
uniformity_of_cell_size_accuracies = cross_val_score(estimator=uniformity_of_cell_size_classifier, X = uniformity_of_cell_size_train, y = uocs_train, cv = 10)

Work for Cell Shape

uniformity_of_cell_shape = inputed_data[['Uniformity of Cell Shape']]
uocsh = inputed_data['Class']

#Splitting
uniformity_of_cell_shape_train, uniformity_of_cell_shape_test, uocsh_train, uocsh_test = train_test_split(uniformity_of_cell_shape, uocsh, test_size = 0.2, random_state = 0)

#Fitting
uniformity_of_cell_shape_classifier = LogisticRegression(random_state = 0)
uniformity_of_cell_shape_classifier.fit(uniformity_of_cell_shape_train, uocsh_train)

#Predicting
uocsh_pred = uniformity_of_cell_shape_classifier.predict(uniformity_of_cell_shape_test)

#Confusion Matrix
uniformity_of_cell_shape_cm = confusion_matrix(uocsh_test, uocsh_pred)
# display(uniformity_of_cell_shape_cm)

# K-fold cross validation
uniformity_of_cell_shape_accuracies = cross_val_score(estimator = uniformity_of_cell_shape_classifier, X = uniformity_of_cell_shape_train, y = uocsh_train, cv = 10)

Determining the Top 3 Most Accurate Features:

The same process as shown above was done for each feature, and it was determined that bland chromatin, cell size, and cell shape were the top 3 accurate predictors

Accuracies

#top 3 accuracies
print("Uniformity of Bland Chromatin: {:.2f} %".format(accuracies_BC.mean()*100))
print("Uniformity of Cell Size: {:.2f} %".format(uniformity_of_cell_size_accuracies.mean()*100))
print("Uniformity of Cell Shape: {:.2f} %".format(uniformity_of_cell_shape_accuracies.mean()*100))

Uniformity of Bland Chromatin: 89.65 %
Uniformity of Cell Size: 93.02 %
Uniformity of Cell Shape: 92.49 %

Build graphs

#all three data
import matplotlib.pyplot as plt
import numpy as np
single_Data=[uniformity_of_cell_size_cm, cBC, uniformity_of_cell_shape_cm]
total_benign=[]
total_malignant=[]
true_benign=[]
true_malignant=[]
false_benign=[]
false_malignant=[]
for i in range(3):
  total_benign.append((single_Data[i][0][0]+single_Data[i][1][0]))
  total_malignant.append(single_Data[i][0][1]+single_Data[i][1][1])
  true_benign.append((single_Data[i][0][0]/total_benign[i])*100)
  true_malignant.append((single_Data[i][1][1]/total_malignant[i])*100)
  false_benign.append((single_Data[i][1][0]/total_benign[i])*100)
  false_malignant.append((single_Data[i][0][1]/total_malignant[i])*100)

Displaying Graphs

true_values=[]
false_values=[]

print("\033[1mGraphs Displaying the Accuracy of Benign vs. Malignant Predictions of the Top 3 Features\033[m")
print()

for i in range(3):
  true_values.append((true_benign[i],true_malignant[i]))
  false_values.append((false_benign[i],false_malignant[i]))

  ind=np.arange(5)
  p1=plt.bar((0,1),true_values[i],width=0.75, color="#ffb6b9")
  p2=plt.bar((0,1),false_values[i],width=0.75,bottom=true_values[i], color="#B8B8B8")

  plt.ylabel("Percentage (%)")
  
  if(i==0):
    plt.title("Cell Size: Overall Accuracy = {:.2f} %".format(uniformity_of_cell_size_accuracies.mean()*100))
  elif(i==1):
    plt.title("Bland Chromatin: Overall Accuracy = {:.2f} %".format(accuracies_BC.mean()*100))
  elif(i==2):
    plt.title("Cell Shape: Overall Accuracy = {:.2f} %".format(uniformity_of_cell_shape_accuracies.mean()*100))
  
  plt.xticks((0,1),("Benign","Malignant"))
  plt.legend((p1[0], p2[0]), ('Correct Prediction', 'Incorrect Prediction'))
  plt.show()

Graphs Displaying the Accuracy of Benign vs. Malignant Predictions of the Top 3 Features