Discussion :

[Rumpel]

Bonjour,

Je suis tombé sur cette vidéo :
http://doublezoom.free.fr/programmat...e_Survival.php

Mais je suis incapable de dire si la programmation d'un tel projet est facile ou pas.
L'auteur donne peu d'informations.

Par exemple, sur le nombre de neurones, comme il y a 3 outputs, il semble normal qu'il y ait 3 neurones sur la deuxième couche, mais pourquoi seulement 4 sur la première alors qu'il y a 5 inputs ? Que se passerait il si on faisait varier le nombre de neurones sur la première couche ?
Quelle fonction de transfert doit on prendre ? Intuitivement je testerais la sigmoïde ...
Quel valeur de seuil choisir ?

Et pour l'algorithme génétique ensuite, quelle fonction de fitness prendre ?

Merci pour la réponse à ces premières questions, peut être y en aura t il d'autres, mais je pense que pourrait être sympa de faire un tutoriel avec un exemple concret et amusant .

[dourouc05]

Un neurone a autant d'entrées que tu veux, il a une seule sortie : si ton réseau a trois sorties, tu as au moins trois neurones ; par contre, le nombre d'entrées n'a rien à voir. Un neurone fait juste une combinaison linéaire de ses entrées, applique sa fonction et il a calculé sa sortie, il ne fait rien d'autres.

[Rumpel]

Hello,

Merci pour ta réponse.
Mais ici alors concrètement, comment sait on le nombre de neurones que l'on met sur la première couche (il faut avoir cliqué sur le lien du premier post pour le schéma) ?
Est ce que le poids 0 est fixé ou alors il peut varier comme les autres coefficients ?
Je n'ai pas compris à quoi il servait exactement (la valeur de seuil).

Quel est l'influence de la fonction de transfert ?
Je peux prendre 1/(1+e^-x) ou tanh(x) ?

J'ai trouvé ce code, mais je ne le comprends pas trop, outre que je ne code pas en Python.
Comment fonctionne la rétro propagation et à quoi ça sert ...

Code python :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
#!/usr/bin/python
#coding: UTF-8
 
import math
 
import numpy as np
 
# our sigmoid function, tanh is a little nicer than the standard 1/(1+e^-x)
def sigmoid(x):
    return np.tanh(x)
 
# derivative of our sigmoid function
def dsigmoid(x):
    return 1.0 - x**2
 
 
class MLP:
    def __init__(self, *args):
        self.args = args
        n = len(args)
 
        self.layers = [np.ones(args[i] + (i==0)) for i in range(0, n)]
 
        self.weights = list()
        for i in range(n-1):
            R = np.random.random((self.layers[i].size, self.layers[i+1].size))
            self.weights.append((2*R-1)*0.20)
 
        self.m = [0 for i in range(len(self.weights))]
 
 
    def update(self, inputs):
        self.layers[0][:-1] = inputs
 
        for i in range(1, len(self.layers)):
            self.layers[i] = sigmoid(np.dot(self.layers[i-1], self.weights[i-1]))
 
 
        return self.layers[-1]
 
 
    def backPropagate(self, inputs, outputs, a=0.1, m=0.1):
 
        error = outputs - self.update(inputs)
        de = error*dsigmoid(self.layers[-1])
        deltas = list()
        deltas.append(de)
 
 
        for i in range(len(self.layers)-2, 0, -1):
 
            deh = np.dot(deltas[-1], self.weights[i].T) * dsigmoid(self.layers[i])
            deltas.append(deh)
 
        deltas.reverse()
 
        for i, j in enumerate(self.weights):
 
            layer = np.atleast_2d(self.layers[i])
            delta = np.atleast_2d(deltas[i])
 
            dw = np.dot(layer.T,delta)
            self.weights[i] += a*dw + m*self.m[i]
            self.m[i] = dw
 
 
 
 
pat = (((0, 0), 0),
    ((0, 1), 1),
    ((1, 0), 1),
    ((1, 1), 0))
 
 
n = MLP(2, 3, 1)
 
for i in range(1000):
    for p in pat:
        n.backPropagate(p[0], p[1])
 
for p in pat:
    print n.update(p[0])

Edit :
" Il n'existe aucune loi, aucune règle, aucun théorème qui permettrait de déterminer le nombre de neurones à placer dans la couche cachée pour avoir un réseau de neurones optimal. "
(Tuto Alp)

Bon, une question en moins
Mais il en reste d'autres ...

[dourouc05]

Mais ici alors concrètement, comment sait on le nombre de neurones que l'on met sur la première couche (il faut avoir cliqué sur le lien du premier post pour le schéma) ?

Tu en mets suffisamment pour que ton réseau fonctionne bien. Règle de bonne pratique : pas trop de neurones, histoire de limiter la complexité de ton réseau et d'éviter de lui faire apprendre du bruit plus que des choses intéressantes. Il n'est pas rare de tenter un certain nombre de réseaux différents, en faisant varier le nombre de neurones de chaque couche et les liens entre neurones, pour trouver la meilleure structure pour ton problème particulier.

Tu peux considérer la première couche comme une compression des données en entrée au réseau, c'est-à-dire que la sortie de ces premiers neurones représentera une version condensée de l'information nécessaire pour le reste du réseau. C'est un raisonnement "avec les mains", c'est ce qui est fait dans l'apprentissage profond (mot clé : autoencodeur). Rien ne t'empêche cependant d'avoir plus de neurones que d'entrées .

Est ce que le poids 0 est fixé ou alors il peut varier comme les autres coefficients ?
Je n'ai pas compris à quoi il servait exactement (la valeur de seuil).

C'est un degré de liberté supplémentaire pour l'apprentissage du réseau qui l'aide à obtenir de meilleurs résultats.

Quel est l'influence de la fonction de transfert ?
Je peux prendre 1/(1+e^-x) ou tanh(x) ?

Comment fonctionne la rétro propagation et à quoi ça sert ...

L'objectif de l'algorithme de rétropropagation du gradient de l'erreur est de déterminer les coefficients optimaux pour chaque neurone ; il doit être combiné à un algorithme d'optimisation non linéaire, comme la plus grande pente, pour effectivement minimiser l'erreur du réseau (voir https://fr.wikipedia.org/wiki/Algorithme_du_gradient, par exemple). Pour que cet algorithme d'optimisation fonctionne, ta fonction de transfert doit être continûment dérivable (hypothèse nécessaire pour une bonne partie des algorithmes d'optimisation non linéaire). C'est tout ce que tu as comme contrainte forte. Ensuite, d'autres critères peuvent s'appliquer (voir http://stats.stackexchange.com/quest...ation-function).

[Matthieu76]

Salut, je pense qu'il faut que tu trouves ta propre fonction qui fait que plus tu es proche du résultat attendu moins ton réseaux doit se modifie et plus tu es éloigner de ton résultat plus ton réseaux doit se modifier, mais fait attention à ne pas perdre un réseaux de neurone qui serait plus performant que celui que tu as actuellement.

Je pense que déterminer cette fonction est la vrai difficulté des réseaux de neurones.

En espérant que cela t'a aidé

Après il y a peut-être des méthodes qui te donne directement cette fonction mais je ne connais pas assez bien les réseaux de neurones.

[Rumpel]

Ok, merci, je crois que j'ai assez d'éléments pour tenter de programmer, si j'ai un souci, je reviens
Comme c'est juste pour m'amuser je mettrais mon code ici ...