choix des algos en argument

code/knn.py

@@ -7,6 +7,9 @@ class Knn:
     def __init__(self):
         self.space = np.array([])
     
+    def reset(self):
+        self.space = np.array([])
+
     def addPoint(self, coord, value):
         self.space = np.append(self.space, Point(coord, value))
 

code/nnnar.py

@@ -17,6 +17,12 @@ class Nnnar:
         self.space = fillSpace(self.space)
         self.calculatedSpaceAroundIdx = []
     
+    def reset(self):
+        coord = np.zeros(self.nbDimensions,dtype=int) + self.nbSubdivisions
+        self.space = np.zeros(coord)
+        fillSpace = np.vectorize(lambda x: [], otypes=[object])
+        self.space = fillSpace(self.space)
+
     def addPoint(self, coord, value):
         if len(coord) != self.nbDimensions:
             raise AttributeError("Error: wrong number of dimensions")

demo1.py

@@ -15,9 +15,13 @@ import pandas as pd
 trainTestRatio = 0.8
 nnnarSubDiv = 10
 
+# initialisation du modèle
+if (sys.argv[1] == "knn"):
+    model = Knn()
+else:
+    model = Nnnar(4, 0, 100, nnnarSubDiv)
+
 # lecture des données
-nnnar = Nnnar(4, 0, 100, nnnarSubDiv)
-knn = Knn()
 df = pd.read_csv('./data/maison.csv')
 df = df.iloc[:, 0:5]
 
@@ -43,18 +47,17 @@ coord = train.iloc[:, 1:].values
 value = train.iloc[:, 0].values
 
 for i in range(len(coord)):
-    knn.addPoint(np.array(coord[i]), np.array([value[i]]))
-    nnnar.addPoint(np.array(coord[i]), np.array([value[i]]))
+    model.addPoint(np.array(coord[i]), np.array([value[i]]))
 
 # Test du modèles
 coord = test.iloc[:, 1:].values
 value = test.iloc[:, 0].values
 
-nbErrorNnnar = 0
+nbError = 0
 
 for i in range(len(coord)):
-    v = nnnar.getValueOfPoint(np.array(coord[i]),5)[0]
+    v = model.getValueOfPoint(np.array(coord[i]),5)[0]
     if v != value[i]:
-        nbErrorNnnar += 100*abs(v-value[i])/value.max()
+        nbError += 100*abs(v-value[i])/value.max()
 
-print("accuracy moyenne:",str(100-nbErrorNnnar/len(coord)))
+print("accuracy moyenne:",str(100-nbError/len(coord)))

demo2.py

@@ -9,8 +9,12 @@ from knn import *
 import matplotlib.pyplot as plt
 from random import *
 
-knn = Knn()
-nnnar = Nnnar(1, 0, 1000, 10)
+
+# initialisation du modèle
+if (sys.argv[1] == "knn"):
+    model = Knn()
+else:
+    model = Nnnar(1, 0, 1000, 10)
 
 def getRandomParam():
     return [random()*10-5, random()*10-5,random()*10-5]
@@ -28,19 +32,16 @@ y = []
 for i in [minx + (maxx-minx)*i/nbPoints for i in range(nbPoints)]:
     x.append(i)
     y.append(applyFunction(i,param))
-    knn.addPoint(np.array([i]),np.array([y[-1]]))
-    nnnar.addPoint(np.array([i]),np.array([y[-1]]))
+    model.addPoint(np.array([i]),np.array([y[-1]]))
 
 error = 0
 nbInfer = 20
 for i in range(nbInfer):
     xt = random()*maxx
-    yt = nnnar.getValueOfPoint(np.array([xt]),2)
+    yt = model.getValueOfPoint(np.array([xt]),2)
     yr = applyFunction(xt,param)
     error += abs(yt[0]-yr)
-    ytk = knn.getValueOfPoint(np.array([xt]),2)
     plt.plot(xt,yt[0],'xr')
-    plt.plot(xt,ytk[0],'xg')
 
 print("Error: ",(error/nbInfer)/applyFunction(maxx,param))
 

demo3.py

@@ -63,15 +63,19 @@ print("pixel corompu trouvé")
 # Fournir les données d'entrainement au model
 
 t = time()
-nnnar = Nnnar(2,0,260,100)
+if (sys.argv[1] == "knn"):
+    model = Knn()
+else:
+    model = Nnnar(2,0,260,100)
+
 for y, x in goodPix:
-    nnnar.addPoint(np.array([x,y]), np.array(image[y,x]))
+    model.addPoint(np.array([x,y]), np.array(image[y,x]))
 
 # Remplacer les pixels corrompus par des pixels prédits
 image2 = image.copy()
 for y, x in badPix:
     coord = np.array([x,y])
-    image2[y,x] = nnnar.getValueOfPoint(coord, 8)[0]
+    image2[y,x] = model.getValueOfPoint(coord, 8)[0]
 
 print("temps d'infération des",str(len(badPix)),"pixels:",str(round(time()-t,3)),"s")
 

demo4.py

@@ -9,9 +9,7 @@ import numpy as np
 import pandas as pd
 from time import time
 
-def runOneTest(trainTestRatio):
-    nnnar = Nnnar(4, 0, 100.001, 10)# le 100.001 est pour être sûr d'être au dessus de la valeur max (100.0)
-    knn = Knn()
+def runOneTest(trainTestRatio,model):
     df = pd.read_csv('./data/Iris.csv')
     df = df.iloc[:, 1:]
     # Normalisation des données
@@ -37,7 +35,7 @@ def runOneTest(trainTestRatio):
     value = train.iloc[:, -1].values
 
     for i in range(len(coord)):
-        knn.addPoint(np.array(coord[i]), np.array([value[i]]))
+        model.addPoint(np.array(coord[i]), np.array([value[i]]))
 
     # Test du modèle
     coord = test.iloc[:, :-1].values
@@ -45,18 +43,24 @@ def runOneTest(trainTestRatio):
 
     nbError = 0
     for i in range(len(coord)):
-        if knn.getLabelOfPoint(np.array(coord[i]), 5) != value[i]:
+        if model.getLabelOfPoint(np.array(coord[i]), 5) != value[i]:
             nbError += 1
 
     return 100 - nbError / len(coord) * 100
 
 
+if (sys.argv[1] == "knn"):
+    model = Knn()
+else:
+    model = Nnnar(4, 0, 100.001, 10)
+
 t1 = time()
 
 nbRepetition = 100
 accuracy = 0
 for i in range(nbRepetition):
-    accuracy += runOneTest(0.8)
+    model.reset()
+    accuracy += runOneTest(0.8,model)
 
 t2 = time()
 print("accuracy moyenne:",str(accuracy/nbRepetition))