Dans ce notebook, nous allons réécrire les fonctions nécessaires pour utiliser un classifieur, et en particulier un classifieur de Bayes.
Il est clair que les fonctions décrites ici peuvent être retrouvées dans des bibliothèques Python (sklearn en particulier) mais nous allons tout refaire pour comprendre comment cela se passe.
On commence par charger les données :
import pandas as pa
data = pa.read_csv('https://www.labri.fr/perso/zemmari/datasets/hm.csv', delimiter=',', decimal='.')
data
On mélage les données :
data=data.sample(frac=1)
data
On récupère les données :
X = data[['Height', 'Weight', 'Foot']]
X.head()
Y = data[['Sex']]
Y.head()
On découpe les données en deux parties :
Y_test, Y_test pour le test
N.B. : ici, on fait les choses par nous même mais n'oubliez pas que la focntion train_test_split fait bien le travail. Ici on refait les choses dans un but purement pédagogique.
def split(X, Y, p):
l = int(len(X) * (1-p));
X_train, Y_train = X[:l], Y[:l]
X_test, Y_test = X[l:], Y[l:]
return X_train, Y_train, X_test, Y_test
X_train, Y_train, X_test, Y_test = split(X, Y, .25)
print('X_train : \n', X_train)
print('Y_train : \n', Y_train)
print('X_test : \n', X_test)
print('Y_test : \n', Y_test)
Tout ce qui a été fait dans les cellules précédentes est commun pour le machine learnning. D'autres actions, (celles dans les cellules un peu plus loin) le sont également.
Pour la moment, nous allons nous focaliser sur les classifieurs de Bayes.
print(data)
data_m = data[data['Sex']=="M"]
print(data_m)
data_f = data[data['Sex']=="F"]
print(data_f)
import numpy as np
def train_bayes(data, columns):
data_m = data[data['Sex']=='M']
data_f = data[data['Sex']=='F']
means = []
sigmas = []
probas = [len(data_m)/(len(data)),len(data_f)/(len(data))]
for c in columns:
means.append([np.mean(data_m[c]),np.mean(data_f[c])])
sigmas.append([np.sqrt(np.var(data_m[c])),np.sqrt(np.var(data_f[c]))])
return means, sigmas, probas
#print(X_train[])
means, sigmas, probas = train_bayes(data,X.columns)
print(means)
print(sigmas)
print(probas)
import scipy.stats as st
def classify(means, sigmas, probas,item):
probas_m = [st.norm.pdf(item[i], means[i][0],sigmas[i][0]) for i in range(len(means))]
probas_f = [st.norm.pdf(item[i],means[i][1],sigmas[i][1]) for i in range(len(means))]
p_m = probas[0] * np.product(probas_m)
p_f = probas[1] * np.product(probas_f)
if p_m > p_f:
return 'M'
return 'F'
#print('Coucou:', len(X_test.loc[1:,['Height', 'Weight', 'Foot']]), len(means))
item = []
for c in X_test.columns:
item.append(X_test[1:1][c])
print(classify(means, sigmas, probas,item))
#print(classify(means, sigmas, probas,np.array(X_test.loc[1:,])))
item = [1.81,59,21]
print(classify(means, sigmas, probas,item))
Une fois les données chargées et découpées (en train et test), une fois que le modèle a été entrainé (avec la partie train du dataset), on éavlue ses performances sur la partie test.
Rappelons que la partie test n'a pas été vue par notre modèle lors de la phase d'entrainement.
On commence donc par demander au model de classifier tous les exemples de la partie test du dataset :
y_predict = []
for i in range(len(X_test)):
item = []
for c in X_test.columns:
item.append(X_test[i:i][c])
y_predict.append(classify(means, sigmas, probas,item))
print(y_predict)
On définit la fonction qui calcule et affiche la matrice de confusion :
def confusion_matrix(y_truth,y_predict,positive):
for i in range(len(y_truth)):
tp, fp, tn, fn = 0, 0, 0, 0
if y_truth[i] == positive and y_predict[i] == positive:
tp += 1
elif y_truth[i] != positive and y_predict[i] == positive:
fp += 1
elif y_truth[i] != positive and y_predict[i] != positive:
tn += 1
else:
fn += 1
return tp, fp, tn, fn
On regarde les perfomances de notre classifieur :
print(Y_test.shape)
#print(y_predict.shape)
y_truth = Y_test.values.reshape((2,1))
#y_predict = y_predict.values
print(y_truth)
print(np.reshape(y_predict,(2,1)))
#tp, fp, tn, fn = confusion_matrix(y_predict, y_predict,'M')
tp, fp, tn, fn = confusion_matrix(y_truth, np.reshape(y_predict,(2,1)),'F')
print(tp, fp, tn, fn)