python réseau de neuronne arreter l'entrainement automatiquement

Bonjour, je débute avec les réseaux de neurones, j’ai trouvé de tres bon tutos ici
https://github.com/mattm/simple-neural-network/blob/master/neural-network.py et ici : https://iamtrask.github.io/2015/07/12/basic-python-network/

mais ce je comprend pas c’est pourquoi ils entrainent leurs neurone 10000 ou 60000 fois ? pourquoi avoir choisit ces valeurs de maniérè arbitraire.

a partir de ces tutos j’ai crée ce code, avec la pahse avant et la rétro propagation :

 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

from numpy import exp, array, random, dot


class NeuralNetwork():
    def __init__(self):
        random.seed(1)
        self.synaptic_weights = 2 * random.random((3, 1)) - 1

    def __sigmoid(self, x):
        return 1 / (1 + exp(-x))

    def __sigmoid_derivative(self, x):
        return x * (1 - x)

    def train(self, training_set_inputs, training_set_outputs, number_of_training_iterations):
        for iteration in range(number_of_training_iterations):
            output = self.think(training_set_inputs)
            error = training_set_outputs - output
            adjustment = dot(training_set_inputs.T, error * self.__sigmoid_derivative(output))
            self.synaptic_weights += adjustment

    def think(self, inputs):
        return self.__sigmoid(dot(inputs, self.synaptic_weights))


if __name__ == "__main__":

    neural_network = NeuralNetwork()
    training_set_inputs = array([[0, 0, 1], [1, 1, 1], [1, 0, 1], [0, 1, 1]])
    training_set_outputs = array([[0, 0.84, 0.67, 0.456]]).T

    neural_network.train(training_set_inputs, training_set_outputs, 10000)

    print ("Solution of [1, 0, 0] -> ?: ")
    print (neural_network.think(array([1, 0, 0])))

Mon code marche mais comme vous pouvez le voir, je l’entraine 10000 fois. Mon but serait de virer ce 10000 et déterminer cette valeur avec un moyen plus automatique/plus "intelligent", pouvez vous m’aider ? existe t’il un moyen pour déterminer a partir de quand nos neurones sont assez entrainer et éviter donc un sur apprentissage ?

Tu peux entraîner ton réseau jusqu’à ce que le nombre d’erreur te conviennes.

De cette manière, tu n’entraînes pas ton réseau X fois, mais jusqu’à ce que l’erreur atteigne un certain seuil.

Le problème dans ce cas, c’est que si ton seuil de tolérance est non atteignable, tu vas attendre longtemps.

Pour lutter contre cela, tu peux aussi arrêter l’apprentissage quand il ne progresse plus assez rapidement (mais les minimas locaux sont des gros ennemis !). Mais je ne conseillerais pas cette approche.

du coup si tu ne me conseille pas cette approche, cela m’aide pas beaucoup mais si je comprend bien, je compte les erreurs à chaque cycle et si par exemple il y’en a moins de 2 par exemple alors je peut arrêter ?

Je ne déconseille que la seconde partie.

Tu n’es pas forcé de compter le nombre d’erreurs, tu peux aussi prendre la distance moyenne ou ce que tu veux qui permettrait de caractériser ton erreur. Mais tout cela dépend de ton problème.