Module ‘reseau.perceptron’

Ce module permet de modéliser un réseau de neurones, pour le moment un perceptron multicouche.

Utilisation

Premièrement, importer le module:

from reseau import perceptron as p

Dorénavant, le module se nommera p.

Il faut ensuite créer le réseau, grace à la classe Reseau:

r = p.Reseau(nb_in, neur_couches, fnc_couches, b_couches=[], W_couches=[])

On peut ensuite faire apprendre des conaissnces au réseau ou en obtenir la sortie:

r.train1(base, pas=0.1, shuffle=True) # entraine le réseau un fois avec une 'base'
r.learn1(base, ecart=0.1, pas=0.1, shuffle=True) # entraine le réseau avec la 'base' tant que l'erreur est au dessus de 'ecart'
r.a(p) # sortie avec comme vecteur d'entrée d'entrée p

Exemple

Créons un réseau simple qui détectera l’adjacence de deux ‘1’ dans une liste. Le but de ce réseau est de retourner 1 quand deux 1 sont adjacents, et -1 dans le cas contraire. Par exemple, [[0],[0],[1],[0]] -> -1, tandis que [[0],[1],[1],[0]] -> 1

On commence par créer le réseau avec des poids quelconques, avec le réseau que j’ai obtenu. Le nombre de neurones sur chaque couche a été choisi aritrairement, rien ne vous empêche de le changer pour essayer.

from reseau import perceptron as p
r = p.Reseau(4, [4,1], [p.tanh, p.id])

>>> print(r)
     COUCHE 0
     | neurones: 4
     | entrées: 4
     | biais:
     [[ 0.97]
      [-0.59]
      [-0.32]
      [-0.45]]
     | W:
     [[-0.8  -0.6  -0.9   0.96]
      [-0.82  0.96  0.15 -0.49]
      [-0.67 -0.38 -0.27 -0.63]
      [-0.67 -0.8  -0.83 -0.47]]
     ---
     COUCHE 1
     | neurones: 1
     | entrées: 4
     | biais:
     [[-0.01]]
     | W:
     [[-0.45  0.78  0.38 -0.86]]
     ---

Il faut ensuite faire apprendre à notre réseau son rôle. Pour cela on utilise une petit base d’aprentissage

base = [
     ([[0],[0],[1],[0]], -1) ,
     ([[0],[1],[1],[0]], +1) ,
     ([[0],[0],[1],[1]], +1) ,
     ([[0],[1],[0],[1]], -1) ,
     ([[1],[1],[1],[0]], +1) ,
     ([[1],[0],[0],[0]], -1)
]

On peut lui faire apprendre 100 fois

for i in range(100): # Assez peu fin comme critère d'arret de l'aprentissage, certes.
     r.train1(base)

Ou lui faire apprendre tant que l’erreur est supérieure à 0.1, avec un pas variable, qui se divise par 2 à chaque palier d’erreur de 0.1

r.learn12(base, ecart=0.1, div=2)

On peut ensuite vérifier que le réseau sort les bonnes valeurs pour les entrées présentes dans la base:

>>> for (p,d) in base:
...     print(p, r.a(p))
...
[[0], [0], [1], [0]] [[-0.7904701440185451]]
[[0], [1], [1], [0]] [[ 0.7502050292794594]]
[[0], [0], [1], [1]] [[ 0.7427709530924954]]
[[0], [1], [0], [1]] [[-0.6414962450342306]]
[[1], [1], [1], [0]] [[ 1.2927465025782612]]
[[1], [0], [0], [0]] [[-1.2080975879044218]]

La base est donc correctement apprise, dès que deux 1 sont adjacents, la valeur de sortie est positive.

On peut ensuite tester avec des valeurs n’étant pas dans la base, et constater que le réseau remplit bien son rôle, même dans des cas “inconnus”. ::

>>> r.a([[1],[1],[0],[0]])
[[0.22379988971654755]]

>>> r.a([[0],[0],[0],[0]])
[[-1.5643763171699245]]

>>> r.a([[0],[0],[0],[1]])
[[-1.4698045564617104]]

Enfin...

>>> r.a([[1],[0],[1],[0]])
[[1.111763254832399]] # Devrait retourner un nombre négatif...

Référence

Couche

class reseau.perceptron.Couche(nb_neurones, nb_in, f, biais=[], W=[], random_min=-1, random_max=1)

Classe représentant une couche de neurones.

nb_neurones = 0

nombre de neurones présents sur la couche

nb_in = 0

nombre d’entrées de la couche

f = None

fonction d’activation du neurone (de type float -> float )

b = [[0]]

matrice colonne de biais (de hauteur nb_neurones)

W = [[0]]

Matrice des poids de la couche (de dimension nb_neurones x nb_in)

n(p)

Retourne le vecteur de sortie brut (= avant la fonction d’activation) [de dimension nb_neurones x 1].

p: matrice colonne des entrées données au neurone [de dimension nb_in x 1]

a(p)

Retourne le vecteur sortie du neurone [de dimension nb_neurone x 1].

p: matrice colonne des entrées données au neurone [de dimension nb_neurones x 1]

out(n)

Applique la fonction d’acivation au vecteur n.

Fpoint(n)

Retourne la matrice Fpoint, contenant sur sa diagonale la dérivée de f appliquée au point n[i], n étant en général la sortie brute du neurone (reseau.perceptron.Couche.n()).

Reseau

class reseau.perceptron.Reseau(nb_in, neur_couches, fnc_couches, b_couches=[], W_couches=[], random_min=-1, random_max=1)

Classe représentant un réseau de neurone de type perceptron multicouche.

• neur_couches : nombre de neurones pour chaque couches (la couche finale déterminant la taille de la sortie)
• fnc_couches : fonction d’activation pour chaque couche
• b_couches : tableau de biais de chaque couche (matrice colonne de hauteur le nombre de neurone de la couche)
• W_couches : matrices des poids de chaque couche

a(p)

Retourn la sortie finale du réseau, en ayant comme entrée p [vecteur de hauteur nb_in].

a_couche(p, c)

Retourne la valeur de la sortie de la couche n°c, en ayant p comme entrée du réseau [vecteur de hauteur nb_in].

erreur(attendu)

Retourne l’erreur du réseau. attendu est un couple (entrée, sortie_attendue), l’erreur est simplement la plus grande différence entre la sortie attendue et la sortie effective.

erreur_moyenne(base)

Retourne l’erreur moyenne quadratique obtenue sur toutes les sorties de la base.

learn1(base, ecart=0.1, pas=0.1, shuffle=True, base_inconnu=[], stop=-1, stoperror=-1, print_err=False, print_file='')

Réalise un aprentissage continu tant que la sortie du réseau de neurone produit un écart moyen trop important. L’aprentissage s’arrête si l’erreur est au dessus d’un minimum 10 fois d’affilé (comparaison à l’erreur de la bas einconnue si elle est fournie). Si le nombre d’aprentissage est supérieur à stoperror, la fonction lève une exception OverflowError.

Retourne un tuple contenant les listes des erreurs des exemples de la base et inconnu (si pas de base inconnue fournie: liste vide).

learn11(base, ecart=0.1, pas=0.1, shuffle=True, stoperror=-1, print_err=False)

Utilise la fonction learn1 avec un pas variable (le pas est toujours supérieur à pas ). Si le nombre d’aprentissage est supérieur à stoperror, la fonction lève une exception OverflowError

learn12(base, ecart=0.1, div=10, shuffle=True, base_inconnu=[], stop=1000, print_err=False, print_file='')

Utilise la fonction learn1 avec un pas variable par paliers. Dès que l’erreur moyenne baisse de 0.1 (puis 0.01, 0.001, ...), on diminue le pas en le divisant par div. Et on continue tant que l’erreur moyenne est supérieure à ecart.

Retourne un tuple contenant les listes des erreurs des exemples de la base et inconnu (si pas de base inconnue fournie: liste vide).

load(filename)

Charge un réseau préaléblement sauvé dans le fichier donné.

n_couche(p, c)

Retourne la valeur de la sortie brute de la couche n°c, en ayant p comme entrée du réseau [vecteur de hauteur nb_in].

save(filename)

Sauve le réseau dans le fichier spécifié.

train1(base, pas=0.1, shuffle=True)

Mélange la base si nécessaire, puis procède à un unique aprentissage à l’aide de cette base (algorithme de rétropropagation du gradient d’erreur).

La base est une liste de couples (p,d) contenant: l’entrée p et la sortie d attendue.

Fonctions

reseau.perceptron.gen_matrix(lines, col, val=0, random=False, start=-1, end=1)

Genère une np.matrix de lines lignes et col colonnes. Si random vaut False (par défaut), la matrice est remplie de la valeur val, sinon elle est remplie de nombres aléatoires compris entre start et end.

reseau.perceptron.sgn(x)

Retourne le signe de x: 1 si x>0, -1 si x<0 et 0 si x=0.

reseau.perceptron.sgn_vect(v)

Applique la fonction reseau.perceptron.sgn() à la liste v.

reseau.perceptron.id(x)

Retourne x.

reseau.perceptron.sigm(x)

Fonction sigmoïde.

reseau.perceptron.tanh(x)

Fonction tangeante hyperbolique.

reseau.perceptron.seuilmax_vect(v)

Retourne un vecteur similaire contenant uniquement des 0 sauf un 1 sur la ligne contenant la valeur maximale.

reseau.perceptron.normalize_vect(v)

Retoun un vecteur similire à l’entrée, mais dont le nombre de décimales est fixé à deux.