Κατηγοριοποίηση των κυττάρων ως καλοήθη ή κακοήθη.
Συνήθως οι τεχνικές μηχανικής μάθησης έχουν ένα κοινό χαρακτηριστικό , το διαχωρισμό των στοιχείων σε ομάδες (clusters) τα οποία στη συνέχεια χρησιμοποιούν για την εκπαίδευση και δοκιμή των μοντέλων πρόβλεψης.
Στη παρούσα εργασία αυτές οι ομάδες είναι τα καλοήθη από τα κακοήθη κύτταρα ενός όγκου, με στόχο τον εντοπισμό και τη διάκριση του κακοήθους καρκίνου από τον καλοήθη με την χρήση των παρακάτω τεχνικών.
Μοντέλα Πρόβλεψης
Στα πλαίσια της εργασίας θα χρησιμοποιηθούν επτά διαφορετικά μοντέλα μηχανικής μάθησης για την κατηγοριοποίηση και πρόβλεψη της νόσου.
Από τα μοντέλα αυτά θα γίνει η επιλογή 8 χαρακτηριστικών μεθόδων για την εξαγωγή των αποτελεσμάτων.
Έτσι, για κάθε μοντέλο το οποίο θα "τρέξει" για κάθε μια από τις 8 παραπάνω μεθόδους θα προκύψουν συνολικά 56 μοντέλα από τα οποία μετά από σύγκριση των αποτελεσμάτων θα επιλεγεί το καλύτερο.
Επεξήγηση Μοντέλων & Μεθόδων
Logistic Regration
Random Forest Classifier
Gradient Boosting Classifier
Extra trees Classifier
XGB Classifier
KNN Classifier
SVM - Support Vector Machine
Μεθοδολογία
Προέλευση Δεδομένων
Επεξεργασία - Καθαρισμός Δεδομένων
Εισαγωγή των κατάλληλων βιβλιοθηκών
!pip install statsmodels
!pip install xgboost
# importing the libraries
import numpy as np
import pandas as pd
from pandas import DataFrame
import seaborn as sns
import matplotlib.pyplot as plt
import time
from datetime import datetime
import platform
import warnings
warnings.filterwarnings('ignore')
import scipy.stats as stats
import itertools
from copy import copy
from functools import reduce
from statsmodels.stats.outliers_influence import variance_inflation_factor
from tabulate import tabulate
import pickle
import os
import joblib
import sklearn
from sklearn.model_selection import train_test_split
from sklearn.model_selection import RandomizedSearchCV
from sklearn.metrics import f1_score,confusion_matrix,accuracy_score
from sklearn.model_selection import StratifiedKFold,GridSearchCV
from sklearn.model_selection import cross_val_score
from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2
from sklearn.feature_selection import RFE
from sklearn.feature_selection import RFECV
from sklearn.feature_selection import SelectFromModel
from sklearn.feature_selection import VarianceThreshold
from sklearn.feature_selection import SelectPercentile, f_classif
from sklearn import metrics
from sklearn.metrics import roc_auc_score, roc_curve, classification_report
from sklearn.metrics import confusion_matrix, accuracy_score, mean_squared_error
from sklearn.metrics import f1_score, precision_score, recall_score, log_loss, r2_score
from sklearn.metrics import precision_recall_curve
from sklearn.svm import SVC,LinearSVC
from sklearn.linear_model import LogisticRegression
from sklearn.ensemble import GradientBoostingClassifier
from sklearn.ensemble import RandomForestClassifier
from sklearn.ensemble import ExtraTreesClassifier
from sklearn.decomposition import PCA
from xgboost import XGBClassifier
from sklearn.tree import DecisionTreeClassifier
from sklearn.naive_bayes import BernoulliNB
from sklearn.pipeline import make_pipeline,make_union
from sklearn.kernel_approximation import Nystroem
from sklearn.neighbors import KNeighborsClassifier
from sklearn.preprocessing import MaxAbsScaler,MinMaxScaler
from sklearn.preprocessing import Normalizer, RobustScaler
from sklearn.preprocessing import PolynomialFeatures,StandardScaler
from sklearn.preprocessing import FunctionTransformer
Εισαγωγή δεδομένων
dataset = pd.read_csv('/work/Data/data.csv')
Πρωταρχικός Έλεγχος Δεδομένων
dataset.head()
Εξαγωγή διαστάσεων πίνακα
print("Winscosin Cancer dataset dimensions : {}".format(dataset.shape))
Σύμφωνα με το παραπάνω αποτέλεσμα, παρατηρείται ότι το μέγεθος του δείγματος είναι 569 καταχωρίσεις με 33 χαρακτηριστικά/μεταβλητές η καθεμία από αυτές.
Έλεγχος για μηδενικές ή κενές τιμές
#print (dataset.isnull().sum())
#print (dataset.isna().sum())
## Get column data types and missing values in Columns
dataset.info()
Έλεγχος για διπλότυπες τιμές
# Get column names
column_names = dataset.columns
for i in column_names:
print('{} is unique: {}'.format(i, dataset[i].is_unique))
Απόρριψη στηλών που δε θα χρησιμοποιηθούν από το δείγμα
Αρχικά, θα γίνει εμφάνιση των στηλών που αποτελούν το πίνακα δεδομένων.
# Get column names
col = dataset.columns # .columns gives columns names in data
print(col)
Αφαίρεση NaN τιμών
# y includes our labels and x includes our features
y = dataset.diagnosis # M or B
list = ['Unnamed: 32','id','diagnosis']
x = dataset.drop(list,axis = 1 )
x.head()
Προσδιορισμός στηλών με διπλότυπο περιεχόμενο
# calculate duplicates
dups = x.duplicated()
# report if there are any duplicates
print(dups.any())
# list all duplicate rows
print(x[dups])
Σύμφωνα με το παραπάνω αποτέλεσμα κάθε σειρά των δεδομένων αντιπροσωπεύει μια παρατήρηση για έναν ασθενή και οι στήλες περιέχουν τις μεταβλητές.
Ανάλυση Δεδομένων
ax = sns.countplot(y,label="Count") # M = 212, B = 357
B, M = y.value_counts()
print('Number of Benign: ',B)
print('Number of Malignant : ',M)
ax.set_ylabel('Number of patients')
bars = ax.patches
half = int(len(bars)/2)
left_bars = bars[:half]
right_bars = bars[half:]
for left, right in zip(left_bars, right_bars):
height_l = left.get_height()
height_r = right.get_height()
total = height_l + height_r
ax.text(left.get_x() + left.get_width()/2., height_l + 40, '{0:.0%}'.format(height_l/total), ha="center")
ax.text(right.get_x() + right.get_width()/2., height_r + 40, '{0:.0%}'.format(height_r/total), ha="center")
Βασική Στατιστική Εικόνα του Δείγματος
x.describe()
Οπτικοποίηση των δεδομένων
Για την οπτικοποίηση των δεδομένων θα γίνει χρήση του πακέτου seaboarn το οποίο επιτρέπει την ευέλικτη χρήση διάφορων τύπων γραφημάτων. Κάποια από τα γραφήματα που ακολουθούν είναι τα διαγράμματα Violin και Swarm.
Πάντα πριν την οπτικοποίηση των δεδομένων καλό είναι να προηγείται η κανονικοποίηση των στοιχείων ώστε να είναι εφικτή η δημιουργία μιας άρτιας γραφικής παράστασης χωρίς απώλεια δεδομένων.
# first ten features
data_dia = y
data = x
# standardization of the data
data_n_2 = (data - data.mean()) / (data.std())
data = pd.concat([y,data_n_2.iloc[:,0:10]],axis=1)
data = pd.melt(data,id_vars="diagnosis",
var_name="features",
value_name='value')
data.head()
Violin plot
Το γράφημα που ακολουθεί αφορά την οπτικοποίηση 3 ομάδων που το καθένα από αυτά αφορά 10 χαρακτηριστικά του δείγματος.
sns.set(style = 'whitegrid')
#τα πρώτα δέκα χαρακτηριστικά προς μελέτη
plt.figure(figsize=(10,10))
sns.violinplot(x="features", y="value", hue="diagnosis", data=data,split=True, inner="quart",palette ="Set1")
plt.xticks(rotation=90)
Ας ερμηνεύσουμε το παραπάνω γράφημα. Έστω, στο χαρακτηριστικό texture_mean, η διάμεσος του κακοήθους και του καλοήθους φαίνεται σαν διαχωρισμένη, αυτό σημαίνει ότι το στοιχείο ενδεχομένως να μπορεί να χρησιμοποιηθεί από τους αλγόριθμους ταξινόμησης (classification). Ωστόσο, στο χαρακτηριστικό fractal_dimension_mean, η διάμεσος του κακοήθους και του καλοήθους δεν φαίνεται να διαχωρίζεται, επομένως δεν παρέχει πολύ καλές πληροφορίες για ταξινόμηση.
# Επόμενα δέκα χαρακτηριστικά
data = pd.concat([y,data_n_2.iloc[:,10:20]],axis=1)
data = pd.melt(data,id_vars="diagnosis",
var_name="features",
value_name ='value')
plt.figure(figsize=(10,10))
sns.violinplot(x="features", y="value", hue="diagnosis", data=data,split=True, inner="quart",palette ="Set1")
plt.xticks(rotation=90)
# Δεδομένα τελευταίας δεκάδας χαρακτηριστικών
data= pd.concat([y,data_n_2.iloc[:,20:31]],axis=1)
data = pd.melt(data,id_vars="diagnosis",
var_name="features",
value_name ='value')
plt.figure(figsize=(10,10))
sns.violinplot(x="features", y="value", hue="diagnosis", data=data,split=True, inner="quart",palette ="Set1")
plt.xticks(rotation=90)
Boxplots
# As an alternative of violin plot, box plot can be used.Box plots are also useful in terms of seeing outliers
# In order to show you lets have an example of box plot
# first ten features
data = pd.concat([y,data_n_2.iloc[:,0:10]],axis=1)
data = pd.melt(data,id_vars="diagnosis",
var_name="features",
value_name='value')
plt.figure(figsize=(10,10))
sns.boxplot(x="features", y="value", hue="diagnosis", data=data,palette ="muted")
plt.xticks(rotation=90)
# Second ten features
data = pd.concat([y,data_n_2.iloc[:,10:20]],axis=1)
data = pd.melt(data,id_vars="diagnosis",
var_name="features",
value_name='value')
plt.figure(figsize=(10,10))
sns.boxplot(x="features", y="value", hue="diagnosis", data=data,palette ="muted")
plt.xticks(rotation=90)
# Last ten features
data = pd.concat([y,data_n_2.iloc[:,20:31]],axis=1)
data = pd.melt(data,id_vars="diagnosis",
var_name="features",
value_name='value')
plt.figure(figsize=(10,10))
sns.boxplot(x="features", y="value", hue="diagnosis", data=data,palette ="muted")
plt.xticks(rotation=90)
Ας ερμηνεύσουμε ένα ακόμη πράγμα σχετικά με τα παραπάνω γραφήματα. Οι μεταβλητές concavity_worst και concave point_worst φαίνονται παρόμοιες. Πώς μπορούμε να αποφασίσουμε εάν συσχετίζονται μεταξύ τους ή όχι;
Για να μπορέσουμε να συγκρίνουμε δύο χαρακτηριστικά σε βάθος θα χρησιμοποιήσουμε το εργαλείο jointplot, η οποία χρησιμοποιείται για να δείξει την σχέση μεταξύ δύο μεταβλητών. Χρησιμοποιώντας το συντελεστή συσχέτισης Pearson μπορούμε να κρίνουμε αν υπάρχει ή όχι πραγματική συσχέτιση μεταξύ των δύο.
sns.set(style="white",color_codes=True)
jp=sns.jointplot(x.loc[:,'concavity_worst'], x.loc[:,'concave points_worst'], kind ="reg",color="g")
stats.pearsonr(x['concavity_worst'], x['concave points_worst'])
jp=sns.jointplot(x.loc[:,'concavity_mean'], x.loc[:,'concave points_mean'], kind="reg",color="b")
stats.pearsonr(x['concavity_mean'], x['concave points_mean'])
jp=sns.jointplot(x.loc[:,'concavity_se'], x.loc[:,'concave points_se'], kind="reg",color="r")
stats.pearsonr(x['concavity_se'], x['concave points_se'])
Σύμφωνα με τα παραπάνω παρατηρείται ότι όλες οι μεταβλητές που εξετάστηκαν είναι συσχετιζόμενες, καθώς σε όλες ο δείκτης Pearson είναι >0.05.
Στη περίπτωση μας χρειαζόμαστε σύγκριση περισσότερων χαρακτηριστικών, για το λόγο αυτό θα χρησιμοποιηθεί ένα ομαδοποιημένο γράφημα πλέγματος. Μέσω αυτού θα παρατηρηθεί ότι τα χαρακτηριστικά radius_worst, perimeter_worst και area_worst συσχετίζονται μεταξύ τους.
Pairplots
Για να ελεγχεί η κατανομή μιας μεταβλητής καθώς και η συσχέτιση μεταξύ δύο μεταβλητών γίνεται χρήση των γραφημάτων Pairplot.
# Function to calculate correlation coefficient between two arrays
def corr(x, y, **kwargs):
# Calculate the value
coef = np.corrcoef(x, y)[0][1]
# Make the label
label = r'$\rho$ = ' + str(round(coef, 2))
# Add the label to the plot
ax = plt.gca()
ax.annotate(label, xy = (0.2, 0.95), size = 11, xycoords = ax.transAxes)
# First six features
data = pd.concat([y,data_n_2.iloc[:,0:6]],axis=1)
plt.figure(figsize=(10,10))
grid=sns.pairplot(data=data,kind ="scatter",hue="diagnosis",palette="Set1")
# Map the plots to the locations
grid = grid.map_upper(corr)
# First six features
data = pd.concat([y,data_n_2.iloc[:,6:12]],axis=1)
plt.figure(figsize=(10,10))
grid=sns.pairplot(data=data,kind ="scatter",hue="diagnosis",palette="Set1")
# Map the plots to the locations
#grid = grid.map_upper(plt.scatter, color = 'darkred')
grid = grid.map_upper(corr)
#grid = grid.map_lower(sns.kdeplot, cmap = 'Reds')
#grid = grid.map_diag(plt.hist, bins = 10, edgecolor = 'k', color = 'darkred');
# First six features
data = pd.concat([y,data_n_2.iloc[:,12:18]],axis=1)
plt.figure(figsize=(10,10))
grid=sns.pairplot(data=data,kind ="scatter",hue="diagnosis",palette="Set1")
# Map the plots to the locations
#grid = grid.map_upper(plt.scatter, color = 'darkred')
grid = grid.map_upper(corr)
#grid = grid.map_lower(sns.kdeplot, cmap = 'Reds')
#grid = grid.map_diag(plt.hist, bins = 10, edgecolor = 'k', color = 'darkred');
# First six features
data = pd.concat([y,data_n_2.iloc[:,18:24]],axis=1)
plt.figure(figsize=(10,10))
grid=sns.pairplot(data=data,kind ="scatter",hue="diagnosis",palette="Set1")
# Map the plots to the locations
#grid = grid.map_upper(plt.scatter, color = 'darkred')
grid = grid.map_upper(corr)
#grid = grid.map_lower(sns.kdeplot, cmap = 'Reds')
#grid = grid.map_diag(plt.hist, bins = 10, edgecolor = 'k', color = 'darkred');
# First six features
data = pd.concat([y,data_n_2.iloc[:,24:32]],axis=1)
plt.figure(figsize=(10,10))
grid=sns.pairplot(data=data,kind ="scatter",hue="diagnosis",palette="Set1")
# Map the plots to the locations
#grid = grid.map_upper(plt.scatter, color = 'darkred')
grid = grid.map_upper(corr)
#grid = grid.map_lower(sns.kdeplot, cmap = 'Reds')
#grid = grid.map_diag(plt.hist, bins = 10, edgecolor = 'k', color = 'darkred');
Swarm plot
sns.set(style="whitegrid", palette="Set1")
data_dia = y
data = x
data_n_2 = (data - data.mean()) / (data.std()) # standardization
data = pd.concat([y,data_n_2.iloc[:,0:10]],axis=1)
data = pd.melt(data,id_vars="diagnosis",
var_name="features",
value_name='value')
plt.figure(figsize=(10,10))
tic = time.time()
sns.swarmplot(x="features", y="value", hue="diagnosis", data=data)
plt.xticks(rotation=90)
data = pd.concat([y,data_n_2.iloc[:,10:20]],axis=1)
data = pd.melt(data,id_vars="diagnosis",
var_name="features",
value_name='value')
plt.figure(figsize=(10,10))
sns.swarmplot(x="features", y="value", hue="diagnosis", data=data)
plt.xticks(rotation=90)
data = pd.concat([y,data_n_2.iloc[:,20:31]],axis=1)
data = pd.melt(data,id_vars="diagnosis",
var_name="features",
value_name='value')
plt.figure(figsize=(10,10))
sns.swarmplot(x="features", y="value", hue="diagnosis", data=data)
toc = time.time()
plt.xticks(rotation=90)
print("swarm plot time: ", toc-tic ," s")
Στα παραπάνω διαγράμματα γίνεται πιο ξεκάθαρη η συσχέτιση των χαρακτηριστικών με εξαίρεση τα χαρακτηριστικά area_worst που στο τελευταίο σμήνος δείχνει ένα πλήρη διαχωρισμό μεταξύ της ομάδας M και B. Ακόμα, στο χαρακτηριστικό smoothness_se στο δεύτερο διάγραμμα σμήνους φαίνεται μια ανάμειξη μεταξύ των δύο group κάτι που κάνει δύσκολη την ταξινόμηση των στοιχείων. Έτσι, για να παρατηρήσουμε με περισσότερη λεπτομέρεια τα ζεύγη θα χρησιμοποιηθεί ένας χάρτης θερμότητας.
Heatmap
#correlation map
f,ax = plt.subplots(figsize=(18, 18))
sns.heatmap(x.corr(), annot=True, linewidths=.5, fmt= '.1f',ax=ax)
Όπως φαίνεται στο παραπάνω διάγραμμα θερμότητας τα χαρακτηριστικά radius_mean, perimeter_mean και area_mean συσχετίζονται μεταξύ τους. Όπως επίσης και τα compactness_mean, concavity_mean και concave points_mean, τα radius_se, perimeter_se και area_se. Ακόμα, τα radius_worst, το perimeter_worst και το area_worst, καθώς επίσης και τα compactness_worst, concavity_worst και concave points_worst. Ομοίως και τα compactness_se, concavity_se και concave points_se, τα texture_mean και texture_worst . Τέλος, και τα area_worst και area_mean συσχετίζονται μεταξύ τους.
Για μεγαλύτερη ακρίβεια στα αποτελέσματα καθώς και για να βρεθούν επιπλέον συσχετιζόμενα χαρακτηριστικά θα χρησιμοποιηθεί ένας τυχαίος ταξινομητή δασών (Random Forest Classifier).
Πίνακας συσχετίσεων
#αφαίρεση συσχετιζόμενων χαρακτηριστικών
drop_list1 = ['perimeter_mean','radius_mean','compactness_mean','concave points_mean','radius_se','perimeter_se','radius_worst','perimeter_worst','compactness_worst','concave points_worst','compactness_se','concave points_se','texture_worst','area_worst']
x_1 = x.drop(drop_list1,axis = 1 ) # do not modify x, we will use it later
x_1.head()
#correlation map
f,ax = plt.subplots(figsize=(14, 14))
sns.heatmap(x_1.corr(), annot=True, linewidths=.5, fmt= '.1f',ax=ax)
Επιλογή χαρακτηριστικών για μοντελοποίηση
Στην ενότητα αυτή θα γίνει η επιλογή μιας ομάδας χαρακτηριστικών, που θα χ ρησιμοποιηθεί για την δημιουργία των μοντέλων μηχανικής μάθησης που αναφέρθηκαν στην εισαγωγή. Η επιλογή των χαρακτηριστικών θα γίνει σύμφωνα με το πόσο το επιλεγμένο χαρακτηριστικό συμβάλλει περισσότερο στη πρόβλεψη ή στην εξαγωγή του επιθυμητού αποτελέσματος.
Σε τι οφελεί η επιλογή των σωστών μεταβλητών;
Επιλογή μεταβλητών με τη χρήση συσχέτισης
Παραπάνω με την εφαρμογή των θερμικών διαγραμμάτων καταλήξαμε ποιες μεταβλητές είναι συσχετιζόμενες, κάποιες από τις οποίες θα χρησιμοποιηθούν στη δημιουργία των μοντέλων. Οι μεταβλητές επιλέχθηκαν σύμφωνα με την εικόνα τους στα swar plots. Ουσιαστικά, επιλέχθηκαν αυτά που θεωρήθηκαν πιο "καθαρά" για επεξεργασία. Τα δεδομένα που επιλέχθηκαν δίνονται συνοπτικά παρακάτω.
Μέθοδοι επιλογής επικρατέστερων χαρακτηριστικών
1) Μέθοδος Συσχέτισης (Correlation)
Αφαίρεση χαρακτηριστικών με την μεγαλύτερη συσχέτιση
drop_list_cor = ['perimeter_mean','radius_mean','compactness_mean','concave points_mean','radius_se','perimeter_se','radius_worst','perimeter_worst','compactness_worst','concave points_worst','compactness_se','concave points_se','texture_worst','area_worst']
x_1 = x.drop(drop_list_cor,axis = 1 ) # do not modify x, we will use it later
x_1.head()
selected_feature_corr=x_1.columns
fs_corr = fs_corr.reset_index()
fs_corr.head()
#correlation map
f,ax = plt.subplots(figsize=(14, 14))
sns.heatmap(x_1.corr(), annot=True, linewidths=.5, fmt= '.1f',ax=ax)
Στη συνέχεια με τη βοήθεια της μεθόδου Random Forest θα γίνει έλεγχος για το κατ ά πόσο η επιλογή των μεταβλητών ήταν σωστή.
Έλεγχος ακρίβειας
# split data train 70 % and test 30 %
x_train, x_test, y_train, y_test = train_test_split(x_1, y, test_size=0.3, random_state=42)
#random forest classifier with n_estimators=10 (default)
clf_rf = RandomForestClassifier(random_state=43)
clr_rf = clf_rf.fit(x_train,y_train)
ac = accuracy_score(y_test,clf_rf.predict(x_test))
print('Accuracy is: ',ac)
cm = confusion_matrix(y_test,clf_rf.predict(x_test))
sns.heatmap(cm,annot=True,fmt="d")
Σύμφωνα με τον παραπάνω πίνακα σύγχισης, η ακρίβεια επιλογής των μεταβλητών είναι στο 96%
2) Μέθοδος Chi-square
Σε αυτή τη μέθοδο πρέπει να επιλέξουμε πόσα χαρακτηρι στικά θα χρησιμοποιήσουμε σύμφωνα με τη φιλοσοφία της μεθόδου SelectKBest που χρησιμοποιείται. Για παράδειγμα, το k (αριθμός χαρακτηριστικών) θα είναι 5 ή 10 ή 15; Η απάντηση προκύπτει είτε έπειτα από πολλαπλές δοκιμές ή διαισθητικά. Εδώ προσεγγίζεται διαισθητικά, οπότε επιλέχθηκαν k = 10 χαρακτηριστικά ώστε να προκύψουν τα καλύτερα 10.
# find best scored 10 features
select_feature = SelectKBest(chi2, k=10).fit(x_train, y_train)
np.set_printoptions(suppress=True)
print('Score list:', select_feature.scores_)
#print('Total feature list:', x_train.columns)
pd.options.display.float_format = '{:.2f}'.format
fs_chi2 = DataFrame(select_feature.scores_, columns = ["Chi_Square"], index=x_train.columns)
fs_chi2 = fs_chi2.reset_index()
fs_chi2 = fs_chi2.sort_values('Chi_Square',ascending=0)
fs_chi2
x_train_2 = select_feature.transform(x_train)
x_test_2 = select_feature.transform(x_test)
#random forest classifier with n_estimators=10 (default)
clf_rf_2 = RandomForestClassifier()
clr_rf_2 = clf_rf_2.fit(x_train_2,y_train)
ac_2 = accuracy_score(y_test,clf_rf_2.predict(x_test_2))
print('Accuracy is: ',ac_2)
cm_2 = confusion_matrix(y_test,clf_rf_2.predict(x_test_2))
sns.heatmap(cm_2,annot=True,fmt="d")
Η αρτιότητα της επιλογής των μεταβλητών επιβεβαιώνεται και μετά την εφαρμογή της μεθόδου chi-square, καθώς όπως και στη μέθοδο με την εφαρμογή correlation, έτσι και εδώ προέκυψε ακρίβεια 95%.
3) RFE με τυχαία δάση
Το RFE, χρησιμοποιεί μία από τις μεθόδους ταξινόμησης (τυχαίο δάσος εν προκειμένο) και εκχωρεί βάρη σε καθένα από τα χαρακτηριστικά. Τα χαρακτηριστικά με τα μικρότερα απόλυτα βάρη, αφαιρούνται από τα τρέχοντα χαρακτηριστικά του συνόλου. Αυτή η διαδικασία επαναλαμβάνεται αναδρομικά στο κλαδευμένο σύνολο μέχρι τον επιθυμητό αριθμό χαρακτηριστικών Όπως και στη προηγούμενη μέθοδο, θα χρησιμοποιηθούν 10 χαρακτηριστικά. Ωστόσο, για τον προσδιορισμό των 10 δυνατοτήτων που θα χρησιμοποιηθούν θα εφαρμοστεί η μέθοδος RFE.
# Create the RFE object and rank each pixel
clf_rf_3 = RandomForestClassifier()
rfe = RFE(estimator=clf_rf_3, n_features_to_select=10, step=1)
rfe = rfe.fit(x_train, y_train)
# let's print the number of total and selected features
fs_rfe = DataFrame(rfe.support_, columns = ["RFE"], index=x_train.columns)
fs_rfe = fs_rfe.reset_index()
# this is how we can make a list of the selected features
# let's print some stats
print('total features: {}'.format((x_train.shape[1])))
print('selected features: {}'.format(len(x_train.columns[rfe.support_])))
print('Chosen best 10 feature by rfe:',x_train.columns[rfe.support_])
x_train_3 = select_feature.transform(x_train)
x_test_3 = select_feature.transform(x_test)
#random forest classifier with n_estimators=10 (default)
clf_rf_3 = RandomForestClassifier()
clr_rf_3 = clf_rf_3.fit(x_train_3,y_train)
ac_3 = accuracy_score(y_test,clf_rf_3.predict(x_test_3))
print('Accuracy is: ',ac_3)
cm_3 = confusion_matrix(y_test,clf_rf_3.predict(x_test_3))
sns.heatmap(cm_3,annot=True,fmt="d")
Τα 10 καλύτερα χαρακτηριστικά που επιλέχθηκαν από το RFE είναι τα texture_mean, area_mean, smoothness_mean, concavity_mean, area_se, concavity_se, fractal_dimension_se, concavity_worst, symmetry_worst, fractal_dimension_worst.
Τα οποία είναι παρόμοια με την προηγούμενη μέθοδο . Επομένως δεν χρειάζεται να υπολογίσουμε ξανά την ακρίβεια, παρ' όλα αυτά για λόγους επιβεβαίωσης προέκυψε ότι η ακρίβεια είναι πάλι στο 96% όπως και στα προηγούμενα μοντέλα.
4) RFECV με τη χρήση τυχαίων δασών
# The "accuracy" scoring is proportional to the number of correct classifications
clf_rf_4 = RandomForestClassifier()
rfecv = RFECV(estimator=clf_rf_4, step=1, cv=5,scoring='accuracy') #5-fold cross-validation
rfecv = rfecv.fit(x_train, y_train)
# let's print the number of total and selected features
fs_rfecv = DataFrame(rfecv.support_, columns = ["RFECV"], index=x_train.columns)
fs_rfecv = fs_rfecv.reset_index()
# this is how we can make a list of the selected features
# let's print some stats
print('total features: {}'.format((x_train.shape[1])))
print('selected features: {}'.format(len(x_train.columns[rfecv.support_])))
print('Optimal number of features :', rfecv.n_features_)
print('Best features by rfecv:',x_train.columns[rfecv.support_])
# Plot number of features VS. cross-validation scores
plt.figure()
plt.xlabel("Number of features selected")
plt.ylabel("Cross validation score of number of selected features")
plt.plot(range(1, len(rfecv.grid_scores_) + 1), rfecv.grid_scores_)
plt.show()
x_train_4 = select_feature.transform(x_train)
x_test_4 = select_feature.transform(x_test)
#random forest classifier with n_estimators=10 (default)
clf_rf_4 = RandomForestClassifier()
clr_rf_4 = clf_rf_4.fit(x_train_4,y_train)
ac_4 = accuracy_score(y_test,clf_rf_4.predict(x_test_4))
print('Accuracy is: ',ac_4)
cm_4 = confusion_matrix(y_test,clf_rf_4.predict(x_test_4))
sns.heatmap(cm_4,annot=True,fmt="d")
Έτσι, και εδώ βλέπουμε ότι η ακρίβεια επίσης είναι αρκετά υψηλή αγγίζοντας το 97%.
5) Random Forest
Στη μέθοδο τυχαίας ταξινόμησης δασών υπάρχει μια βασική συνάρτηση που επιλέγει τη σημαντικότητα ενός χαρακτηριστικού (όσο υψηλότερη είναι, τόσο πιο σημαντικό είναι το χαρακτηριστικό).
Για να χρησιμοποιήσετε τη μέθοδο feature_importance, στα δεδομένα εκπαίδευσης δεν θα πρέπει να υπάρχουν συσχετισμένα χαρακτηριστικά. Το τυχαίο δάσος επιλέγει τυχαία σε κάθε επανάληψη. Αυτό σημαίνει ότι η ακολουθία της λίστας σημασίας των χαρακτηριστικών μπορεί να αλλάξει.
clf_rf_5 = RandomForestClassifier()
clr_rf_5 = clf_rf_5.fit(x_train,y_train)
importances = clr_rf_5.feature_importances_
std = np.std([tree.feature_importances_ for tree in clf_rf.estimators_],
axis=0)
indices = np.argsort(importances)[::-1]
# Print the feature ranking
print("Feature ranking:")
for f in range(x_train.shape[1]):
print("%d. feature %d (%f)" % (f + 1, indices[f], importances[indices[f]]))
# Plot the feature importances of the forest
plt.figure(1, figsize=(14, 13))
plt.title("Feature importances")
plt.bar(range(x_train.shape[1]), importances[indices],
color="g", yerr=std[indices], align="center")
plt.xticks(range(x_train.shape[1]), x_train.columns[indices],rotation=90)
plt.xlim([-1, x_train.shape[1]])
plt.show()
indices = np.argsort(importances)[::-1]
indices
importances[indices]
# let's print the number of total and selected features
# let's print some stats
print('total features: {}'.format((x_train.shape[1])))
#print('Chosen optimal features by rf:',selected_feature_rf[1:10])
fs_rf = DataFrame(clr_rf_5.feature_importances_, columns = ["RF"], index=x_train.columns)
fs_rf = fs_rf.reset_index()
fs_rf = fs_rf.sort_values('RF',ascending=0)
fs_rf
x_train_5 = select_feature.transform(x_train)
x_test_5 = select_feature.transform(x_test)
#random forest classifier with n_estimators=10 (default)
clf_rf_5 = RandomForestClassifier()
clr_rf_5 = clf_rf_5.fit(x_train_5,y_train)
ac_5 = accuracy_score(y_test,clf_rf_5.predict(x_test_5))
print('Accuracy is: ',ac_5)
cm_5 = confusion_matrix(y_test,clf_rf_5.predict(x_test_5))
sns.heatmap(cm_5,annot=True,fmt="d")
6) L1-based (LinearSVC)
lsvc = LinearSVC(C=0.01, penalty="l1", dual=False,max_iter=2000).fit(x_train, y_train)
model = SelectFromModel(lsvc, prefit=True)
x_new = model.transform(x_train)
print(x_train.columns[model.get_support()])
# let's print the number of total and selected features
fs_l1 = DataFrame(model.get_support(), columns = ["L1"], index=x_train.columns)
fs_l1 = fs_l1.reset_index()
# this is how we can make a list of the selected fes
selected_feature_lsvc = x_train.columns[model.get_support()]
# let's print some stats
print('total features: {}'.format((x_train.shape[1])))
print('selected features: {}'.format(len(selected_feature_lsvc)))
print('Best features by lsvc:',x_train.columns[model.get_support()])
x_train_6 = select_feature.transform(x_train)
x_test_6 = select_feature.transform(x_test)
#random forest classifier with n_estimators=10 (default)
clf_rf_6 = RandomForestClassifier()
clr_rf_6 = clf_rf_6.fit(x_train_6,y_train)
ac_6 = accuracy_score(y_test,clf_rf_6.predict(x_test_6))
print('Accuracy is: ',ac_6)
cm_6 = confusion_matrix(y_test,clf_rf_6.predict(x_test_6))
sns.heatmap(cm_6,annot=True,fmt="d")
7) Extra Trees
# Build a forest and compute the impurity-based feature importances
clf = ExtraTreesClassifier(n_estimators=32,random_state=0)
clf.fit(x_train, y_train)
clf.feature_importances_
importances = clf.feature_importances_
std = np.std([tree.feature_importances_ for tree in clf.estimators_],
axis=0)
indices = np.argsort(importances)[::-1]
# Print the feature ranking
print("Feature ranking:")
for f in range(x_train.shape[1]):
print("%d. feature %d (%f)" % (f + 1, indices[f], importances[indices[f]]))
# Plot the impurity-based feature importances of the forest
plt.figure(1, figsize=(14, 13))
plt.title("Feature importances")
plt.bar(range(x_train.shape[1]), importances[indices],
color="r", yerr=std[indices], align="center")
plt.xticks(range(x_train.shape[1]), x_train.columns[indices],rotation=90)
plt.xlim([-1, x_train.shape[1]])
plt.show()
# let's print the number of total and selected features
# this is how we can make a list of the selected features
selected_feature_extraTrees = x_train.columns[model.get_support()]
# let's print some stats
print('total features: {}'.format((x_train.shape[1])))
print('selected features: {}'.format(len(selected_feature_extraTrees)))
print('Best features by ExtraTrees:',x_train.columns[model.get_support()])
fs_extratrees=DataFrame(clf.feature_importances_, columns = ["Extratrees"], index=x_train.columns)
fs_extratrees = fs_extratrees.reset_index()
fs_extratrees = fs_extratrees.sort_values(['Extratrees'],ascending=0)
fs_extratrees
x_train_7 = select_feature.transform(x_train)
x_test_7 = select_feature.transform(x_test)
#random forest classifier with n_estimators=10 (default)
clf_rf_7 = RandomForestClassifier()
clr_rf_7 = clf_rf_7.fit(x_train_7,y_train)
ac_7 = accuracy_score(y_test,clf_rf_7.predict(x_test_7))
print('Accuracy is: ',ac_2)
cm_7 = confusion_matrix(y_test,clf_rf_7.predict(x_test_7))
sns.heatmap(cm_7,annot=True,fmt="d")
8) Vote based selection
fs_extratrees.shape
dfs = [fs_corr, fs_chi2, fs_rfe, fs_rfecv, fs_rf, fs_l1, fs_extratrees]
final_results = reduce(lambda left,right: pd.merge(left,right,on='index'), dfs)
final_results.head()
final_results.columns
columns = ['Chi_Square', 'RF', 'Extratrees']
score_table = pd.DataFrame({},[])
score_table['index'] = final_results['index']
for i in columns:
score_table[i] = final_results['index'].isin(final_results.nlargest(10,i)['index']).astype(int)
#score_table['Corr'] = final_results['Corr'].astype(int)
score_table['RFE'] = final_results['RFE'].astype(int)
score_table['RFECV'] = final_results['RFECV'].astype(int)
score_table['L1'] = final_results['L1'].astype(int)
score_table['final_score'] = score_table.sum(axis=1)
score_table.sort_values('final_score',ascending=0)
# Voted features
score_table['index'][score_table['final_score']>=2]
# RFE features
score_table['index'][score_table['RFE']==1]
# RFECV features
score_table['index'][score_table['RFECV']==1]
# Chi-Square features
score_table['index'][score_table['Chi_Square']==1]
# RF features
score_table['index'][score_table['RF']==1]
# L1 features
score_table['index'][score_table['L1']==1]
# ExtraTrees features
score_table['index'][score_table['Extratrees']==1]
Πολυγραμμικότητα (Multicollinearity) - VIF
Η πολυσυγγραμμικότητα αποτελει πρόβλημα σε ένα μοντέλο παλινδρόμησης, επειδή δεν θα ήταν εφικτό να διακρίνουμε μεταξύ των επιμέρους επιδράσεων των ανεξάρτητων μεταβλητών την επιρροής που α σκούν στην εξαρτημένη μεταβλητή. Με τη βοήθεια του μοντέλου VIF (Variable Inflation Factors) μπορούμε να καθορίσουμε που υπάρχει πρόβλημα.
def calculate_vif(features):
vif = pd.DataFrame()
vif["Features"] = features.columns
vif["VIF"] = [variance_inflation_factor(features.values, i) for i in range(features.shape[1])]
return(vif)
vif = calculate_vif(x_train)
while vif['VIF'][vif['VIF'] > 10].any():
remove = vif.sort_values('VIF',ascending=0)['Features'][:1]
x_train.drop(remove,axis=1,inplace=True)
vif = calculate_vif(x_train)
vif
Εξαγωγή δεδομένων με τη τεχνική PCA
Θα χρησιμοποιήσουμε την ανάλυση βασικών συνιστωσών (PCA) για την εξαγωγή χαρακτηριστικών. Πριν από το PCA, π ρέπει να κανονικοποιήσουμε τα δεδομένα για καλύτερη απόδοση του PCA.
# split data train 70 % and test 30 %
x_train, x_test, y_train, y_test = train_test_split(x, y, test_size=0.3, random_state=42)
#normalization
x_train_N = (x_train-x_train.mean())/(x_train.max()-x_train.min())
x_test_N = (x_test-x_test.mean())/(x_test.max()-x_test.min())
pca = PCA()
pca.fit(x_train_N)
plt.figure(1, figsize=(10, 9))
plt.clf()
plt.axes([.2, .2, .7, .7])
plt.plot(pca.explained_variance_ratio_, linewidth=2)
plt.axis('tight')
plt.xlabel('n_components')
plt.ylabel('explained_variance_ratio_')
Σύμφωνα με τη διακύμανση φαίνεται ότι επιλέχθηκαν 3 χαρακτηριστικά.
Μοντέλα Μηχανικής Μάθησης
Συνάρτηση για τη φόρτωση και προετοιμασία δεδομένων
Παρόλο που τα δεδομένα έχουν ήδη επεξεργαστεί, θα δημιουργηθεί μια επιπλέον συνάρτηση η οποία θα εισάγει εκ νέου τα δεδομένα ώστε να τα προσαρμόσει κατάλληλα στις ανάγκες των μοντέλων. Όπως για παράδειγμα την αντικατάσταση των χαρακτήρων Β & Μ με 0 και 1 ώστε να μπορούν να προσπελαστούν ευκολότερα από τα μοντέλα μηχανικής μάθησης που θα δημιουργηθούν στην συνέχεια.
def LoadData():
global feature_names, response_name, n_features, model_full
model_full = pd.read_csv('/work/Data/data.csv')
# we change the class values (at the column number 2) from B to 0 and from M to 1
model_full.iloc[:,1].replace('B', 0,inplace=True)
model_full.iloc[:,1].replace('M', 1,inplace=True)
response_name = ['diagnosis']
drop_list = ['Unnamed: 32','id','diagnosis']
model_full_x= model_full.drop(drop_list,axis = 1)
X = model_full_x
y = model_full.diagnosis
X_train, X_test, y_train, y_test = train_test_split(X,
y,
test_size = 0.3,
random_state = 12345)
return X_train, y_train, X_test, y_test
Προσδιορισμός των χαρακτηριστικών που θα επιλεγούν
Στη συνέχεια θα προσδιοριστούν τα χαρακτηριστικά που εξήχθηκαν προς επιλογή παραπάνω ανά μέθοδο .
# 1. Feature selection with correlation (16)
fs_corr = ['texture_mean', 'area_mean', 'smoothness_mean', 'concavity_mean','symmetry_mean',
'fractal_dimension_mean', 'texture_se', 'area_se','smoothness_se', 'concavity_se',
'symmetry_se', 'fractal_dimension_se','smoothness_worst', 'concavity_worst',
'symmetry_worst', 'fractal_dimension_worst']
# 2. Univariate feature selection SelectKBest, chi2
fs_chi2 = ['texture_mean', 'area_mean', 'concavity_mean', 'symmetry_mean', 'area_se',
'concavity_se', 'smoothness_worst', 'concavity_worst', 'symmetry_worst',
'fractal_dimension_worst']
# 3. Recursive feature elimination (RFE) with random forest
fs_rfe = ['texture_mean', 'area_mean', 'smoothness_mean', 'concavity_mean', 'area_se',
'smoothness_se', 'concavity_se', 'smoothness_worst', 'concavity_worst', 'symmetry_worst']
# 4. Recursive feature elimination with cross validation(RFECV) with random forest
fs_rfecv = ['texture_mean', 'area_mean', 'smoothness_mean', 'concavity_mean','fractal_dimension_mean'
, 'area_se', 'concavity_se', 'concavity_worst', 'symmetry_worst']
# 5. Tree based feature selection with random forest classification
fs_rf = ['texture_mean', 'area_mean', 'concavity_mean', 'area_se', 'concavity_se',
'fractal_dimension_se', 'smoothness_worst','concavity_worst', 'symmetry_worst',
'fractal_dimension_worst']
# 6. ExtraTree based feature selection
fs_extraTree = ['texture_mean', 'area_mean', 'concavity_mean', 'fractal_dimension_mean', 'area_se',
'concavity_se','smoothness_worst', 'concavity_worst',
'symmetry_worst','fractal_dimension_worst']
# 7. L1 feature selection (LinearSVC)
fs_l1 = ['texture_mean', 'area_mean', 'area_se']
# 8. Vote based feature selection
fs_voted = ['texture_mean', 'area_mean', 'smoothness_mean', 'concavity_mean',
'fractal_dimension_mean', 'area_se', 'concavity_se', 'smoothness_worst',
'concavity_worst', 'symmetry_worst', 'fractal_dimension_worst']
x_train, y_train, x_test, y_test = LoadData()
Επιλογή μεθόδου
# Correlation
X_train = x_train[fs_corr]
X_test = x_test[fs_corr]
# scaling data
scale = StandardScaler()
X_train = scale.fit_transform(X_train)
X_test = scale.fit_transform(X_test)
print('Correlation method')
print ('----------------------------')
print('Size of data:')
print ('The train data has {0} rows and {1} columns'.format(X_train.shape[0],X_train.shape[1]))
print ('The test data has {0} rows and {1} columns'.format(X_test.shape[0],X_test.shape[1]))
print ('----------------------------')
# Chi2
X_train = x_train[fs_chi2]
X_test = x_test[fs_chi2]
# scaling data
scale = StandardScaler()
X_train = scale.fit_transform(X_train)
X_test = scale.fit_transform(X_test)
print('Chi-square method')
print ('----------------------------')
print('Size of data:')
print ('The train data has {0} rows and {1} columns'.format(X_train.shape[0],X_train.shape[1]))
print ('The test data has {0} rows and {1} columns'.format(X_test.shape[0],X_test.shape[1]))
print ('----------------------------')
# RFE
X_train = x_train[fs_rfe]
X_test = x_test[fs_rfe]
# scaling data
scale = StandardScaler()
X_train = scale.fit_transform(X_train)
X_test = scale.fit_transform(X_test)
print('RFE method')
print ('----------------------------')
print('Size of data:')
print ('The train data has {0} rows and {1} columns'.format(X_train.shape[0],X_train.shape[1]))
print ('The test data has {0} rows and {1} columns'.format(X_test.shape[0],X_test.shape[1]))
print ('----------------------------')
# RFECV
X_train = x_train[fs_rfecv]
X_test = x_test[fs_rfecv]
# scaling data
scale = StandardScaler()
X_train = scale.fit_transform(X_train)
X_test = scale.fit_transform(X_test)
print('RFECV method')
print ('----------------------------')
print('Size of data:')
print ('The train data has {0} rows and {1} columns'.format(X_train.shape[0],X_train.shape[1]))
print ('The test data has {0} rows and {1} columns'.format(X_test.shape[0],X_test.shape[1]))
print ('----------------------------')
# RF
X_train = x_train[fs_rf]
X_test = x_test[fs_rf]
# scaling data
scale = StandardScaler()
X_train = scale.fit_transform(X_train)
X_test = scale.fit_transform(X_test)
print('RF method')
print ('----------------------------')
print('Size of data:')
print ('The train data has {0} rows and {1} columns'.format(X_train.shape[0],X_train.shape[1]))
print ('The test data has {0} rows and {1} columns'.format(X_test.shape[0],X_test.shape[1]))
print ('----------------------------')
# Extra Trees
X_train = x_train[fs_extraTree]
X_test = x_test[fs_extraTree]
# scaling data
scale = StandardScaler()
X_train = scale.fit_transform(X_train)
X_test = scale.fit_transform(X_test)
print('Extra method')
print ('----------------------------')
print('Size of data:')
print ('The train data has {0} rows and {1} columns'.format(X_train.shape[0],X_train.shape[1]))
print ('The test data has {0} rows and {1} columns'.format(X_test.shape[0],X_test.shape[1]))
print ('----------------------------')
# l1
X_train = x_train[fs_l1]
X_test = x_test[fs_l1]
# scaling data
scale = StandardScaler()
X_train = scale.fit_transform(X_train)
X_test = scale.fit_transform(X_test)
print('L1-based method')
print ('----------------------------')
print('Size of data:')
print ('The train data has {0} rows and {1} columns'.format(X_train.shape[0],X_train.shape[1]))
print ('The test data has {0} rows and {1} columns'.format(X_test.shape[0],X_test.shape[1]))
print ('----------------------------')
# Voted
X_train = x_train[fs_voted]
X_test = x_test[fs_voted]
# scaling data
scale = StandardScaler()
X_train = scale.fit_transform(X_train)
X_test = scale.fit_transform(X_test)
print('Vote based method')
print ('----------------------------')
print('Size of data:')
print ('The train data has {0} rows and {1} columns'.format(X_train.shape[0],X_train.shape[1]))
print ('The test data has {0} rows and {1} columns'.format(X_test.shape[0],X_test.shape[1]))
print ('----------------------------')
Καμπύλες ROC και καμπύλες Ακρίβειας-Ανάκλησης
def Plot_ROC_Precision_Recall(label):
class_names = [0, 1]
fig, (left, right) = plt.subplots(nrows=1, ncols=2, figsize=(10, 5))
plt.subplot(1, 2, 1)
plt.plot([0, 1], [0, 1], 'k--')
plt.plot(false_positive_rate, true_positive_rate, color='darkorange', label=label)
plt.xlabel('False positive rate')
plt.ylabel('True positive rate')
plt.title('ROC curve (area = %0.7f)' % auc)
plt.legend(loc='best')
plt.subplot(1, 2, 2)
precision, recall, _ = precision_recall_curve(y_test, y_probabilities_success)
plt.step(recall, precision, color='b', alpha=0.2, where='post')
plt.fill_between(recall, precision, step='post', alpha=0.2, color='b')
plt.xlabel('Recall')
plt.ylabel('Precision')
plt.ylim([0.0, 1.05])
plt.xlim([0.0, 1.0])
plt.title('Precision-Recall curve: AP={0:0.2f}'.format(average_precision))
plt.tight_layout()
plt.show()
Επιλογή χαρακτηριστικού γνωρίσματος
def Plot_Predictor_Importance(logisticRegression = True):
if(logisticRegression):
feature_importance = best_model.feature_importances_
feature_importance = 100.0 * (feature_importance / feature_importance.max())
sorted_idx = np.argsort(feature_importance)
y_pos = np.arange(sorted_idx.shape[0]) + .5
fig, ax = plt.subplots()
fig.set_size_inches(8, 5)
ax.barh(y_pos, feature_importance[sorted_idx], align='center', color='green', ecolor='black', height=0.5)
ax.set_yticks(y_pos)
ax.set_yticklabels(feature_names)
ax.invert_yaxis()
ax.set_xlabel('Relative Importance')
ax.set_title('Predictor Importance')
plt.show()
Σύνοψη μετρήσεων για το επιλεγμένο μοντέλο
def Print_Model_Metrics(algoName):
global testPerformanceData
true_negative = cm[0, 0]
true_positive = cm[1, 1]
false_negative = cm[1, 0]
false_positive = cm[0, 1]
total = true_negative + true_positive + false_negative + false_positive
accuracy_ = (true_positive + true_negative)/total
precision_ = (true_positive)/(true_positive + false_positive)
recall_ = (true_positive)/(true_positive + false_negative)
misclassification_rate = (false_positive + false_negative)/total
F1_ = (2*true_positive)/(2*true_positive + false_positive + false_negative)
assert accuracy == accuracy_, "accuracy score does not agree"
assert precision == precision_, "precision score does not agree"
assert recall == recall_, "recall score does not agree"
assert round(F1,6) == round(F1_,6), "F1: " + str(F1) + " != F1_: " + str(F1_)
header = ["Metric", "Testing Performance"]
table = [["accuracy", accuracy],
["precision", precision],
["recall", recall],
["misclassification rate", misclassification_rate],
["F1", F1],
["r2", r2],
["AUC", auc],
["mse", mse],
["logloss", logloss]
]
print(tabulate(table, header, tablefmt="fancy_grid"))
testPerformanceData = testPerformanceData.append({'Algorithm' : algoName,'Accuracy' : accuracy,'AUC' : auc,'Precision' : precision,'Recall' : recall,'F1' : F1},ignore_index = True)
Δημιουργία πίνακα σύγχισης
def Plot_Confusion_Matrix(best_model):
cmap = plt.cm.Blues
plt.imshow(cm, interpolation='nearest', cmap=cmap)
title='Confusion matrix (on test data)'
classes = [0, 1]
plt.title(title)
plt.colorbar()
tick_marks = np.arange(len(classes))
plt.xticks(tick_marks, classes, rotation=0)
plt.yticks(tick_marks, classes)
thresh = cm.max() / 2.
for i, j in itertools.product(range(cm.shape[0]), range(cm.shape[1])):
plt.text(j, i, cm[i, j],
horizontalalignment="center",
color="white" if cm[i, j] > thresh else "black")
plt.tight_layout()
plt.ylabel('True label')
plt.xlabel('Predicted label')
c_report = classification_report(y_test, y_predicted_test)
print('\nClassification report:\n', c_report)
ntotal = len(y_test)
correct = y_test == y_predicted_test
numCorrect = sum(correct)
percent = round( (100.0*numCorrect)/ntotal, 6)
print("\nCorrect classifications on test data: {0:d}/{1:d} {2:8.3f}%".format(numCorrect,
ntotal,
percent))
prediction_score = 100.0*best_model.score(X_test, y_test)
assert (round(percent,3) == round(prediction_score, 3)), "prediction score does not agree"
def dataPreProc(fs):
X_train, y_train, X_test, y_test = LoadData(fs)
seed = 7
np.random.seed(seed)
# scaling data
scale = StandardScaler()
X_tr = scale.fit_transform(X_train)
X_te = scale.fit_transform(X_test)
return X_tr, X_te
def timer(start_time=None):
if not start_time:
start_time = datetime.now()
return start_time
elif start_time:
thour, temp_sec = divmod((datetime.now() - start_time).total_seconds(), 3600)
tmin, tsec = divmod(temp_sec, 60)
print('\n Time taken: %i hours %i minutes and %s seconds.' % (thour, tmin, round(tsec, 2)))
def best_mdl():
print('\n Best estimator:')
print(model.best_estimator_)
print('\n Best score:')
print(model.best_score_ * 2 - 1)
print('\n Best parameters:')
print(model.best_params_)
results = pd.DataFrame(model.cv_results_)
print('\n CV results:')
print(results.head())
#best_model = results.best_estimator_
#best_model = model_result.best_estimator_
best_model = model.best_estimator_
return best_model
Ανάλυση EDA
#X_train, y_train, X_test, y_test = LoadData()
model_full.head()
model_full.describe()
model_full.dtypes
# lets get the % of Cancer Patients
print('Distribution of Cancer patients on whole data')
ax = sns.countplot(model_full['diagnosis'])
ax.set_ylabel('Percentage of patients (%)')
bars = ax.patches
half = int(len(bars)/2)
left_bars = bars[:half]
right_bars = bars[half:]
for left, right in zip(left_bars, right_bars):
height_l = left.get_height()
height_r = right.get_height()
total = height_l + height_r
ax.text(left.get_x() + left.get_width()/2., height_l + 40, '{0:.0%}'.format(height_l/total), ha="center")
ax.text(right.get_x() + right.get_width()/2., height_r + 40, '{0:.0%}'.format(height_r/total), ha="center")
no, yes = model_full['diagnosis'].value_counts()
#X_train, y_train, X_test, y_test = LoadData()
print('Distribution of the data:')
print ('----------------------------------------------------')
print ('The total data has {0} rows and {1} columns'.format(model_full.shape[0],model_full.shape[1]))
print ('')
print ('Malignent cases = {0} and % = {1} '.format(yes,np.round((yes/model_full.shape[0])*100,2)))
print ('')
print ('Benign cases = {0} and % = {1} '.format(no,np.round((no/model_full.shape[0])*100,2)))
print ('')
print ('----------------------------------------------------')
print ('Distribution of training data')
print ('----------------------------------------------------')
print ('The train data has {0} rows and {1} columns'.format(X_train.shape[0],X_train.shape[1]))
print ('')
print ('The training data % = {0} '.format(np.round((X_train.shape[0]/model_full.shape[0])*100,2)))
print ('')
y_tr = y_train.sum()
n_tr = X_train.shape[0] -y_tr #yes1
print ('Malignent cases = {0} and % = {1} '.format(y_tr,np.round((y_tr/X_train.shape[0])*100,2)))
print ('')
print ('Benign cases = {0} and % = {1} '.format(n_tr,np.round((n_tr/X_train.shape[0])*100,2)))
print ('')
print ('----------------------------------------------------')
print ('Distribution of testing data')
print ('----------------------------------------------------')
print ('The test data has {0} rows and {1} columns'.format(X_test.shape[0],X_test.shape[1]))
print ('')
print ('The testing data % = {0} '.format(np.round((X_test.shape[0]/model_full.shape[0])*100,2)))
print ('')
y_te = y_test.sum()
n_te = X_test.shape[0] -y_te
print ('Malignent cases = {0} and % = {1} '.format(y_te,np.round((y_te/X_test.shape[0])*100,2)))
print ('')
print ('Benign cases = {0} and % = {1} '.format(n_te,np.round((n_te/X_test.shape[0])*100,2)))
print ('')
# lets get the % of Blood Transfusion patients
print('Training data : Distribution of patients')
ax = sns.countplot(y_train)
ax.set_ylabel('Percentage of patients (%)')
bars = ax.patches
half = int(len(bars)/2)
left_bars = bars[:half]
right_bars = bars[half:]
for left, right in zip(left_bars, right_bars):
height_l = left.get_height()
height_r = right.get_height()
total = height_l + height_r
ax.text(left.get_x() + left.get_width()/2., height_l + 40, '{0:.0%}'.format(height_l/total), ha="center")
ax.text(right.get_x() + right.get_width()/2., height_r + 40, '{0:.0%}'.format(height_r/total), ha="center")
# lets get the % of Blood Transfusion patients
print('Testing data : Distribution of patients')
ax = sns.countplot(y_test)
ax.set_ylabel('Percentage of patients (%)')
bars = ax.patches
half = int(len(bars)/2)
left_bars = bars[:half]
right_bars = bars[half:]
for left, right in zip(left_bars, right_bars):
height_l = left.get_height()
height_r = right.get_height()
total = height_l + height_r
ax.text(left.get_x() + left.get_width()/2., height_l + 40, '{0:.0%}'.format(height_l/total), ha="center")
ax.text(right.get_x() + right.get_width()/2., height_r + 40, '{0:.0%}'.format(height_r/total), ha="center")
Δημιουργία μοντέλων
Προσδιορισμός ταξινομητών (classifiers)
nonlr_clf_dict = dict()
clf = LogisticRegression()
nonlr_clf_dict['Logistic Regression'] = clf
clf = RandomForestClassifier()
nonlr_clf_dict['Random Forest Classifier'] = clf
clf = GradientBoostingClassifier()
nonlr_clf_dict['Gradient Boosting Classifier'] = clf
clf = ExtraTreesClassifier()
nonlr_clf_dict['Extra Trees Classifier'] = clf
clf = XGBClassifier()
nonlr_clf_dict['XGB Classifier'] = clf
clf = KNeighborsClassifier()
nonlr_clf_dict['KNeighbors Classifier'] = clf
clf = SVC(kernel='rbf',probability=True)
nonlr_clf_dict['SVM Classifier'] = clf
Υλοποίηση μοντέλων
folds = 5
param_comb = 5
skf = StratifiedKFold(n_splits=folds, shuffle = True, random_state = 10345)
scoring_strings = ['accuracy', 'precision', 'recall', 'f1',
'average_precision', 'roc_auc']
trainPerformanceData = pd.DataFrame(columns = ['Algorithm','Scoring Name','CV mean', 'CV std'])
testPerformanceData = pd.DataFrame(columns = ['Algorithm','Accuracy','AUC','Precision','Recall','F1'])
# timing starts from this point for "start_time" variable
#start_time = timer(None)
for clf_name, clf in nonlr_clf_dict.items():
for scoring in scoring_strings:
scores = cross_val_score(clf, X_train, y_train, scoring=scoring, cv=skf,verbose=1, n_jobs=2)
print("---------------------------------------------------------------------")
print(clf_name)
print("---------------------------------------------------------------------")
print("Cross Validation scores on training data")
print ('Scoring Name: CV mean: %.5f CV std: %.5f',scoring,np.mean(np.abs(scores)),np.std(scores))
print("")
# append rows to an empty DataFrame
trainPerformanceData = trainPerformanceData.append({'Algorithm' : clf_name, 'Scoring Name' : scoring, 'CV mean' : np.mean(np.abs(scores)),'CV std' : np.std(scores)},
ignore_index = True)
clf.fit(X_train, y_train)
y_predicted_test = clf.predict(X_test)
y_probabilities_test = clf.predict_proba(X_test)
y_probabilities_success = y_probabilities_test[:, 1]
from sklearn.metrics import average_precision_score
average_precision = average_precision_score(y_test, y_probabilities_success)
print('Average precision-recall score: {0:0.2f}'.format(average_precision))
false_positive_rate, true_positive_rate, threshold = roc_curve(y_test, y_probabilities_success)
mse = mean_squared_error(y_test, y_predicted_test)
logloss = log_loss(y_test, y_predicted_test)
accuracy = accuracy_score(y_test, y_predicted_test)
precision = precision_score(y_test, y_predicted_test, average='binary')
recall = recall_score(y_test, y_predicted_test, average='binary')
F1 = f1_score(y_test, y_predicted_test)
r2 = r2_score(y_test, y_predicted_test)
auc = roc_auc_score(y_test, y_predicted_test)
cm = confusion_matrix(y_test, y_predicted_test)
testPerformanceData = testPerformanceData.append({'Algorithm' : clf_name,'Accuracy' : accuracy,'Average_Precision':average_precision,'F1' : F1 ,'Precision' : precision,'Recall' : recall,'AUC' : auc},ignore_index = True)
Print_Model_Metrics(clf_name)
Plot_Confusion_Matrix(clf)
Plot_ROC_Precision_Recall(clf_name)
auc = roc_auc_score(y_test, clf.predict_proba(X_test)[:, 1])
print("")
print("AUC scores on testing data")
print(clf_name, 'auc score:', auc)
trainPerformanceData
trainPerformanceData_pvt=pd.pivot_table(trainPerformanceData,index=["Algorithm"],values=["CV mean"],columns=["Scoring Name"],aggfunc=[np.min])
trainPerformanceData_pvt
testPerformanceData.sort_values(by=['Algorithm'])
# plotting the coefficient score
fig, ax = plt.subplots(figsize =(6, 4))
color =['tab:blue', 'tab:orange', 'tab:green', 'tab:red', 'tab:purple', 'tab:olive', 'tab:cyan']
ax.barh(testPerformanceData["Algorithm"], testPerformanceData['AUC'], color = color)
#ax.spines['bottom'].set_position('zero')
plt.style.use('ggplot')
plt.ylabel('Algorithm')
plt.xlabel('AUC')
plt.title('AUC value of Algorithms ')
plt.show()
Συμπεράσματα
Έτσι, τα πιο σημαντικά χαρακτηριστικά για την πρόβλεψη κακοήθους ή καλοήθους όγκου για καρκινοπαθείς που λαμβάνονται με αλγόριθμους είναι τα texture_mean, area_mean, concavity_mean, area_se, concavity_se, fractal_dimension_se, smoothness_worst, concavity_worst, symmetry_worst_worst, fractal_worst.
Για να ληφθούν καλύτερα αποτελέσματα από το προγνωστικό μοντέλο, πολλά διαφορετικά μοντέλα εκπαιδεύονται, βελτιστοποιούνται και αξιολογούνται χρησιμοποιώντας 16 σετ χαρακτηριστικών. Κατά τη διάρκεια αυτής της διαδικασίας, το ίδιο το σύνολο χαρακτηριστικών καταργείται χρησιμοποιώντας μεθόδους ειδικές για το μοντέλο.
Κάθε μοντέλο και υποσύνολο χαρακτηριστικών αξιολογείται χρησιμοποιώντας την Ακρίβεια, AUC και ευαισθησία χρησιμοποιώντας πενταπλάσια διασταυρούμενη επικύρωση.
Τα καλύτερα αποτελέσματα επιτυγχάνονται με την λογιστική παλινδρόμηση, με το σύνολο χαρακτηριστικών τυχαίων δασών να συλλέγεται σε 10 χαρακτηριστικά. Ο παραπάνω πίνακας δείχνει τα μέτρα απόδοσης των τεχνικών ταξινόμησης. Η λογιστική παλινδρόμηση πέτυχε ακρίβεια και AUC 0,977 και 0,971 στα δεδομένα δοκιμής.
Βελτιστοποίηση Παραμέτρων
Χρησιμοποιώντας τη μέθοδο RandomizedSearchCV του Scikit-Learn, μπορούμε να ορίσουμε ένα πλέγμα περιοχών υπερπαραμέτρων και να κάνουμε τυχαία δειγματοληψία από το πλέγμα, εκτελώντας K-Fold CV με κάθε συνδυασμό τιμών. Αυτό έχει ως αποτέλεσμα τη βελτιστοποίηση των αποτελεσμάτων καθώς το μοντέλο εκπαιδεύεται εκ νέου σε τυχαία δείγματα ώστε να επιτύχει την καλύτερη δυνατή πρόβλεψη.
Logistic Regression
clf = LogisticRegression()
penalty = ['l1', 'l2']
C = [0.0001, 0.001, 0.01, 0.1, 1, 10, 100, 1000]
#class_weight = [{1:0.5, 0:0.5}, {1:0.4, 0:0.6}, {1:0.6, 0:0.4}, {1:0.7, 0:0.3}]
solver = ['liblinear', 'saga']
param_grid = dict(penalty=penalty,
C=C,
#class_weight=class_weight,
solver=solver)
model = GridSearchCV(estimator=clf, param_grid=param_grid, scoring='roc_auc', n_jobs=4, cv=skf.split(X_train,y_train), verbose=3)
start_time = timer(None) # timing starts from this point for "start_time" variable
model.fit(X_train, y_train)
timer(start_time) # timing ends here for "start_time" variable
best_model = best_mdl()
best_model
XGBoost
clf = XGBClassifier()
# A parameter grid for XGBoost
param_grid = {
'min_child_weight': [1, 5, 10],
'gamma': [0.5, 1, 1.5, 2, 5],
'subsample': [0.6, 0.8, 1.0],
'colsample_bytree': [0.6, 0.8, 1.0],
'max_depth': [3, 4, 5]
}
model = GridSearchCV(estimator=clf, param_grid=param_grid, scoring='roc_auc', n_jobs=4, cv=skf.split(X_train,y_train), verbose=3)
# Here we go
#start_time = timer(None) # timing starts from this point for "start_time" variable
model.fit(X_train, y_train)
#timer(start_time) # timing ends here for "start_time" variable
best_model = best_mdl()
Gradient Boost Classifier
clf = GradientBoostingClassifier(max_depth=3, min_samples_split=2, min_samples_leaf=1, subsample=1,max_features='sqrt', random_state=10)
# A parameter grid for GradientBoostingClassifier
param_grid = {'learning_rate':[0.15,0.1,0.05,0.01,0.005,0.001], 'n_estimators':[100,250,500,750,1000,1250,1500,1750]}
model = GridSearchCV(estimator=clf, param_grid=param_grid, scoring='roc_auc', n_jobs=4, cv=skf.split(X_train,y_train), verbose=3)
# Here we go
#start_time = timer(None) # timing starts from this point for "start_time" variable
model.fit(X_train, y_train)
#timer(start_time) # timing ends here for "start_time" variable
best_model = best_mdl()
Random Forest
clf = RandomForestClassifier()
# A parameter grid for GradientBoostingClassifier
param_grid = {'bootstrap': [True, False],
'max_depth': [10, 20, 30, 40, 50, 60, 70, 80, 90, 100, None],
'max_features': ['auto', 'sqrt'],
'min_samples_leaf': [1, 2, 4],
'min_samples_split': [2, 5, 10],
'n_estimators': [200, 400, 600, 800, 1000, 1200, 1400, 1600, 1800, 2000]}
model = GridSearchCV(estimator=clf, param_grid=param_grid, scoring='roc_auc', n_jobs=4, cv=skf.split(X_train,y_train), verbose=3)
# Here we go
#start_time = timer(None) # timing starts from this point for "start_time" variable
model.fit(X_train, y_train)
#timer(start_time) # timing ends here for "start_time" variable
best_model = best_mdl()
Ορισμός πλέγματος υπερπαραμέτρων για το RandomizedSearchCV
Για να χρησιμοποιήσουμε το RandomizedSearchCV, εδώ, έχουμε ορίσει λεξικό μοντέλων και ένα λεξικό παραμέτρων για καθένα από τα μοντέλα για την βοηθητική κλάση που ακολουθεί.
models1 = {
'Logistic Regression' : LogisticRegression(),
'RandomForestClassifier': RandomForestClassifier(),
'GradientBoostingClassifier': GradientBoostingClassifier(),
'ExtraTreesClassifier': ExtraTreesClassifier(),
'KNeighbors Classifier' : KNeighborsClassifier(),
'SVC': SVC()
}
params1 = {
'Logistic Regression' : {'penalty' : ['l1','l2'], 'C' : np.logspace(0, 4, 10), 'solver' :['liblinear']},
'RandomForestClassifier': { 'n_estimators': [16, 32] },
'GradientBoostingClassifier': { 'n_estimators': [16, 32], 'learning_rate': [0.8, 1.0] },
'ExtraTreesClassifier': { 'n_estimators': [16, 32] },
'KNeighbors Classifier' : {'n_neighbors' :[1,2,5,6,7,10], 'weights':['uniform', 'distance']},
'SVC': {'kernel': ['linear','rbf'], 'C': [1, 10], 'gamma': [0.001, 0.0001]}
}
Εκπαίδευση των μοντέλων με το RandomizedSearchCV
class EstimatorSelectionHelper:
def __init__(self, models, params):
if not set(models.keys()).issubset(set(params.keys())):
missing_params = list(set(models.keys()) - set(params.keys()))
raise ValueError("Some estimators are missing parameters: %s" % missing_params)
self.models = models
self.params = params
self.keys = models.keys()
self.grid_searches = {}
def fit(self, X, y, cv=5, n_jobs=3, verbose=1, scoring=None, refit=False):
for key in self.keys:
print("Running RandomizedSearchCV for %s." % key)
model = self.models[key]
params = self.params[key]
gs = RandomizedSearchCV(estimator= model, param_distributions = params, cv=cv, n_jobs=n_jobs,
verbose=verbose, scoring=scoring, random_state = 2020)
gs.fit(X,y)
print('=====================================================================')
print('Best Score: %s' % gs.fit(X,y).best_score_)
print('Best Hyperparameters: %s' % gs.fit(X,y).best_params_)
print('=====================================================================')
self.grid_searches[key] = gs
def score_summary(self, sort_by='mean_score'):
def row(key, scores, params):
d = {
'estimator': key,
'min_score': min(scores),
'max_score': max(scores),
'mean_score': np.mean(scores),
'std_score': np.std(scores),
}
return pd.Series({**params,**d})
rows = []
for k in self.grid_searches:
print(k)
params = self.grid_searches[k].cv_results_['params']
scores = []
for i in range(self.grid_searches[k].cv):
key = "split{}_test_score".format(i)
r = self.grid_searches[k].cv_results_[key]
scores.append(r.reshape(len(params),1))
all_scores = np.hstack(scores)
for p, s in zip(params,all_scores):
rows.append((row(k, s, p)))
df = pd.concat(rows, axis=1).T.sort_values([sort_by], ascending=False)
columns = ['estimator', 'min_score', 'mean_score', 'max_score', 'std_score']
columns = columns + [c for c in df.columns if c not in columns]
return df[columns]
Αξιολόγηση των μοντέλων για RandomizedSearchCV
# Define the scoring
scoring_strings = ['accuracy', 'precision', 'recall', 'f1', 'average_precision','roc_auc']
scores_all = pd.DataFrame()
# Create object of the class helper
helper1 = EstimatorSelectionHelper(models1, params1)
flag=True
for scoring in scoring_strings:
helper1.fit(X_train, y_train, cv=5, scoring=scoring, n_jobs=2)
df_scores = helper1.score_summary(sort_by='max_score')
if flag:
# Saving each model for each scoring.
df_scores.to_csv("/work/Evaluation"+scoring+".csv")
df_scores['scoring_name']=scoring
scores_all = df_scores
print(scoring)
print(scores_all)
flag=False
else:
# Saving each model for each scoring.
df_scores.to_csv("/work/Evaluation"+scoring+".csv")
df_scores['scoring_name']=scoring
scores_all= scores_all.append(df_scores, ignore_index=True, sort=False)
print(scoring)
print(scores_all)
# Saving each model for each scoring.
scores_all.to_csv("/work/Evaluation/scores_all.csv")
Ορισμός πλέγματος υπερπαραμέτρων για το GridSearchCV
Ορισμός πλέγματος για το GridSearchCV
params1 = {
'Logistic Regression' : {'penalty' : ['l1','l2'], 'C' : np.logspace(0, 4, 10), 'solver' :['liblinear']},
'RandomForestClassifier': { 'n_estimators': [16, 32] },
'GradientBoostingClassifier': { 'n_estimators': [16, 32], 'learning_rate': [0.8, 1.0] },
'ExtraTreesClassifier': { 'n_estimators': [16, 32] },
'KNeighbors Classifier' : {'n_neighbors' :[1,2,5,6,7,10], 'weights':['uniform', 'distance']},
'SVC': {'kernel': ['linear','rbf'], 'C': [1, 10], 'gamma': [0.001, 0.0001]}
}
Εκπαίδευση των μοντέλων για το GridSearchCV
class EstimatorSelectionHelper:
def __init__(self, models, params):
if not set(models.keys()).issubset(set(params.keys())):
missing_params = list(set(models.keys()) - set(params.keys()))
raise ValueError("Some estimators are missing parameters: %s" % missing_params)
self.models = models
self.params = params
self.keys = models.keys()
self.grid_searches = {}
def fit(self, X, y, cv=5, n_jobs=3, verbose=1, scoring=None, refit=False):
for key in self.keys:
print("Running RandomizedSearchCV for %s." % key)
model = self.models[key]
params = self.params[key]
gs = GridSearchCV(model, params, cv=cv, n_jobs=n_jobs,
verbose=verbose, scoring=scoring, refit=refit,
return_train_score=True)
gs.fit(X,y)
print('=====================================================================')
print('Best Score: %s' % gs.fit(X,y).best_score_)
print('Best Hyperparameters: %s' % gs.fit(X,y).best_params_)
print('=====================================================================')
self.grid_searches[key] = gs
def score_summary(self, sort_by='mean_score'):
def row(key, scores, params):
d = {
'estimator': key,
'min_score': min(scores),
'max_score': max(scores),
'mean_score': np.mean(scores),
'std_score': np.std(scores),
}
return pd.Series({**params,**d})
rows = []
for k in self.grid_searches:
print(k)
params = self.grid_searches[k].cv_results_['params']
scores = []
for i in range(self.grid_searches[k].cv):
key = "split{}_test_score".format(i)
r = self.grid_searches[k].cv_results_[key]
scores.append(r.reshape(len(params),1))
all_scores = np.hstack(scores)
for p, s in zip(params,all_scores):
rows.append((row(k, s, p)))
df = pd.concat(rows, axis=1).T.sort_values([sort_by], ascending=False)
columns = ['estimator', 'min_score', 'mean_score', 'max_score', 'std_score']
columns = columns + [c for c in df.columns if c not in columns]
return df[columns]
Αξιολόγηση των μοντέλων
for scoring in scoring_strings:
helper1.fit(X_train, y_train, cv=5, scoring=scoring, n_jobs=2)
df_scores = helper1.score_summary(sort_by='max_score')