Neuronales Netz

Bitte aktiviere JavaScript!
Habe ich:

Java:
package suchtytv.complexservice.game.maths.artificialneuralnetwork.multilayerperceptron;

import java.util.ArrayList;
import java.util.Arrays;
import org.neuroph.core.Layer;
import org.neuroph.core.Neuron;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.learning.error.MeanSquaredError;

import org.neuroph.core.transfer.Sigmoid;
import org.neuroph.core.transfer.TransferFunction;
import org.neuroph.nnet.MultiLayerPerceptron;
import org.neuroph.nnet.learning.BackPropagation;
import org.neuroph.util.TransferFunctionType;
import org.neuroph.util.data.norm.MaxMinNormalizer;

import suchtytv.complexservice.game.maths.VectorND;

public class GamePlayingNetwork  {
    MultiLayerPerceptron nn;

    public GamePlayingNetwork(int inputNodes, int outPutNodes) {
       

        nn = new MultiLayerPerceptron(inputNodes,50,50,50,outPutNodes);

        for(Layer l : nn.getLayers()) {
            for(Neuron n : l.getNeurons()) {
                n.setTransferFunction(new Sigmoid());
            }
        }
        nn.randomizeWeights();
        BackPropagation bp = new BackPropagation();
        bp.setLearningRate(0.1);
        bp.setErrorFunction(new MeanSquaredError());
        bp.setMaxError(0.01);
        bp.setMaxIterations(100);
        nn.setLearningRule(bp);

    }
   
    public void train(ArrayList<VectorND> samples) {
        System.out.println("Training with "+ samples.size() + " sample(s)... this could take a while ");

        DataSet set = new DataSet(47, 2);
        for(VectorND nd : samples) {
        double[] all = nd.getArray();
        double[] input  = Arrays.copyOfRange(all, 0, nd.length()-2);
        double[] output  = Arrays.copyOfRange(all, nd.length()-2, nd.length());
        set.addRow(input, output);
       
       
        }
        new MaxMinNormalizer().normalize(set);
        set.shuffle();
        nn.learn(set);
//        nn.getLearningRule().setLearningRate(nn.getLearningRule().getLearningRate() - 0.5*nn.getLearningRule().getLearningRate());
        System.out.println("Training Done");
    }

    public MultiLayerPerceptron getNeuralNetwork() {
        return nn;
       
    }

    public void setInput() {
       
       
    }

    public void setInput(double[] array) {
        nn.setInput(array);
       
    }

    public VectorND getOutput() {
        nn.calculate();
       
        // TODO Auto-generated method stub
        double[] b = nn.getOutput();
        VectorND nd = new VectorND();
        nd.add(b);
        return nd;
    }
   
   

}
Jetzt werden die Werte lustiger weise alle NaN was eigentlich gar nicht sein kann...
 
Nur, damit wir vom gleichen reden, es geht um
Code:
      double[] input = {a,b,c,d,e};
      double[] output = {0.5*a*b+c+d*e*0.5}; // Werte könne maximal 2 sein , da double zwischen 0 und 1
D. h. Dein Ausgabeneuron liefert Werte zwischen 0 und 1 (bzw. -1 und +1), gleichzeitig soll der Fehler zu Werten zwischen 0 und 2 minimiert werden. Damit ist in jedem Fall ein gewisser Feler enthalten, weil das Ausgabeneuron Werte > 1 nicht "darstellen" kann.

Was das denormalisieren betrifft: soweit sind wir noch gar nicht :) Es ging ja erst einmal darum, dass das Netz als solches funktioniert.

Habe Deinen Code mal ein wenig angepasst, nicht erschrecken, ist nicht schön :)

Java:
public class Network implements LearningEventListener {
    MultiLayerPerceptron nn;
    public Network() {
        nn = new MultiLayerPerceptron(TransferFunctionType.SIGMOID, 5,4,1);
        MomentumBackpropagation bp = new MomentumBackpropagation();
        bp.setMomentum(0.9);
        bp.setLearningRate(0.1);
        bp.setErrorFunction(new MeanSquaredError());
        bp.setMaxError(0.001);
        bp.addListener(this);
        nn.setLearningRule(bp);
    }

    public void train() {
        DataSet set = new DataSet(5, 1);
        for(int i = 0; i < 1000; ++i) {
            Random r = new Random();
            double a = r.nextDouble();
            double b = r.nextDouble();

            double c = r.nextDouble();
            double d = r.nextDouble();
            double e = r.nextDouble();

            double[] input = {a,b,c,d,e};
            double[] output = {0.5*a*b+c+d*e*0.5};
            set.addRow(input, output);
        }

        Normalizer normalizer = new MaxMinNormalizer();
        normalizer.normalize(set);

        set.shuffle();
        List<DataSet> trainAndTest = set.sample(new SubSampling(70));

        DataSet training = trainAndTest.get(0);
        nn.learn(training);
        System.out.println("Training Done.");

        DataSet test = trainAndTest.get(1);
        for (DataSetRow row : test.getRows()) {
            nn.setInput(row.getInput());
            nn.calculate();
            double actual = nn.getOutput()[0];
            double expected = row.getDesiredOutput()[0];
            double err = Math.pow(actual - expected, 2);

            System.out.printf("Actual: %f, desired: %f, err: %f\n", actual, expected, err);
        }
    }

    public static void main(String args[]) {
        Network nn = new Network();
        nn.train();
    }

    @Override
    public void handleLearningEvent(LearningEvent event) {
        BackPropagation bp = (BackPropagation)event.getSource();
        if (event.getEventType() != LearningEvent.Type.LEARNING_STOPPED)
            System.out.println(bp.getCurrentIteration() + ". iteration : "+ bp.getTotalNetworkError());
    }
}
 
Nur, damit wir vom gleichen reden, es geht um
Code:
      double[] input = {a,b,c,d,e};
      double[] output = {0.5*a*b+c+d*e*0.5}; // Werte könne maximal 2 sein , da double zwischen 0 und 1
D. h. Dein Ausgabeneuron liefert Werte zwischen 0 und 1 (bzw. -1 und +1), gleichzeitig soll der Fehler zu Werten zwischen 0 und 2 minimiert werden. Damit ist in jedem Fall ein gewisser Feler enthalten, weil das Ausgabeneuron Werte > 1 nicht "darstellen" kann.

Was das denormalisieren betrifft: soweit sind wir noch gar nicht :) Es ging ja erst einmal darum, dass das Netz als solches funktioniert.

Habe Deinen Code mal ein wenig angepasst, nicht erschrecken, ist nicht schön :)

Java:
public class Network implements LearningEventListener {
    MultiLayerPerceptron nn;
    public Network() {
        nn = new MultiLayerPerceptron(TransferFunctionType.SIGMOID, 5,4,1);
        MomentumBackpropagation bp = new MomentumBackpropagation();
        bp.setMomentum(0.9);
        bp.setLearningRate(0.1);
        bp.setErrorFunction(new MeanSquaredError());
        bp.setMaxError(0.001);
        bp.addListener(this);
        nn.setLearningRule(bp);
    }

    public void train() {
        DataSet set = new DataSet(5, 1);
        for(int i = 0; i < 1000; ++i) {
            Random r = new Random();
            double a = r.nextDouble();
            double b = r.nextDouble();

            double c = r.nextDouble();
            double d = r.nextDouble();
            double e = r.nextDouble();

            double[] input = {a,b,c,d,e};
            double[] output = {0.5*a*b+c+d*e*0.5};
            set.addRow(input, output);
        }

        Normalizer normalizer = new MaxMinNormalizer();
        normalizer.normalize(set);

        set.shuffle();
        List<DataSet> trainAndTest = set.sample(new SubSampling(70));

        DataSet training = trainAndTest.get(0);
        nn.learn(training);
        System.out.println("Training Done.");

        DataSet test = trainAndTest.get(1);
        for (DataSetRow row : test.getRows()) {
            nn.setInput(row.getInput());
            nn.calculate();
            double actual = nn.getOutput()[0];
            double expected = row.getDesiredOutput()[0];
            double err = Math.pow(actual - expected, 2);

            System.out.printf("Actual: %f, desired: %f, err: %f\n", actual, expected, err);
        }
    }

    public static void main(String args[]) {
        Network nn = new Network();
        nn.train();
    }

    @Override
    public void handleLearningEvent(LearningEvent event) {
        BackPropagation bp = (BackPropagation)event.getSource();
        if (event.getEventType() != LearningEvent.Type.LEARNING_STOPPED)
            System.out.println(bp.getCurrentIteration() + ". iteration : "+ bp.getTotalNetworkError());
    }
}
Jetzt reden wir wieder vom selben. MeinFehler. Einige Fragen zum Code:

Was hast das Momentum zu bedeuten?
 
Ich möchte mal zu dem anderen NN zurückkommen:

Java:
package suchtytv.complexservice.game.maths.artificialneuralnetwork.multilayerperceptron;

import java.util.ArrayList;
import java.util.Arrays;
import org.neuroph.core.Layer;
import org.neuroph.core.Neuron;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.events.LearningEvent;
import org.neuroph.core.events.LearningEventListener;
import org.neuroph.core.learning.error.MeanSquaredError;
import org.neuroph.core.transfer.Linear;
import org.neuroph.core.transfer.RectifiedLinear;
import org.neuroph.core.transfer.Sigmoid;
import org.neuroph.core.transfer.TransferFunction;
import org.neuroph.nnet.MultiLayerPerceptron;
import org.neuroph.nnet.learning.BackPropagation;
import org.neuroph.nnet.learning.MomentumBackpropagation;
import org.neuroph.util.TransferFunctionType;
import org.neuroph.util.data.norm.MaxMinNormalizer;

import suchtytv.complexservice.game.maths.VectorND;

public class GamePlayingNetwork implements LearningEventListener {
    MultiLayerPerceptron nn;

    public GamePlayingNetwork(int inputNodes, int outPutNodes) {

        nn = new MultiLayerPerceptron(inputNodes, 50, 50, outPutNodes);

        for (Layer l : nn.getLayers()) {
            for (Neuron n : l.getNeurons()) {
                n.setTransferFunction(new RectifiedLinear());
            }
        }
        nn.getLayerAt(3).getNeuronAt(0).setTransferFunction(new Linear());
        nn.getLayerAt(3).getNeuronAt(1).setTransferFunction(new Linear());

        nn.randomizeWeights();
        MomentumBackpropagation bp = new MomentumBackpropagation();
        bp.setMomentum(0.9);
        bp.setLearningRate(0.1);
        bp.setErrorFunction(new MeanSquaredError());
        bp.setMaxError(0.001);
        bp.addListener(this);
        bp.setMaxIterations(200);
        nn.setLearningRule(bp);

    }

    public void train(ArrayList<VectorND> samples) {
        System.out.println("Training with " + samples.size() + " sample(s)... this could take a while ");

        DataSet set = new DataSet(47, 2);
        for (VectorND nd : samples) {
            double[] all = nd.getArray();
            double[] input = Arrays.copyOfRange(all, 0, nd.length() - 2);
            double[] output = Arrays.copyOfRange(all, nd.length() - 2, nd.length());
            set.addRow(input, output);

        }
        set.shuffle();
        nn.learn(set);
        System.out.println("Training Done");
    }

    public MultiLayerPerceptron getNeuralNetwork() {
        return nn;

    }

    public void setInput() {

    }

    public void setInput(double[] array) {
        nn.setInput(array);

    }

    public VectorND getOutput() {
        nn.calculate();

        // TODO Auto-generated method stub
        double[] b = nn.getOutput();
        VectorND nd = new VectorND();
        nd.add(b);
        return nd;
    }

    @Override
    public void handleLearningEvent(LearningEvent event) {
        BackPropagation bp = (BackPropagation)event.getSource();
        if (event.getEventType() != LearningEvent.Type.LEARNING_STOPPED)
            System.out.println(bp.getCurrentIteration() + ". iteration : "+ bp.getTotalNetworkError());
       
    }

}
Dieses Netzwerk zeigt erste Lebenzeichen... Es weicht tatsächlich aus...
 
Java:
package suchtytv.complexservice.game.maths.artificialneuralnetwork.multilayerperceptron;

import java.util.ArrayList;
import java.util.Arrays;
import org.neuroph.core.Layer;
import org.neuroph.core.Neuron;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.events.LearningEvent;
import org.neuroph.core.events.LearningEventListener;
import org.neuroph.core.learning.error.MeanSquaredError;
import org.neuroph.core.transfer.Linear;
import org.neuroph.core.transfer.Log;
import org.neuroph.core.transfer.RectifiedLinear;
import org.neuroph.core.transfer.Sigmoid;
import org.neuroph.core.transfer.TransferFunction;
import org.neuroph.nnet.MultiLayerPerceptron;
import org.neuroph.nnet.learning.BackPropagation;
import org.neuroph.nnet.learning.MomentumBackpropagation;
import org.neuroph.util.TransferFunctionType;
import org.neuroph.util.data.norm.MaxMinNormalizer;

import suchtytv.complexservice.game.maths.VectorND;

public class GamePlayingNetwork implements LearningEventListener {
    MultiLayerPerceptron nn;

    public GamePlayingNetwork(int inputNodes, int outPutNodes) {

        nn = new MultiLayerPerceptron(inputNodes, 50, 50, outPutNodes);

        for (Layer l : nn.getLayers()) {
            for (Neuron n : l.getNeurons()) {
                n.setTransferFunction(new org.neuroph.core.transfer.Sigmoid());
            }
        }
        nn.getLayerAt(3).getNeuronAt(0).setTransferFunction(new Linear());
        nn.getLayerAt(3).getNeuronAt(1).setTransferFunction(new Linear());

        nn.randomizeWeights();
        MomentumBackpropagation bp = new MomentumBackpropagation();
        bp.setMomentum(10);
        bp.setLearningRate(0.01);
        bp.setErrorFunction(new MeanSquaredError());
        bp.setMaxError(0.001);
        bp.addListener(this);
        bp.setMaxIterations(200);
        nn.setLearningRule(bp);

    }

    public void train(ArrayList<VectorND> samples) {
        System.out.println("Training with " + samples.size() + " sample(s)... this could take a while ");

        DataSet set = new DataSet(47, 2);
        for (VectorND nd : samples) {
            double[] all = nd.getArray();
            double[] input = Arrays.copyOfRange(all, 0, nd.length() - 2);
            double[] output = Arrays.copyOfRange(all, nd.length() - 2, nd.length());
            set.addRow(input, output);

        }
        set.shuffle();
        nn.learn(set);
        System.out.println("Training Done");
    }

    public MultiLayerPerceptron getNeuralNetwork() {
        return nn;

    }

    public void setInput() {

    }

    public void setInput(double[] array) {
        nn.setInput(array);

    }

    public VectorND getOutput() {
        nn.calculate();

        // TODO Auto-generated method stub
        double[] b = nn.getOutput();
        VectorND nd = new VectorND();
        nd.add(b);
        return nd;
    }

    @Override
    public void handleLearningEvent(LearningEvent event) {
        BackPropagation bp = (BackPropagation)event.getSource();
        if (event.getEventType() != LearningEvent.Type.LEARNING_STOPPED)
            System.out.println(bp.getCurrentIteration() + ". iteration : "+ bp.getTotalNetworkError());
   
    }

}
Dieses Netzwerk schafft es das Spiel für einige Sekunden lang zu spielen, es ist eine Intension erkennbar. Es bleibt wie ich immer auf der linken Seite des Spielfeldes und versucht häufig nicht über den Spielrand zu kommen. Es versucht meine Kreisbewegung zu imitieren, die ich nutze um schnellen Objekten ausweichen zu können, ohne dabei von null beschleunigen zu müssen. Bei zu vielen Vögeln in der Nähe, verliert es ...

Der Fehler liegt bei lediglich 0.009 . Wie mach ich jetzt das Fein-tuning?
 
Zuletzt bearbeitet:
Güte: https://www.duden.de/rechtschreibung/Guete#Bedeutung2
des: https://www.duden.de/rechtschreibung/des_bestimmter_Artikel_im_Genitiv
Spielens: https://www.duden.de/rechtschreibung/spielen

@Feeder ich meine, Dein NN (Perzeptron) wäre zu groß, es muss ja teils Neuronen mit 2500 Bearbeitung: 50 Eingängen haben....
Bei 47 Eingangsvariablen wären es merkwürdige, wenn es nicht teils 50 Eingänge wären...
 
Hey, ich bin es nochmal:

Es funktioniert leider von der Qualität des Spielens noch nicht wie ich es mir vorgestellt habe, sollte ich noch irgendetwas anderes probieren:

Ich habe bereits versucht:
Mehr Neuronen
Höheres Momentum
Höhere Learningrate

Java:
package suchtytv.complexservice.game.maths.artificialneuralnetwork.multilayerperceptron;

import java.util.ArrayList;
import java.util.Arrays;
import org.neuroph.core.Layer;
import org.neuroph.core.Neuron;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.events.LearningEvent;
import org.neuroph.core.events.LearningEventListener;
import org.neuroph.core.learning.error.MeanSquaredError;
import org.neuroph.core.transfer.Linear;
import org.neuroph.core.transfer.Log;
import org.neuroph.core.transfer.RectifiedLinear;
import org.neuroph.core.transfer.Sigmoid;
import org.neuroph.core.transfer.TransferFunction;
import org.neuroph.nnet.MultiLayerPerceptron;
import org.neuroph.nnet.learning.BackPropagation;
import org.neuroph.nnet.learning.MomentumBackpropagation;
import org.neuroph.util.TransferFunctionType;
import org.neuroph.util.data.norm.MaxMinNormalizer;

import suchtytv.complexservice.game.maths.VectorND;

public class GamePlayingNetwork implements LearningEventListener {
    MultiLayerPerceptron nn;

    public GamePlayingNetwork(int inputNodes, int outPutNodes) {

        nn = new MultiLayerPerceptron(inputNodes, 16,16, outPutNodes);

        for (Layer l : nn.getLayers()) {
            for (Neuron n : l.getNeurons()) {
                n.setTransferFunction(new org.neuroph.core.transfer.Sigmoid());
            }
        }
        nn.getLayerAt(3).getNeuronAt(0).setTransferFunction(new Linear());
        nn.getLayerAt(3).getNeuronAt(1).setTransferFunction(new Linear());

        nn.randomizeWeights();
        MomentumBackpropagation bp = new MomentumBackpropagation();
        bp.setMomentum(5);
        bp.setLearningRate(0.01);


        bp.setErrorFunction(new MeanSquaredError());
        bp.setMaxError(0.001);
        bp.addListener(this);
        bp.setMaxIterations(25);
        nn.setLearningRule(bp);

    }

    public void train(ArrayList<VectorND> samples) {
        System.out.println("Training with " + samples.size() + " sample(s)... this could take a while ");

        DataSet set = new DataSet(47, 2);
        for (VectorND nd : samples) {
            double[] all = nd.getArray();
            double[] input = Arrays.copyOfRange(all, 0, nd.length() - 2);
            double[] output = Arrays.copyOfRange(all, nd.length() - 2, nd.length());
            set.addRow(input, output);

        }
        set.shuffle();
        nn.learn(set);
        System.out.println("Training Done");
    }

    public MultiLayerPerceptron getNeuralNetwork() {
        return nn;

    }

    public void setInput() {

    }

    public void setInput(double[] array) {
        nn.setInput(array);

    }

    public VectorND getOutput() {
        nn.calculate();

        // TODO Auto-generated method stub
        double[] b = nn.getOutput();
        VectorND nd = new VectorND();
        nd.add(b);
        return nd;
    }

    @Override
    public void handleLearningEvent(LearningEvent event) {
        BackPropagation bp = (BackPropagation)event.getSource();
        if (event.getEventType() != LearningEvent.Type.LEARNING_STOPPED)
            System.out.println(bp.getCurrentIteration() + ". iteration : "+ bp.getTotalNetworkError());
  
    }

}
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben