web-dev-qa-db-fra.com

configuration simple du réseau neuronal java

J'ai décidé de jouer avec des concepts simples impliquant des réseaux de neurones en Java, et en adaptant un code quelque peu inutile trouvé sur un forum, j'ai été capable de créer un modèle très simple pour la simulation du débutant typique XOR :


public class MainApp {
    public static void main (String [] args) {
        Neuron xor = new Neuron(0.5f);
        Neuron left = new Neuron(1.5f);
        Neuron right = new Neuron(0.5f);
        left.setWeight(-1.0f);
        right.setWeight(1.0f);
        xor.connect(left, right);

        for (String val : args) {
            Neuron op = new Neuron(0.0f);
            op.setWeight(Boolean.parseBoolean(val));
            left.connect(op);
            right.connect(op);
        }

        xor.fire();

        System.out.println("Result: " + xor.isFired());

    }
}


public class Neuron {
    private ArrayList inputs;
    private float weight;
    private float threshhold;
    private boolean fired;

    public Neuron (float t) {
        threshhold = t;
        fired = false;
        inputs = new ArrayList();
    }

    public void connect (Neuron ... ns) {
        for (Neuron n : ns) inputs.add(n);
    }

    public void setWeight (float newWeight) {
        weight = newWeight;
    }

    public void setWeight (boolean newWeight) {
        weight = newWeight ? 1.0f : 0.0f;
    }

    public float getWeight () {
        return weight;
    }

    public float fire () {
        if (inputs.size() > 0) {
            float totalWeight = 0.0f;
            for (Neuron n : inputs) {
                n.fire();
                totalWeight += (n.isFired()) ? n.getWeight() : 0.0f;
            }
            fired = totalWeight > threshhold;
            return totalWeight;
        }
        else if (weight != 0.0f) {
            fired = weight > threshhold;
            return weight;
        }
        else {
            return 0.0f;
        }
    }

    public boolean isFired () {
        return fired;
    }
}

Dans ma classe principale, j'ai créé la simulation simple en modélisant le diagramme de Jeff Heaton: XOR diagram

Cependant, je voulais m'assurer que mon implémentation pour la classe Neuron est correcte. J'ai déjà testé toutes les entrées possibles ([true true], [true false], [false true], [false false]), et elles ont toutes passé avec succès ma vérification manuelle. De plus, puisque ce programme accepte les entrées en tant qu'arguments, il semble également passer une vérification manuelle pour des entrées telles que [true false false], [true true false], etc.

Mais conceptuellement, cette implémentation serait-elle correcte? Ou comment puis-je l'améliorer avant de commencer à développer et à approfondir la recherche sur ce sujet?

Je vous remercie!

javaartificial-intelligenceneural-networksimulation
22
jerluc

Cela ressemble à un bon point de départ. J'ai quelques suggestions:

  1. Pour l’évolutivité, fire () doit être restructuré afin qu’un neurone déjà activé avec le jeu d’entrées actuel n’ait pas à recalculer à chaque fois. Ce serait le cas si vous aviez une autre couche cachée ou plus d'un noeud de sortie.

  2. Envisagez de diviser votre calcul de seuil en sa propre méthode. Ensuite, vous pouvez sous-classer Neuron et utiliser différents types de fonctions d’activation (sigmoïde bipolaire, RBF, linéaire, etc.).

  3. Pour apprendre des fonctions plus complexes, ajoutez une entrée de polarisation à chaque neurone. C'est en gros une autre entrée avec sa propre valeur de poids, mais l'entrée est toujours fixée à 1 (ou -1).

  4. N'oubliez pas de tenir compte des méthodes de formation. La rétro-propagation aura besoin de quelque chose comme l'inverse de fire (), pour prendre une sortie cible et répercuter les changements de poids à travers chaque couche.

9
darkcanuck

D'après le travail (limité) que j'ai effectué avec les réseaux de neurones, cette implémentation et ce modèle me semblent corrects - le résultat correspond à ce que j'attendais et la source semble solide.

0
Michael Berry