Fix TP3 exo2.

[TP_AA.git] / TP3 / exo1 / tp3_exo1.py

#!/usr/bin/env python3

# -*- coding: utf-8 -*-
import numpy as np
from numpy.random import rand
import pylab as pl


def generateData(n):
    """
    Generates a 2D linearly separable dataset with 2n samples.
    The third element of the sample is the label
    """
    linear_offset = 0.6
    xb = (rand(n) * 2 - 1) / 2 - linear_offset
    yb = (rand(n) * 2 - 1) / 2 + linear_offset
    xr = (rand(n) * 2 - 1) / 2 + linear_offset
    yr = (rand(n) * 2 - 1) / 2 - linear_offset
    inputs = []
    for i in range(n):
        inputs.append([xb[i], yb[i], -1])
        inputs.append([xr[i], yr[i], 1])
    return inputs


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
    yb = (rand(n) * 2 - 1) / 2
    xr = (rand(n) * 2 - 1) / 2 + 1.5
    yr = (rand(n) * 2 - 1) / 2 - 0.5
    inputs = []
    for i in range(n):
        inputs.append([xb[i], yb[i], -1])
        inputs.append([xr[i], yr[i], 1])
    return inputs


training_set_size = 150
training_set = generateData2(training_set_size)
data = np.array(training_set)
X = data[:, 0:2]
Y = data[:, -1]


def perceptron_nobias(X, Y):
    w = np.zeros([len(X[0])])
    # Go in the loop at least one time
    classification_error = 1
    while not classification_error == 0:
        classification_error = 0
        for x, y in zip(X, Y):
            if y * np.dot(w, x) <= 0:
                classification_error += 1
                w = w + y * x
    return w


def complete(sample):
    new_sample = np.insert(sample, len(sample[0]), [1], axis=1)
    return np.array(new_sample)


X = complete(X)
w = perceptron_nobias(X, Y)
# w is orthogonal to the hyperplan
# with generateData
# plot arguments format is pl.plot([x1,x2],[y1,y2])
# w[0]x + w[1]y = 0, so y = -w[0]x / w[1]
# pl.plot([-1, 1], [w[0] / w[1], -w[0] / w[1]])
# with generateData2 and complete
# w[0]x + w[1]y + w[2] = 0, so y = -(w[0]x + w[2]) / w[1]
x_start1 = -0.5
x_start2 = 2.5
pl.plot([x_start1, x_start2], [-(w[0] * x_start1 + w[2]) /
                               w[1], -(w[0] * x_start2 + w[2]) / w[1]])
pl.scatter(X[:, 0], X[:, 1], c=Y, s=training_set_size)
pl.title(u"Perceptron - hyperplan")
pl.show()