Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""
    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x')
    plt.ylabel('y')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)



def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    return np.loadtxt(filename, delimiter=',', comments='#')



def main():
    """Point d'entree du programme"""
    initPLT()     # Initialisation de MatPlotLib

    # Lecture du dataset
    dataset = readDataset('datasetA.csv')
    
    # Affichage du dataset
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for id, (t, x1, x2) in enumerate(dataset):
        print(f"    {id+1:3d}: {int(t)} - ({x1}, {x2})")

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    return np.loadtxt(filename, delimiter=',', comments='#')


def displayDataset(dataset):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
    for t, x1, x2 in dataset:
        color = 'red' if int(t) == 1 else 'green'
        plt.scatter(x1, x2, marker='o', color=color)


def main():
    """Point d'entree du programme"""
    initPLT()     # Initialisation de MatPlotLib

    dataset = readDataset('datasetA.csv')
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for id, (t, x1, x2) in enumerate(dataset):
        print(f"    {id+1:3d}: {int(t)} - ({x1}, {x2})")

    displayDataset(dataset) # Affichage du dataset

    plt.savefig('ex03-datasetA.svg')

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    
    return np.loadtxt(filename, delimiter=',', comments='#')


def displayDataset(dataset):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
    
    for t, x1, x2 in dataset:
        color = 'red' if int(t) == 1 else 'green'
        plt.scatter(x1, x2, marker='o', color=color)


def main():
    """Point d'entree du programme"""
    
    initPLT()     # Initialisation de MatPlotLib

    # Exercice 4. 1/2: Ajout du modèle
    model = np.array([-0.5, 1.2, -1.35], dtype=float)

    dataset = readDataset('datasetA.csv')
    
    # Exercice 4. 2/2: Affichage du modèle
    print("Model")
    print(f"  w1: {model[0]:9.6f}")
    print(f"  w2: {model[1]:9.6f}")
    print(f"   b: {model[2]:9.6f}")
    print("")
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for id, (t, x1, x2) in enumerate(dataset):
        print(f"    {id+1:3d}: {int(t)} - ({x1}, {x2})")

    displayDataset(dataset) # Affichage du dataset

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    
    return np.loadtxt(filename, delimiter=',', comments='#')


def displayDataset(dataset):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
    
    for t, x1, x2 in dataset:
        color = 'red' if int(t) == 1 else 'green'
        plt.scatter(x1, x2, marker='o', color=color)

# Exercice 5. 1/2: ajout de la fonction z
def z(model, features):
    """Calcule la valeur de la fonction d'agregation pour le modele 
    et le vecteur de caracteristiques (features) donne"""
    
    w = model[:-1]   # les n poids
    b = model[-1]    # le biais
    return np.dot(w, features) + b


def main():
    """Point d'entree du programme"""
    
    initPLT()     # Initialisation de MatPlotLib

    model = np.array([-0.5, 1.2, -1.35], dtype=float)

    dataset = readDataset('datasetA.csv')
    
    print("Model")
    print(f"  w1: {model[0]:9.6f}")
    print(f"  w2: {model[1]:9.6f}")
    print(f"   b: {model[2]:9.6f}")
    print("")
    
    # Exercice 5. 2/2: Affichage de z
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for id, (t, x1, x2) in enumerate(dataset):
        print(f"    {id+1:3d}: {int(t)} - ({x1}, {x2}) - z={z(model, (x1, x2)):9.6f}")

    displayDataset(dataset) # Affichage du dataset

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    
    return np.loadtxt(filename, delimiter=',', comments='#')


def displayDataset(dataset):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
    
    for t, x1, x2 in dataset:
        color = 'red' if int(t) == 1 else 'green'
        plt.scatter(x1, x2, marker='o', color=color)

def z(model, features):
    """Calcule la valeur de la fonction d'agregation pour le modele 
    et le vecteur de caracteristiques (features) donne"""
    
    w = model[:-1]   # les n poids
    b = model[-1]    # le biais
    return np.dot(w, features) + b


# Exercice 6. 1/2: ajout de la fonction phi
def phi(z):
    """Calcule la valeur de la fonction d'activation heaviside pour la valeur agregee z"""
 
    return 1 if z >= 0 else 0


def main():
    """Point d'entree du programme"""
    
    initPLT()     # Initialisation de MatPlotLib

    model = np.array([-0.5, 1.2, -1.35], dtype=float)

    dataset = readDataset('datasetA.csv')
    
    print("Model")
    print(f"  w1: {model[0]:9.6f}")
    print(f"  w2: {model[1]:9.6f}")
    print(f"   b: {model[2]:9.6f}")
    print("")
    
    # Exercice 6. 1/2: Ajout de l'affichage de phi
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for id, (t, x1, x2) in enumerate(dataset):
        print(f"    {id+1:3d}: {int(t)} - ({x1}, {x2}) - z={z(model, (x1, x2)):9.6f} - \u03c6={phi(z(model, (x1, x2)))}")

    displayDataset(dataset) # Affichage du dataset

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    
    return np.loadtxt(filename, delimiter=',', comments='#')


def displayDataset(dataset):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
    
    for t, x1, x2 in dataset:
        color = 'red' if int(t) == 1 else 'green'
        plt.scatter(x1, x2, marker='o', color=color)

def z(model, features):
    """Calcule la valeur de la fonction d'agregation pour le modele 
    et le vecteur de caracteristiques (features) donne"""
    
    w = model[:-1]   # les n poids
    b = model[-1]    # le biais
    return np.dot(w, features) + b


def phi(z):
    """Calcule la valeur de la fonction d'activation heaviside pour la valeur agregee z"""
 
    return 1 if z >= 0 else 0


# Exercice 7. 1/2: ajout de la fonction z
def y(model, features):
    """Calcule la valeur prediction pour le modele et les features passes en parametre"""
 
    return phi(z(model, features))

    
def main():
    """Point d'entree du programme"""
    
    initPLT()     # Initialisation de MatPlotLib

    model = np.array([-0.5, 1.2, -1.35], dtype=float)

    dataset = readDataset('datasetA.csv')
    
    print("Model")
    print(f"  w1: {model[0]:9.6f}")
    print(f"  w2: {model[1]:9.6f}")
    print(f"   b: {model[2]:9.6f}")
    print("")
    
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    # Exercice 7. 2/2: Ajout de l'affichage de la prediction
    for k in range(0,dataset.shape[0]):
        t = dataset[k][0]
        x1 = dataset[k][1]
        x2 = dataset[k][2]
        print(f"    {k:3d}: {int(t)} - ({x1}, {x2}) - z={z(model, (x1, x2)):9.6f} - \u03c6={phi(z(model, (x1, x2)))} - y={y(model, dataset[k][1:])}")

    displayDataset(dataset) # Affichage du dataset

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

En comparant les classes explicites ( \( t \)) et les prédictions, on remarque de nombreuses différences. La prédiction du perceptron avec le modèle actuel est incorrecte.

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    
    return np.loadtxt(filename, delimiter=',', comments='#')


def displayDataset(dataset):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
    
    for t, x1, x2 in dataset:
        color = 'red' if int(t) == 1 else 'green'
        plt.scatter(x1, x2, marker='o', color=color)


# Exercice 8 1/2 - Implantation de la fonction
def displayFrontier(model):
    """Affiche la frontière de décision du perceptron sous forme d'une droite.
       La frontière est l'ensemble des points où z = 0, soit : w1*x1 + w2*x2 + b = 0
    """

    w1, w2, b = model

    # On récupère les bornes actuelles de l'axe des abscisses
    x1_min, x1_max = plt.xlim()

    x2_min, x2_max = plt.ylim()


    if w2 != 0:
        # Cas général : x2 = -(w1*x1 + b) / w2
        plt.plot([x1_min, x1_max], [-(w1 * x1_min + b) / w2, -(w1 * x1_max + b) / w2], color='orange', linewidth=2)
    else:
        # Cas particulier : droite verticale x1 = -b / w1
        plt.plot([-b/w1, -b/w1],[x2_min, x2_max], color='orange', linewidth=2)


def z(model, features):
    """Calcule la valeur de la fonction d'agregation pour le modele 
    et le vecteur de caracteristiques (features) donne"""
    
    w = model[:-1]   # les n poids
    b = model[-1]    # le biais
    return np.dot(w, features) + b


def phi(z):
    """Calcule la valeur de la fonction d'activation heaviside pour la valeur agregee z"""
 
    return 1 if z >= 0 else 0


def y(model, features):
    """Calcule la valeur prediction pour le modele et les features passes en parametre"""
 
    return phi(z(model, features))


def main():
    """Point d'entree du programme"""
    
    initPLT()     # Initialisation de MatPlotLib

    model = np.array([-0.5, 1.2, -1.35], dtype=float)

    dataset = readDataset('datasetA.csv')
    
    print("Model")
    print(f"  w1: {model[0]:9.6f}")
    print(f"  w2: {model[1]:9.6f}")
    print(f"   b: {model[2]:9.6f}")
    print("")
    
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for k in range(0,dataset.shape[0]):
        t = dataset[k][0]
        x1 = dataset[k][1]
        x2 = dataset[k][2]
        print(f"    {k:3d}: {int(t)} - ({x1}, {x2}) - z={z(model, (x1, x2)):9.6f} - \u03c6={phi(z(model, (x1, x2)))} - y={y(model, dataset[k][1:])}")

    displayDataset(dataset) # Affichage du dataset

    # Exercice 8 2/2 - Rendu de la frontière de decision
    displayFrontier(model)

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    
    return np.loadtxt(filename, delimiter=',', comments='#')


# Exercice 9 - 1/2 - modification de l'affichage
def displayDataset(dataset, model=None):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
        
    if (model is None): 
        for t, x1, x2 in dataset:
            color = 'red' if int(t) == 1 else 'green'
            plt.scatter(x1, x2, marker='o', color=color)
    else:
        for t, x1, x2 in dataset:
            
            color = 'gray'

            # Calcul de la prédiction
            p = y(model, (x1, x2))
            
            if t == 1:
                if p == 1:
                    color = 'red'
                elif p == 0:
                    color = 'magenta'
                else:
                    color = 'black'
            elif t == 0:
                if p == 0:
                    color = 'green'
                elif p == 1:
                    color = 'cyan'
                else:
                    color = 'black'
                    
            plt.scatter(x1, x2, marker='o', color=color)


def displayFrontier(model):
    """Affiche la frontière de décision du perceptron sous forme d'une droite.
       La frontière est l'ensemble des points où z = 0, soit : w1*x1 + w2*x2 + b = 0
    """

    w1, w2, b = model

    # On récupère les bornes actuelles de l'axe des abscisses
    x1_min, x1_max = plt.xlim()

    x2_min, x2_max = plt.ylim()


    if w2 != 0:
        # Cas général : x2 = -(w1*x1 + b) / w2
        plt.plot([x1_min, x1_max], [-(w1 * x1_min + b) / w2, -(w1 * x1_max + b) / w2], color='orange', linewidth=2)
    else:
        # Cas particulier : droite verticale x1 = -b / w1
        plt.plot([-b/w1, -b/w1],[x2_min, x2_max], color='orange', linewidth=2)


def z(model, features):
    """Calcule la valeur de la fonction d'agregation pour le modele 
    et le vecteur de caracteristiques (features) donne"""
    
    w = model[:-1]   # les n poids
    b = model[-1]    # le biais
    return np.dot(w, features) + b


def phi(z):
    """Calcule la valeur de la fonction d'activation heaviside pour la valeur agregee z"""
 
    return 1 if z >= 0 else 0


def y(model, features):
    """Calcule la valeur prediction pour le modele et les features passes en parametre"""
 
    return phi(z(model, features))
    

def main():
    """Point d'entree du programme"""
    
    initPLT()     # Initialisation de MatPlotLib

    model = np.array([-0.5, 1.2, -1.35], dtype=float)

    dataset = readDataset('datasetA.csv')
    
    print("Model")
    print(f"  w1: {model[0]:9.6f}")
    print(f"  w2: {model[1]:9.6f}")
    print(f"   b: {model[2]:9.6f}")
    print("")
    
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for k in range(0,dataset.shape[0]):
        t = dataset[k][0]
        x1 = dataset[k][1]
        x2 = dataset[k][2]
        print(f"    {k:3d}: {int(t)} - ({x1}, {x2}) - z={z(model, (x1, x2)):9.6f} - \u03c6={phi(z(model, (x1, x2)))} - y={y(model, dataset[k][1:])}")

    # Exercice 9 - 2/2 - appel de l'affichage modifie
    displayDataset(dataset, model) # Affichage du dataset

    displayFrontier(model)

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    
    return np.loadtxt(filename, delimiter=',', comments='#')


def displayDataset(dataset, model=None):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
        
    if (model is None): 
        for t, x1, x2 in dataset:
            color = 'red' if int(t) == 1 else 'green'
            plt.scatter(x1, x2, marker='o', color=color)
    else:
        for t, x1, x2 in dataset:
            
            color = 'gray'

            # Calcul de la prédiction
            p = y(model, (x1, x2))
            
            if t == 1:
                if p == 1:
                    color = 'red'
                elif p == 0:
                    color = 'magenta'
                else:
                    color = 'black'
            elif t == 0:
                if p == 0:
                    color = 'green'
                elif p == 1:
                    color = 'cyan'
                else:
                    color = 'black'
                    
            plt.scatter(x1, x2, marker='o', color=color)


def displayFrontier(model):
    """Affiche la frontière de décision du perceptron sous forme d'une droite.
       La frontière est l'ensemble des points où z = 0, soit : w1*x1 + w2*x2 + b = 0
    """

    w1, w2, b = model

    # On récupère les bornes actuelles de l'axe des abscisses
    x1_min, x1_max = plt.xlim()

    x2_min, x2_max = plt.ylim()


    if w2 != 0:
        # Cas général : x2 = -(w1*x1 + b) / w2
        plt.plot([x1_min, x1_max], [-(w1 * x1_min + b) / w2, -(w1 * x1_max + b) / w2], color='orange', linewidth=2)
    else:
        # Cas particulier : droite verticale x1 = -b / w1
        plt.plot([-b/w1, -b/w1],[x2_min, x2_max], color='orange', linewidth=2)


# Exercice 10 - 2/2: Affichage de l'erreur
def displayError(e):
    """
    Affiche la valeur d'erreur dans le coin superieur gauche du graphique
    
    :param e: la valeur d'erreur a afficher
    """
    x_min, x_max = plt.xlim()
    y_min, y_max = plt.ylim()
    
    plt.text(x_min+0.05, y_max-0.3, f"Error: {e:5.2f}", fontsize=9, color='black')

def z(model, features):
    """Calcule la valeur de la fonction d'agregation pour le modele 
    et le vecteur de caracteristiques (features) donne"""
    
    w = model[:-1]   # les n poids
    b = model[-1]    # le biais
    return np.dot(w, features) + b


def phi(z):
    """Calcule la valeur de la fonction d'activation heaviside pour la valeur agregee z"""
 
    return 1 if z >= 0 else 0


def y(model, features):
    """Calcule la valeur prediction pour le modele et les features passes en parametre"""
 
    return phi(z(model, features))
    

# Exercice 10 - 1/2: Implantation de la fonctione error
def error(model, dataset):
    """
    Calcul l'erreur d'un modele d'apprentissage par rapport a un jeu de donnees
    :param model: le modele pour lequel calculer l'erreur
    :param dataset: le jeux de donnees sur lequel l'erreur est calculee
    :return: l'erreur du modele par rapport au jeux de donnees
    """
    
    e = 0
    for k in range(0,dataset.shape[0]):
        e = e + np.absolute(dataset[k][0] - y(model, dataset[k][1:]))
        
    return e


def main():
    """Point d'entree du programme"""
    
    initPLT()     # Initialisation de MatPlotLib

    model = np.array([-0.5, 1.2, -1.35], dtype=float)

    dataset = readDataset('datasetA.csv')
    
    e = error(model, dataset)
    
    print("Model")
    print(f"  w1: {model[0]:9.6f}")
    print(f"  w2: {model[1]:9.6f}")
    print(f"   b: {model[2]:9.6f}")
    print("")
    
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for k in range(0,dataset.shape[0]):
        t = dataset[k][0]
        x1 = dataset[k][1]
        x2 = dataset[k][2]
        print(f"    {k:3d}: {int(t)} - ({x1}, {x2}) - z={z(model, (x1, x2)):9.6f} - \u03c6={phi(z(model, (x1, x2)))} - y={y(model, dataset[k][1:])}")

    print(f"  Error: {e}")

    displayDataset(dataset, model) 
    displayFrontier(model)
    displayError(e)

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    
    return np.loadtxt(filename, delimiter=',', comments='#')


def displayDataset(dataset, model=None):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
        
    if (model is None): 
        for t, x1, x2 in dataset:
            color = 'red' if int(t) == 1 else 'green'
            plt.scatter(x1, x2, marker='o', color=color)
    else:
        for t, x1, x2 in dataset:
            
            color = 'gray'

            # Calcul de la prédiction
            p = y(model, (x1, x2))
            
            if t == 1:
                if p == 1:
                    color = 'red'
                elif p == 0:
                    color = 'magenta'
                else:
                    color = 'black'
            elif t == 0:
                if p == 0:
                    color = 'green'
                elif p == 1:
                    color = 'cyan'
                else:
                    color = 'black'
                    
            plt.scatter(x1, x2, marker='o', color=color)


def displayFrontier(model):
    """Affiche la frontière de décision du perceptron sous forme d'une droite.
       La frontière est l'ensemble des points où z = 0, soit : w1*x1 + w2*x2 + b = 0
    """

    w1, w2, b = model

    # On récupère les bornes actuelles de l'axe des abscisses
    x1_min, x1_max = plt.xlim()

    x2_min, x2_max = plt.ylim()


    if w2 != 0:
        # Cas général : x2 = -(w1*x1 + b) / w2
        plt.plot([x1_min, x1_max], [-(w1 * x1_min + b) / w2, -(w1 * x1_max + b) / w2], color='orange', linewidth=2)
    else:
        # Cas particulier : droite verticale x1 = -b / w1
        plt.plot([-b/w1, -b/w1],[x2_min, x2_max], color='orange', linewidth=2)


def displayError(e):
    """
    Affiche la valeur d'erreur dans le coin superieur gauche du graphique
    
    :param e: la valeur d'erreur a afficher
    """
    x_min, x_max = plt.xlim()
    y_min, y_max = plt.ylim()
    
    plt.text(x_min+0.05, y_max-0.3, f"Error: {e:5.2f}", fontsize=9, color='black')

def z(model, features):
    """Calcule la valeur de la fonction d'agregation pour le modele 
    et le vecteur de caracteristiques (features) donne"""
    
    w = model[:-1]   # les n poids
    b = model[-1]    # le biais
    return np.dot(w, features) + b


def phi(z):
    """Calcule la valeur de la fonction d'activation heaviside pour la valeur agregee z"""
 
    return 1 if z >= 0 else 0


def y(model, features):
    """Calcule la valeur prediction pour le modele et les features passes en parametre"""
 
    return phi(z(model, features))
    

def error(model, dataset):
    """
    Calcul l'erreur d'un modele d'apprentissage par rapport a un jeu de donnees
    :param model: le modele pour lequel calculer l'erreur
    :param dataset: le jeux de donnees sur lequel l'erreur est calculee
    :return: l'erreur du modele par rapport au jeux de donnees
    """
    
    e = 0
    for k in range(0,dataset.shape[0]):
        e = e + np.absolute(dataset[k][0] - y(model, dataset[k][1:]))
        
    return e


# Exercice 12 - 1/2 - Implantation de la fonction train
def train(model, dataset):
    """
    Entraine le modele donne en parametre sur le jeu de donnees fourni.
    :param model: Le modele a entrainer
    :param dataset: LE jeux de donnees d'entrainement
    """
    return 0;

def main():
    """Point d'entree du programme"""
    
    initPLT()     # Initialisation de MatPlotLib

    model = np.array([-0.5, 1.2, -1.35], dtype=float)

    dataset = readDataset('datasetA.csv')
    
    # Exercice 12 - 2/2 - Appel a la fonction train
    train(model, dataset)
    
    e = error(model, dataset)
    
    print("Model")
    print(f"  w1: {model[0]:9.6f}")
    print(f"  w2: {model[1]:9.6f}")
    print(f"   b: {model[2]:9.6f}")
    print("")
    
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for k in range(0,dataset.shape[0]):
        t = dataset[k][0]
        x1 = dataset[k][1]
        x2 = dataset[k][2]
        print(f"    {k:3d}: {int(t)} - ({x1}, {x2}) - z={z(model, (x1, x2)):9.6f} - \u03c6={phi(z(model, (x1, x2)))} - y={y(model, dataset[k][1:])}")

    print(f"  Error: {e}")

    displayDataset(dataset, model) 
    displayFrontier(model)
    displayError(e)

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    
    return np.loadtxt(filename, delimiter=',', comments='#')


def displayDataset(dataset, model=None):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
        
    if (model is None): 
        for t, x1, x2 in dataset:
            color = 'red' if int(t) == 1 else 'green'
            plt.scatter(x1, x2, marker='o', color=color)
    else:
        for t, x1, x2 in dataset:
            
            color = 'gray'

            # Calcul de la prédiction
            p = y(model, (x1, x2))
            
            if t == 1:
                if p == 1:
                    color = 'red'
                elif p == 0:
                    color = 'magenta'
                else:
                    color = 'black'
            elif t == 0:
                if p == 0:
                    color = 'green'
                elif p == 1:
                    color = 'cyan'
                else:
                    color = 'black'
                    
            plt.scatter(x1, x2, marker='o', color=color)


def displayFrontier(model):
    """Affiche la frontière de décision du perceptron sous forme d'une droite.
       La frontière est l'ensemble des points où z = 0, soit : w1*x1 + w2*x2 + b = 0
    """

    w1, w2, b = model

    # On récupère les bornes actuelles de l'axe des abscisses
    x1_min, x1_max = plt.xlim()

    x2_min, x2_max = plt.ylim()


    if w2 != 0:
        # Cas général : x2 = -(w1*x1 + b) / w2
        plt.plot([x1_min, x1_max], [-(w1 * x1_min + b) / w2, -(w1 * x1_max + b) / w2], color='orange', linewidth=2)
    else:
        if w1 != 0:
            # Cas particulier : droite verticale x1 = -b / w1
            plt.plot([-b/w1, -b/w1],[x2_min, x2_max], color='orange', linewidth=2)


def displayError(e):
    """
    Affiche la valeur d'erreur dans le coin superieur gauche du graphique
    
    :param e: la valeur d'erreur a afficher
    """
    x_min, x_max = plt.xlim()
    y_min, y_max = plt.ylim()
    
    plt.text(x_min+0.05, y_max-0.3, f"Error: {e:5.2f}", fontsize=9, color='black')

def z(model, features):
    """Calcule la valeur de la fonction d'agregation pour le modele 
    et le vecteur de caracteristiques (features) donne"""
    
    w = model[:-1]   # les n poids
    b = model[-1]    # le biais
    return np.dot(w, features) + b


def phi(z):
    """Calcule la valeur de la fonction d'activation heaviside pour la valeur agregee z"""
 
    return 1 if z >= 0 else 0


def y(model, features):
    """Calcule la valeur prediction pour le modele et les features passes en parametre"""
 
    return phi(z(model, features))
    

def error(model, dataset):
    """
    Calcul l'erreur d'un modele d'apprentissage par rapport a un jeu de donnees
    :param model: le modele pour lequel calculer l'erreur
    :param dataset: le jeux de donnees sur lequel l'erreur est calculee
    :return: l'erreur du modele par rapport au jeux de donnees
    """
    
    e = 0
    for k in range(0,dataset.shape[0]):
        e = e + np.absolute(dataset[k][0] - y(model, dataset[k][1:]))
        
    return e


# Exercice 13 - 1/2 - Implantation de la fonction init
def init(model):
    if (model is None): 
        return
    else:
        for i in range(0,model.shape[0]):
            model[i] = 0


def train(model, dataset):
    """
    Entraine le modele donne en parametre sur le jeu de donnees fourni.
    :param model: Le modele a entrainer
    :param dataset: LE jeux de donnees d'entrainement
    """
    
    # Exercice 13 - 2/2 - Appel a init
    init(model)
    
    return 0;


def main():
    """Point d'entree du programme"""
    
    initPLT()     # Initialisation de MatPlotLib

    model = np.array([-0.5, 1.2, -1.35], dtype=float)

    dataset = readDataset('datasetA.csv')
    
    # Exercice 12 - 2/2 - Appel a la fonction train
    train(model, dataset)
    
    e = error(model, dataset)
    
    print("Model")
    print(f"  w1: {model[0]:9.6f}")
    print(f"  w2: {model[1]:9.6f}")
    print(f"   b: {model[2]:9.6f}")
    print("")
    
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for k in range(0,dataset.shape[0]):
        t = dataset[k][0]
        x1 = dataset[k][1]
        x2 = dataset[k][2]
        print(f"    {k:3d}: {int(t)} - ({x1}, {x2}) - z={z(model, (x1, x2)):9.6f} - \u03c6={phi(z(model, (x1, x2)))} - y={y(model, dataset[k][1:])}")

    print(f"  Error: {e}")

    displayDataset(dataset, model) 
    displayFrontier(model)
    displayError(e)

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()

Contenu du fichier perceptron.py:

import matplotlib.pyplot as plt
import numpy as np


def initPLT():
    """Initialisation des composants de MatPlotLib"""

    plt.figure(figsize=(20, 12, 'cm'))

    plt.xlabel('x1')
    plt.ylabel('x2')

    plt.xlim(0, 5.0)
    plt.ylim(0, 5.0)

    plt.grid(alpha=0.5, linewidth = 1)


def readDataset(filename):
    """Lit un dataset CSV dont chaque ligne est [t, x1, x2]
    et le renvoie sous forme de tableau NumPy (n, 3)."""
    
    return np.loadtxt(filename, delimiter=',', comments='#')


def displayDataset(dataset, model=None):
    """Affiche le dataset passé en paramètre dans le graphique MatPlotLib actuel"""
        
    if (model is None): 
        for t, x1, x2 in dataset:
            color = 'red' if int(t) == 1 else 'green'
            plt.scatter(x1, x2, marker='o', color=color)
    else:
        for t, x1, x2 in dataset:
            
            color = 'gray'

            # Calcul de la prédiction
            p = y(model, (x1, x2))
            
            if t == 1:
                if p == 1:
                    color = 'red'
                elif p == 0:
                    color = 'magenta'
                else:
                    color = 'black'
            elif t == 0:
                if p == 0:
                    color = 'green'
                elif p == 1:
                    color = 'cyan'
                else:
                    color = 'black'
                    
            plt.scatter(x1, x2, marker='o', color=color)


def displayFrontier(model):
    """Affiche la frontière de décision du perceptron sous forme d'une droite.
       La frontière est l'ensemble des points où z = 0, soit : w1*x1 + w2*x2 + b = 0
    """

    w1, w2, b = model

    # On récupère les bornes actuelles de l'axe des abscisses
    x1_min, x1_max = plt.xlim()

    x2_min, x2_max = plt.ylim()


    if w2 != 0:
        # Cas général : x2 = -(w1*x1 + b) / w2
        plt.plot([x1_min, x1_max], [-(w1 * x1_min + b) / w2, -(w1 * x1_max + b) / w2], color='orange', linewidth=2)
    else:
        if w1 != 0:
            # Cas particulier : droite verticale x1 = -b / w1
            plt.plot([-b/w1, -b/w1],[x2_min, x2_max], color='orange', linewidth=2)


def displayError(e):
    """
    Affiche la valeur d'erreur dans le coin superieur gauche du graphique
    
    :param e: la valeur d'erreur a afficher
    """
    x_min, x_max = plt.xlim()
    y_min, y_max = plt.ylim()
    
    plt.text(x_min+0.05, y_max-0.3, f"Error: {e:5.2f}", fontsize=9, color='black')

def z(model, features):
    """Calcule la valeur de la fonction d'agregation pour le modele 
    et le vecteur de caracteristiques (features) donne"""
    
    w = model[:-1]   # les n poids
    b = model[-1]    # le biais
    return np.dot(w, features) + b


def phi(z):
    """Calcule la valeur de la fonction d'activation heaviside pour la valeur agregee z"""
 
    return 1 if z >= 0 else 0


def y(model, features):
    """Calcule la valeur prediction pour le modele et les features passes en parametre"""
 
    return phi(z(model, features))
    

def error(model, dataset):
    """
    Calcul l'erreur d'un modele d'apprentissage par rapport a un jeu de donnees
    :param model: le modele pour lequel calculer l'erreur
    :param dataset: le jeux de donnees sur lequel l'erreur est calculee
    :return: l'erreur du modele par rapport au jeux de donnees
    """
    
    e = 0
    for k in range(0,dataset.shape[0]):
        e = e + np.absolute(dataset[k][0] - y(model, dataset[k][1:]))
        
    return e


def init(model):
    if (model is None): 
        return
    else:
        for i in range(0,model.shape[0]):
            model[i] = 0


# Exercice 14 - 1/4 - Implantation de la fonction epoch
def epoch(model, dataset, alpha):
    for k in range(0,dataset.shape[0]):
        pred = y(model, dataset[k][1:])
        
        if dataset[k][0] != pred:
            
            # Mise a jour des wi (n premiers elements du vecteur de parametres)
            for i in range(0,model.shape[0]-1):
                model[i] = model[i] + alpha*(dataset[k][0]-pred)*dataset[k][i+1]        

            # Mise a jour de b (dernier element du vecteur de parametres)
            model[model.shape[0]-1] = model[model.shape[0]-1] + alpha*(dataset[k][0]-pred)       

    
# Exercice 13 - 2/4 - Appel a init
def train(model, dataset, alpha=1.0):
    """
    Entraine le modele donne en parametre sur le jeu de donnees fourni.
    :param model: Le modele a entrainer
    :param dataset: LE jeux de donnees d'entrainement
    """
    
    init(model)
    
    # Exercice 13 - 3/4 - Appel a init
    epoch(model, dataset, alpha)
    
    return 0;


def main():
    """Point d'entree du programme"""
    
    initPLT()     # Initialisation de MatPlotLib

    model = np.array([-0.5, 1.2, -1.35], dtype=float)

    dataset = readDataset('datasetA.csv')
    
    # Exercice 13 - 4/4 - Modification de l'appel a train
    train(model, dataset, 1.0)
    
    e = error(model, dataset)
    
    print("Model")
    print(f"  w1: {model[0]:9.6f}")
    print(f"  w2: {model[1]:9.6f}")
    print(f"   b: {model[2]:9.6f}")
    print("")
    
    print("Dataset")
    print("  Dimension: "+str(dataset.shape[1]))
    print("  Size     : "+str(dataset.shape[0]))
    print("  Samples  : ")
    
    for k in range(0,dataset.shape[0]):
        t = dataset[k][0]
        x1 = dataset[k][1]
        x2 = dataset[k][2]
        print(f"    {k:3d}: {int(t)} - ({x1}, {x2}) - z={z(model, (x1, x2)):9.6f} - \u03c6={phi(z(model, (x1, x2)))} - y={y(model, dataset[k][1:])}")

    print(f"  Error: {e}")

    displayDataset(dataset, model) 
    displayFrontier(model)
    displayError(e)

    plt.show()    # Affichage du canevas MatPlotLib


if __name__ == "__main__":
    main()