X-Git-Url: https://git.piment-noir.org/?a=blobdiff_plain;f=TP3%2Fexo2%2Ftp3_exo2.py;h=7ceadb1b8185610e7c5d66577261a187324bfe7f;hb=26fd2383c38aa862fd24bdfadf3ba219fa1cd4dd;hp=c59b671479c474d3b2800ae39e4bbc0c3aa559da;hpb=4bab9ffbab19664454d31b11a99a5f3d7c14d492;p=TP_AA.git

diff --git a/TP3/exo2/tp3_exo2.py b/TP3/exo2/tp3_exo2.py
index c59b671..7ceadb1 100755
--- a/TP3/exo2/tp3_exo2.py
+++ b/TP3/exo2/tp3_exo2.py
@@ -28,7 +28,7 @@ def generateData2(n):
     Generates a 2D linearly separable dataset with 2n samples.
     The third element of the sample is the label
     """
-    xb = (rand(n) * 2 - 1) / 2 - 0.5
+    xb = (rand(n) * 2 - 1) / 2 + 0.5
     yb = (rand(n) * 2 - 1) / 2
     xr = (rand(n) * 2 - 1) / 2 + 1.5
     yr = (rand(n) * 2 - 1) / 2 - 0.5
@@ -41,7 +41,7 @@ def generateData2(n):
 
 def generateData3(n):
     """
-    Generates a 2D linearly separable dataset with 2n samples.
+    Generates a 2D linearly separable dataset with about 2n samples.
     The third element of the sample is the label
     """
     # (xb, yb) est dans le carré centré à l’origine de côté 1
@@ -62,7 +62,7 @@ def generateData3(n):
 
 
 training_set_size = 150
-training_set = generateData2(training_set_size)
+training_set = generateData3(training_set_size)
 data = np.array(training_set)
 X = data[:, 0:2]
 Y = data[:, -1]
@@ -74,10 +74,11 @@ def perceptron_nobias(X, Y):
     classification_error = 1
     while not classification_error == 0:
         classification_error = 0
-        for i in range(X.shape[0]):
-            if Y[i] * np.dot(w, X[i]) <= 0:
+        for x, y in zip(X, Y):
+            if y * np.dot(w, x) <= 0:
                 classification_error += 1
-                w = w + Y[i] * X[i]
+                w = w + y * x
+        print(classification_error)
     return w
 
 
@@ -86,14 +87,15 @@ def complete(sample):
     return np.array(new_sample)
 
 
-def plongement(sample_element):
-    return [1, sample_element[0], sample_element[1], sample_element[0] * sample_element[0], sample_element[0] * sample_element[1], sample_element[1] * sample_element[1]]
+def plongement_phi(sample_element):
+    return [1, sample_element[0], sample_element[1], sample_element[0]**2,
+            sample_element[0] * sample_element[1], sample_element[1]**2]
 
 
-def apply_plongement(sample):
+def apply_plongement(sample, p):
     output = []
     for i in range(sample.shape[0]):
-        current = plongement(sample[i])
+        current = p(sample[i])
         output.append(current)
     return np.array(output)
 
@@ -101,12 +103,22 @@ def apply_plongement(sample):
 def f_from_k(coeffs, support_set, k, x):
     output = 0
     for c, s in zip(coeffs, support_set):
-        output += c * s[0] * k(s[1], x)
+        output += c * s[1] * k(s[0], x)
     return output
 
 
 def k1(X1, X2):
-    return 1 + X1[0] * X2[0] + X1[1] * X2[1] + X1[0] * X1[0] * X2[0] * X2[0] + X1[0] * X1[1] * X2[0] * X1[1] + X1[1] * X2[1] * X2[1]
+    return 1 + X1[0] * X2[0] + X1[1] * X2[1] + X1[0]**2 * X2[0]**2 \
+             + X1[0] * X1[1] * X2[0] * X2[1] + X1[1]**2 * X2[1]**2
+
+
+def kg(x, y):
+    # sigma = 20  # do not converge
+    # sigma = 10  # do not converge
+    sigma = 1
+    # sigma = 0.5  # overfitting
+    # sigma = 0.2  # overfitting
+    return np.exp(-((x[0] - y[0])**2 + (x[1] - y[1])**2) / sigma**2)
 
 
 def perceptron_k(X, Y, k):
@@ -116,22 +128,40 @@ def perceptron_k(X, Y, k):
     classification_error = 1
     while not classification_error == 0:
         classification_error = 0
-        for i in range(X.shape[0]):
-            if Y[i] * f_from_k(coeffs, support_set, k, X[i]) <= 0:
+        for x, y in zip(X, Y):
+            if y * f_from_k(coeffs, support_set, k, x) <= 0:
+                if x not in support_set:
+                    support_set.append((x, y))
+                    coeffs.append(1)
+                else:
+                    coeffs[support_set.index((x, y))] += 1
                 classification_error += 1
-                support_set.append([Y[i], X[i]])
-                coeffs.append(1)
-            else:
-                coeffs[len(coeffs) - 1] = coeffs[len(coeffs) - 1] + 1
-    return coeffs, support_set
+        print(classification_error)
+    return np.array(coeffs), np.array(support_set)
 
 
-print(perceptron_k(X, Y, k1))
+def f(w, x, y):
+    return w[0] + w[1] * x + w[2] * y + w[3] * x**2 + w[4] * x * y + w[5] * y**2
 
-X = apply_plongement(X)
-w = perceptron_nobias(X, Y)
-print(w)
 
 pl.scatter(X[:, 0], X[:, 1], c=Y, s=training_set_size)
-pl.title(u"Perceptron - hyperplan")
+pl.title(u"Perceptron - prolontaged hyperplan")
+
+# k = k1
+# coeffs, support_set = perceptron_k(X, Y, k)
+k = kg
+coeffs, support_set = perceptron_k(X, Y, k)
+res = training_set_size
+for x in range(res):
+    for y in range(res):
+        if abs(f_from_k(coeffs, support_set, k, [-3 / 2 + 3 * x / res, -3 / 2 + 3 * y / res])) < 0.01:
+            pl.plot(-3 / 2 + 3 * x / res, -3 / 2 + 3 * y / res, 'xr')
+
+# X = apply_plongement(X, plongement_phi)
+# w = perceptron_nobias(X, Y)
+# for x in range(res):
+#     for y in range(res):
+#         if abs(f(w, -3 / 2 + 3 * x / res, -3 / 2 + 3 * y / res)) < 0.01:
+#             pl.plot(-3 / 2 + 3 * x / res, -3 / 2 + 3 * y / res, 'xb')
+
 pl.show()