.. module-reseau.perceptron

==========================
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
******
.. autoclass:: reseau.perceptron.Couche
   :members: nb_neurones, nb_in, f, b, W, n, a, out, Fpoint

Reseau
******
.. autoclass:: reseau.perceptron.Reseau
   :members:

Fonctions
*********
.. autofunction:: reseau.perceptron.gen_matrix
.. autofunction:: reseau.perceptron.sgn
.. autofunction:: reseau.perceptron.sgn_vect
.. autofunction:: reseau.perceptron.id
.. autofunction:: reseau.perceptron.sigm
.. autofunction:: reseau.perceptron.tanh
.. autofunction:: reseau.perceptron.seuilmax_vect
.. autofunction:: reseau.perceptron.normalize_vect