Résiliente rétropropagation réseau de neurones - question sur gradient

Question

D'abord, je veux dire que je suis vraiment nouveau pour les réseaux de neurones et je ne comprends pas très bien;)

J'ai fait ma première implémentation C # du réseau de neurones de rétropropagation. Je l'ai testé en utilisant XOR et il semble travail.

Maintenant, je voudrais changer ma mise en œuvre à utiliser rétropropagation élastique (RPROP - http: //en.wikipedia .org / wiki / RPROP ).

La définition dit: « . RPROP prend en compte que le signe de la dérivée partielle sur tous les modèles (pas de grandeur), et agit indépendamment sur chaque « poids »

Quelqu'un pourrait-il me dire ce dérivé partiel sur tous les modèles est? Et comment dois-je calculer cette dérivée partielle pour un neurone dans la couche cachée.

Merci beaucoup

Mise à jour:

Ma base de mise en œuvre sur ce code Java: www_.dia.fi.upm.es/~jamartin/downloads/bpnn.java

Mon méthode backPropagate ressemble à ceci:

public double backPropagate(double[] targets)
    {
        double error, change;

        // calculate error terms for output
        double[] output_deltas = new double[outputsNumber];

        for (int k = 0; k < outputsNumber; k++)
        {

            error = targets[k] - activationsOutputs[k];
            output_deltas[k] = Dsigmoid(activationsOutputs[k]) * error;
        }

        // calculate error terms for hidden
        double[] hidden_deltas = new double[hiddenNumber];

        for (int j = 0; j < hiddenNumber; j++)
        {
            error = 0.0;

            for (int k = 0; k < outputsNumber; k++)
            {
                error = error + output_deltas[k] * weightsOutputs[j, k];
            }

            hidden_deltas[j] = Dsigmoid(activationsHidden[j]) * error;
        }

        //update output weights
        for (int j = 0; j < hiddenNumber; j++)
        {
            for (int k = 0; k < outputsNumber; k++)
            {
                change = output_deltas[k] * activationsHidden[j];
                weightsOutputs[j, k] = weightsOutputs[j, k] + learningRate * change + momentumFactor * lastChangeWeightsForMomentumOutpus[j, k];
                lastChangeWeightsForMomentumOutpus[j, k] = change;

            }
        }

        // update input weights
        for (int i = 0; i < inputsNumber; i++)
        {
            for (int j = 0; j < hiddenNumber; j++)
            {
                change = hidden_deltas[j] * activationsInputs[i];
                weightsInputs[i, j] = weightsInputs[i, j] + learningRate * change + momentumFactor * lastChangeWeightsForMomentumInputs[i, j];
                lastChangeWeightsForMomentumInputs[i, j] = change;
            }
        }

        // calculate error
        error = 0.0;

        for (int k = 0; k < outputsNumber; k++)
        {
            error = error + 0.5 * (targets[k] - activationsOutputs[k]) * (targets[k] - activationsOutputs[k]);
        }

        return error;
    }

Ainsi peut-on utiliser la variable change = hidden_deltas[j] * activationsInputs[i] en tant que gradient (dérivée partielle) pour contrôler le chanter?

Answer 1

Je pense que le « sur tous les modèles » signifie simplement « à chaque itération » ... un coup d'oeil à la RPROP papier

Pour le dérivé paritial: vous avez déjà mis en œuvre l'algorithme de rétro-propagation normale. Ceci est une méthode pour calculer efficacement le gradient ... il vous calculez les valeurs ô pour les neurones isolés, qui sont en fait les valeurs ∂E de négatif / ∂w, à savoir le dérivé parital de l'erreur globale en fonction des poids.

au lieu de multiplier les poids avec ces valeurs, vous prenez une des deux constantes (η + ou η-), selon que le signe a changé

Answer 2

Ce qui suit est un exemple d'une partie d'une mise en œuvre de la technique de formation de RPROP dans l'intelligence artificielle Encog bibliothèque. Il devrait vous donner une idée de la façon de procéder. Je vous conseille de télécharger toute la bibliothèque, car il sera plus facile de passer par le code source dans un IDE plutôt que par l'interface svn en ligne.

http://code.google.com/p/encog-cs/source/browse/#svn/trunk/encog-core/encog-core-cs/Neural/Networks/Training / propagation / résiliente

http://code.google.com/ p / encog-cs / source / browse / # svn / trunk

Notez que le code est en C #, mais ne devrait pas être difficile à traduire dans une autre langue.