162 lines
6.4 KiB
Python
162 lines
6.4 KiB
Python
#!/usr/bin/env python3
|
|
# -*- coding: utf-8 -*
|
|
"""
|
|
Vous allez definir une classe pour chaque algorithme que vous allez développer,
|
|
votre classe doit contenit au moins les 3 methodes definies ici bas,
|
|
* train : pour entrainer le modèle sur l'ensemble d'entrainement
|
|
* predict : pour prédire la classe d'un exemple donné
|
|
* test : pour tester sur l'ensemble de test
|
|
vous pouvez rajouter d'autres méthodes qui peuvent vous etre utiles, mais moi
|
|
je vais avoir besoin de tester les méthodes test, predict et test de votre code.
|
|
"""
|
|
|
|
import numpy as np
|
|
import math
|
|
import metrics
|
|
import time
|
|
|
|
|
|
# le nom de votre classe
|
|
# BayesNaif pour le modèle bayesien naif
|
|
# Knn pour le modèle des k plus proches voisins
|
|
|
|
def gaussian_pdf(x, param):
|
|
"""
|
|
Fonction de densité de probabilité de la distribution gaussienne
|
|
"""
|
|
mu, sigma = param
|
|
return math.exp(-(float(x)-float(mu))**2/(2*float(sigma)**2)) / (float(sigma)*math.sqrt(2*math.pi))
|
|
|
|
class BayesNaif:
|
|
|
|
def __init__(self, gaussian, **kwargs):
|
|
"""
|
|
c'est un Initializer.
|
|
Vous pouvez passer d'autre paramètres au besoin,
|
|
c'est à vous d'utiliser vos propres notations
|
|
gaussian: variable booléenne qui définit si on utilise la variante gaussienne de l'algorithme Bayes Naif
|
|
"""
|
|
self.gaussian=gaussian
|
|
|
|
def train(self, train, train_labels, verbose=True):
|
|
"""
|
|
c'est la méthode qui va entrainer votre modèle,
|
|
train est une matrice de type Numpy et de taille nxm, avec
|
|
n : le nombre d'exemple d'entrainement dans le dataset
|
|
m : le mobre d'attribus (le nombre de caractéristiques)
|
|
|
|
train_labels : est une matrice numpy de taille nx1
|
|
|
|
vous pouvez rajouter d'autres arguments, il suffit juste de
|
|
les expliquer en commentaire
|
|
|
|
|
|
|
|
------------
|
|
Après avoir fait l'entrainement, faites maintenant le test sur
|
|
les données d'entrainement
|
|
IMPORTANT :
|
|
Vous devez afficher ici avec la commande print() de python,
|
|
- la matrice de confision (confusion matrix)
|
|
- l'accuracy
|
|
- la précision (precision)
|
|
- le rappel (recall)
|
|
|
|
Bien entendu ces tests doivent etre faits sur les données d'entrainement
|
|
nous allons faire d'autres tests sur les données de test dans la méthode test()
|
|
"""
|
|
start_time = time.time()
|
|
# Distribution a priori des classes de l'étiquette P(C)
|
|
|
|
n,m = train.shape
|
|
|
|
self.unique_labels = np.unique(train_labels)
|
|
|
|
self.labels_prob = {}
|
|
for c in self.unique_labels:
|
|
self.labels_prob.update({c:sum(train_labels == c) / n})
|
|
|
|
# Distribution des probabilités conditionnelles P(F1,F2,...|C)
|
|
|
|
self.features_cond = {}
|
|
self.unique_values_cond = {}
|
|
|
|
# on itère sur les labels, les colonnes et les valeurs uniques des colonnes (si discret)
|
|
|
|
for c in self.unique_labels:
|
|
subset = train[np.where(train_labels==self.unique_labels[c])[0]]
|
|
n_subset, m_subset = subset.shape
|
|
for f in range(m_subset):
|
|
current_column = subset[:,f]
|
|
if (self.gaussian):
|
|
self.features_cond.update({(c,f):(np.mean(current_column),np.std(current_column))})
|
|
else:
|
|
unique_values = np.unique(current_column)
|
|
self.unique_values_cond.update({(c,f):unique_values})
|
|
for v in unique_values:
|
|
self.features_cond.update({(c,f,v):sum(current_column==v)/n_subset})
|
|
cm,accuracy,precision,recall,compute_time = self.test(train, train_labels, verbose=False)
|
|
compute_time = time.time() - start_time
|
|
if (verbose):
|
|
metrics.print_prediction_metrics(cm,accuracy,precision,recall,compute_time)
|
|
return cm,accuracy,precision,recall,compute_time
|
|
|
|
|
|
def predict(self, exemple, label):
|
|
"""
|
|
Prédire la classe d'un exemple donné en entrée
|
|
exemple est de taille 1xm
|
|
|
|
si la valeur retournée est la meme que la veleur dans label
|
|
alors l'exemple est bien classifié, si non c'est une missclassification
|
|
|
|
"""
|
|
|
|
nb_unique_labels = len(self.unique_labels)
|
|
|
|
# P(X|C)
|
|
p_xc = {}
|
|
for l in range(nb_unique_labels):
|
|
if (self.gaussian):
|
|
p_xc.update({l:np.product([gaussian_pdf(exemple[f],self.features_cond.get((self.unique_labels[l],f))) or 1 for f in range(len(exemple))])})
|
|
else:
|
|
p_xc.update({l:np.product([self.features_cond.get((self.unique_labels[l],f,exemple[f])) or 1 for f in range(len(exemple))])})
|
|
|
|
prob = [self.labels_prob.get(i)*p_xc.get(i) for i in self.unique_labels]
|
|
prob = prob/sum(prob)
|
|
|
|
return (self.unique_labels[np.where(prob==max(prob))[0]].tolist()[0],label)
|
|
|
|
def test(self, test, test_labels, verbose=True):
|
|
"""
|
|
c'est la méthode qui va tester votre modèle sur les données de test
|
|
l'argument test est une matrice de type Numpy et de taille nxm, avec
|
|
n : le nombre d'exemple de test dans le dataset
|
|
m : le mobre d'attribus (le nombre de caractéristiques)
|
|
|
|
test_labels : est une matrice numpy de taille nx1
|
|
|
|
vous pouvez rajouter d'autres arguments, il suffit juste de
|
|
les expliquer en commentaire
|
|
|
|
Faites le test sur les données de test, et afficher :
|
|
- la matrice de confision (confusion matrix)
|
|
- l'accuracy
|
|
- la précision (precision)
|
|
- le rappel (recall)
|
|
|
|
Bien entendu ces tests doivent etre faits sur les données de test seulement
|
|
|
|
"""
|
|
start_time = time.time()
|
|
prediction_test = [self.predict(test[i],test_labels[i])[0] for i in range(len(test_labels))]
|
|
cm = metrics.confusion_matrix(test_labels,prediction_test)
|
|
accuracy, precision, recall = metrics.prediction_metrics(cm,test_labels,prediction_test)
|
|
compute_time = time.time() - start_time
|
|
if (verbose):
|
|
metrics.print_prediction_metrics(cm,accuracy,precision,recall,compute_time)
|
|
|
|
return cm,accuracy,precision,recall,compute_time
|
|
|
|
# Vous pouvez rajouter d'autres méthodes et fonctions,
|
|
# il suffit juste de les commenter.
|