amélioration naive bayes et predict

Code/BayesNaif.py

@@ -18,10 +18,11 @@ import math
 # BayesNaif pour le modèle bayesien naif
 # Knn pour le modèle des k plus proches voisins
 
-def gaussian_pdf(x, mu, sigma):
+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: #nom de la class à changer
@@ -29,15 +30,17 @@ class BayesNaif: #nom de la class à changer
 
         
 
-    def __init__(self, **kwargs):
+    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
         """
         
+        self.gaussian=gaussian
         
-    def train(self, train, train_labels, gaussian=False): #vous pouvez rajouter d'autres attribus au besoin
+        
+    def train(self, train, train_labels):#TODO A ENLEVER #vous pouvez rajouter d'autres attribus au besoin
         """
         c'est la méthode qui va entrainer votre modèle,
         train est une matrice de type Numpy et de taille nxm, avec 
@@ -69,35 +72,33 @@ class BayesNaif: #nom de la class à changer
         
         n,m = train.shape
         
-        unique_labels = np.unique(train_labels)
+        self.unique_labels = np.unique(train_labels)
         
-        prob_labels = []
-        for i in unique_labels:
-            prob_labels.append(sum(train_labels == i) / n)
+        self.labels_prob = {}
+        for i in self.unique_labels:
+            self.labels_prob.update({i:sum(train_labels == i) / n})
             
-        # Distribution des vraisemblances P(F1,F2,...|C)
+        # Distribution des probabilités conditionnelles P(F1,F2,...|C)
         
-        features_likelihood = []
+        self.features_cond = {}
+        self.unique_values_cond = {}
         
         # on itère sur les labels, les colonnes et les valeurs uniques des colonnes (si discret)
         
-        for l in unique_labels:
-            subset = train[np.where(train_labels==unique_labels[l])[0]]
+        for l in self.unique_labels:
+            subset = train[np.where(train_labels==self.unique_labels[l])[0]]
             n_subset, m_subset = subset.shape
             for c in range(m_subset):
-                if (gaussian):
-                    features_likelihood.append((l,c,np.mean(subset[:,c]),np.std(subset[:,c])))
+                current_column = subset[:,c]
+                if (self.gaussian):
+                    self.features_cond.update({(l,c):(np.mean(current_column),np.std(current_column))})
                 else:
-                    unique_values = np.unique(train[:,c])
+                    unique_values = np.unique(current_column)
+                    self.unique_values_cond.update({(l,c):unique_values})
                     for v in unique_values:
-                        features_likelihood.append((l,c,v,sum(subset[:,c]==v)/n_subset))
-                        
-        # Distribution des probabilités P(F1,F2,...)
+                        self.features_cond.update({(l,c,v):sum(current_column==v)/n_subset})
         
         
-        
-            
-        
 
     def predict(self, exemple, label):
         """
@@ -108,6 +109,21 @@ class BayesNaif: #nom de la class à changer
         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[c],self.features_cond.get((self.unique_labels[l],c))) for c in range(len(exemple))])})
+            else:
+                p_xc.update({l:np.product([self.features_cond.get((self.unique_labels[l],c,exemple[c])) for c 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):
         """

Code/Knn.py

@@ -25,13 +25,13 @@ def mode(a):
 
 class Knn: #nom de la class à changer
 
-    def __init__(self, **kwargs):
+    def __init__(self, k=5, **kwargs):
         """
         c'est un Initializer. 
         Vous pouvez passer d'autre paramètres au besoin,
         c'est à vous d'utiliser vos propres notations
         """
-        self.k=5
+        self.k=k
         
     def set_best_k(self, train, train_labels, nb_split, k_potentiel):
        
@@ -162,8 +162,8 @@ class Knn: #nom de la class à changer
         if (verbose):
             print("Observé:"+str(label)+" Prédit:"+str(nn_mode_label))
         
-        return nn_mode_label
-
+        return (nn_mode_label,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

Code/entrainer_tester.py

@@ -23,28 +23,42 @@ En gros, vous allez :
 
 train, train_labels, test, test_labels = ld.load_iris_dataset(0.7)
 train, train_labels, test, test_labels = ld.load_congressional_dataset(0.7)
+train, train_labels, test, test_labels = ld.load_monks_dataset(1)
+train, train_labels, test, test_labels = ld.load_monks_dataset(2)
+train, train_labels, test, test_labels = ld.load_monks_dataset(3)
 
-# Initializer vos paramètres
+# KNN
 
 ## Choix du meilleur K
-
 findbest_Knn = Knn.Knn()
 meilleur_k = findbest_Knn.set_best_k(train, train_labels, nb_split=5, k_potentiel=range(1,16))
 print("Le meilleur K est:"+str(meilleur_k)+"\n\n")
 
-# Initializer/instanciez vos classifieurs avec leurs paramètres
-
-myKnn = Knn.Knn()
-myKnn.k=meilleur_k
-
-# Entrainez votre classifieur
+## Initializer/instanciez vos classifieurs avec leurs paramètres
+myKnn = Knn.Knn(meilleur_k)
 
+## Entrainez votre classifieur
 myKnn.train(train, train_labels)
 
-# Tester votre classifieur
+## Prediction
 
+
+
+## Tester votre classifieur
 myKnn.test(test, test_labels)
 
+# Naive Bayes
+
+## Initializer/instanciez vos classifieurs avec leurs paramètres
+BN = BayesNaif.BayesNaif(True)
+
+## Entrainez votre classifieur
+BN.train(train, train_labels)
+
+## Prediction
+
+np.array([BN.predict(train[i],train_labels[i]) for i in range(105)])
+