Neuronales Netz

Feeder

Bekanntes Mitglied
Hey,

ich schreibe ein kleines Netz und benutze dafür die Bibliothek Neuroph. Inputdaten sind dabie Dinge wie:

Spielerposition, Gegnerposition, Geschwindigkeit, Größe, aber auch die letzte Eingabe des Spielers...

die Ausgabe soll dann eine "Kraft" mit x,y sein, die dann den Spieler bewegt.
Ich nehme die Inputdaten wie folgt auf:

1. Mensch drückt <r>
2. Aufnahme beginnt und nimmt nun in jedem Spieldurchlauf (Durchlauf der Gameloop) alle Daten auf (speichert sie)
3. Nach ca 1 minute hat man dann ca. 5000 Trainingsdaten (vllt overfittet das Netzwerk?)
Sollte ich dafür die Liste mal etwas mischen, schließlich lernt es immer 20-30 ähnliche Beispiele

Leider konvergiert das folgende Netz nicht. Vorschläge:?


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 suchtytv.complexservice.game.maths.VectorND;

public class GamePlayingNetwork  {
    MultiLayerPerceptron nn;
    public GamePlayingNetwork(int inputNodes, int outPutNodes) {
 

        nn = new MultiLayerPerceptron(inputNodes,50,50,outPutNodes); //create NN  with 48 inputNodes and 2 outputNodes
        for(Layer l : nn.getLayers()) {
            for(Neuron n : l.getNeurons()) {
                n.setTransferFunction(new TransferFunction() { //recalibrate Sigmoid for better use !!! Library never asked about derivative: f' =  2*simoid' !!!
            
                    @Override
                    public double getOutput(double totalInput) {
                        // TODO Auto-generated method stub
                        return 2/(1+Math.exp(-totalInput))-1; //sigmoid between -1 and 1
                    }
            });
                System.out.println(n.getInputConnections().size());
            }
        }
        BackPropagation bp = new BackPropagation();
        bp.setLearningRate(0.5); //In any case points will beconverging to a to big local minima (if they are converging)
        bp.setErrorFunction(new MeanSquaredError()); //should I use a linearity?
        bp.setMaxIterations(100);
        nn.setLearningRule(bp);

    }
 
    public void train(ArrayList<VectorND> samples) { //Train the network
        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, 47);
        double[] output  = Arrays.copyOfRange(all, 47, 49); //VectorND is just a multidimensional Vector including the data
        set.addRow(input, output);
 
 
        }
        //set.shuffle() does not help either
        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() {
        // TODO Auto-generated method stub
        double[] b = nn.getOutput();
        VectorND nd = new VectorND();
        nd.add(b);
        return nd;
    }
 
 

}
 
Zuletzt bearbeitet:
X

Xyz1

Gast
Ok ich habe ein paar Fragen....
Was sind die Inputdaten?
Was sind Beispielinputdaten?
Was ist das Ziel?
Hast du mal per Hand versucht, die Lernrate herunterzuschrauben und / oder die Iterationen zu erhöhen?
Die Mittlere quadratische Abweichung (new MeanSquaredError()) ist schon ok....

Dann noch etwas das ist eigentlich überwachtes Lernen das heißt wenn nicht müsstest du eigentlich die Backpropagation weg lassen. Wie hier zu sehen ist.

Also aus der Hüfte: bp.setLearningRate(0.1); oder bp.setLearningRate(0.01); und bp.setMaxIterations(15000); und der rest SOLLTE vielleicht funktionieren.
 
X

Xyz1

Gast
Undnoch was.... Warum eigentlich so viele Perzeptronen und um welches Spiel geht es eigentlich?
 

Feeder

Bekanntes Mitglied
Hey, meine Inputs (Beispielinputs sind die Trainingsdaten) sind wie folgt strukturiert:

Java:
        //Aufzeichnen des Spiels, wenn gewollt.
        if(Simulation.recordGame) {
            VectorND nd = new VectorND();
            //Adding PlayerPositions
            nd.addElement(player.getPosition().getX()); //add properties of the player
            nd.addElement(player.getPosition().getY());
            nd.addElement(player.getSpeed().getX());//
            nd.addElement(player.getSpeed().getY());//
            nd.addElement(lastforce.getX()); //add the last force which was applied before
            nd.addElement(lastforce.getY());
            //Adding Position of GameObjects (Maximum) and radius
            for(GameObject o : gameList) {
                if(o instanceof Bird) {
                    Bird b = (Bird)o;
                    nd.addElement(b.getPosition().getX()); //add properties of the birds
                    nd.addElement(b.getPosition().getY()); //
                    nd.addElement(b.getRadius());
                    nd.addElement(b.getSpeed().getX());
                    nd.addElement(b.getSpeed().getY());

                }
            }
            //Adding MousePosition
            nd.addElement(1); //add bias if necessary ?!?!
            force.div(2*forcemultiplier); //Turning force to actual force //just translate values for ANN
            nd.addElement(force.getX());   // add the force the ANN shall apply
            nd.addElement(force.getY()); //
            movieMaker.addData(nd);
        }
        lastforce = force.clone();

eine Version des Spiels versuche ich anzuhängen (selbst programmierter Quatsch :))
Ist aber nicht alles kommentiert ;( Du solltest aber selbst kompilieren können

EDIT: Die Datei ist zu groß damit ich sie kompilieren kann

Spielanleitung:

Du bewegst die Kugel mit der Maus.
Du kannst mir <r> eine Trainingaufnahme starten.
Du kannst nachdem du eine Traini ngsaufnahme gestartet hast mit <t> das Netz trainieren
Du kannst mit <p> den Roboter spielen lassen, sobald du das Netz trainiert hatest
Öffne das Spiel mit der Konsole um zusätzliche Infos zu erhalten
Du kannst das Spiel mit Mausklick restarten
 

Anhänge

  • testgameNNApproach.zip
    1 MB · Aufrufe: 6
Zuletzt bearbeitet:

Feeder

Bekanntes Mitglied
JA - das ist einfach ein Survivalgame, überlebe solange wie möglich. Die Anfangsbedingungen sind zufällig. Einzelspiel.

Ich brauchte nur ein einfaches Spiel um das zumachen was ich jetzt mache und da ich momentan eine BeLL schreibe kann ich da nichts zu sehr viel "nicht mathematik" implementieren

Kompiliert habe ich ja - aber wenn du kompilierst ist die Datei nicht zu groß ... srry...
Ich hab deine Tipps eingebaut - haben nicht geklappt ;(

Trotzdem erst mal danke für die Mühe :)
 

Feeder

Bekanntes Mitglied
Also:

Mit 0.01 und 15000 hatte ich es bereits probiert und das Training endet nach 3s ohne Erfolg.
Mit 0.1 rechnet er und rechnet und rechnet und rechnet und rechnet und rechnet nur um dann genau das selbe zumachen wie das 0.01 ... Nichts sinnvolles (einfach in eine richtung wegfliegen)

EDIT: Bei dem Netzwerk (49,50,2) rechnet er nochmal viel länger (noch nicht fertig) als bei dem Netzwerk (49,20,20,2)

Danke für deine Antwort :)

Gruß Niclas
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Auskennen ist da "leicht" übertrieben... und es ist auch ein paar Jährchen her, dass ich mich damit beschäftigt habe. Das Bias-Neuron ist einfach ein zusätzliches Neuron je Layer mit dem konstanten Wert 1. Den genauen Sinn müsste ich jetzt erst nachsehen, sofern ich mich entsinne, hatte das irgendeinen mathematischen Hintergrund. Ich habe mir nur gemerkt, dass man die Daten normalisieren und Bias-Neuronen verwenden soll :)

EDIT: hier wird es z. B. beschrieben: https://stackoverflow.com/questions/2480650/role-of-bias-in-neural-networks
 
Zuletzt bearbeitet:

mihe7

Top Contributor
Ja, im Link zu Stackoverflow (s. oben) ist das ganze noch im Zusammenhang mit der Aktivierungsfunktion dargestellt und ein paar schöne Beispiele sind auch dabei :)
 
X

Xyz1

Gast
Wieso kommt da als nächster Videovorschlag "Bares für Rares" bei Youtube? :rolleyes:
Also nochmal kurz zusammenfassen (ich lerne auch besser mit temporell-volativen Skizzen), ein Bias-Neutron ist ein Neutron mit zusätzlichem 1-Eingang.
Zusammen mit der Aktivierungsfunktion, den Funktionssummen und den Lernregel(n) gibt es dann das komplette Neutron.
Und wie sich das auf ein MLP NN auswirkt, weiß keiner....
 

mihe7

Top Contributor
Wieso kommt da als nächster Videovorschlag "Bares für Rares" bei Youtube
Ist das nicht abhängig von den eigenen Vorlieben? :p
ein Bias-Neutron ist ein Neutron mit zusätzlichem 1-Eingang.
So könnte man das sagen, würde ich meinen (btw: Neutronen sind was anderes :))

Zusammen mit der Aktivierungsfunktion, den Funktionssummen und den Lernregel(n) gibt es dann das komplette Neutron.
Die Lernregeln würde ich weglassen. Das Lernen betrifft ja meist auch kein einzelnes Neuron sondern optimiert ja die Gewichtungen über mehrere Neuronen.

Und wie sich das auf ein MLP NN auswirkt, weiß keiner....
Ach, irgendjemanden wird es schon geben :)
 

Feeder

Bekanntes Mitglied
Hallo,

selbstverständlich habe ich Bias Neuronen verwendet :) Und da ich mir zwischenzeitlich auch nicht sicher war, habe ich ein Bias Neuron direkt am Anfang eingefügt :)
Ja tatsächlich sind die Daten für 2 * sigmoid -1 angepasst.

Ich wundere mich aber, woher das Programm weiß, wie es im Fall von 2*sigmoid-1 backpropagieren soll (meine AF), da er doch die Ableitung f'(x) = 2sigmoid'(x) nicht kennt
 
Zuletzt bearbeitet:

Feeder

Bekanntes Mitglied
Meine Fresse sowas regt mich schon wieder auf - wie kann man denn in der abstrakten Klasse die Ableitungsfunktion definieren... Ich habe das jetzt erstmal angepasst:
Java:
package suchtytv.complexservice.game.maths.artificialneuralnetwork.multilayerperceptron;

import org.neuroph.core.transfer.Sigmoid;
import org.neuroph.core.transfer.TransferFunction;

public class BetterSigmoid extends TransferFunction   {

    Sigmoid sig = new Sigmoid();
    @Override
    public double getOutput(double totalInput) {
        // TODO Auto-generated method stub
        return 2/(1+Math.exp(-totalInput))-1; //sigmoid between -1 and 1
        }
    //Warum juckt den mein @Override nicht?
    public double getDerivative(double net) {
        return 2*sig.getDerivative(net);
    
    }

}

Leider klappts immer noch net :(
 
Zuletzt bearbeitet:

Feeder

Bekanntes Mitglied
Hey, ich habe den Code nochmal abgeändert:

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

import org.neuroph.core.transfer.Sigmoid;
import org.neuroph.core.transfer.TransferFunction;

public class BetterSigmoid extends TransferFunction   {

    Sigmoid sig = new Sigmoid();
    @Override
    public double getOutput(double totalInput) {
        // TODO Auto-generated method stub
        return 2/(1+Math.exp(-totalInput))-1; //sigmoid between -1 and 1
        }

    public double getDerivative(double net) {
        return 2*sig.getOutput(net)*(1-sig.getOutput(net));
       
    }

}

Er rechnet jetzt aber schon seit über einer 3/4 Stunde, kann das sein?
 

mihe7

Top Contributor
Rechnet er noch? Das Zeug dauert teilweise ewig.
Ansonsten:
1. neuroph hat doch Tutorials, probiere doch die mal aus (umgesetzt in Java-Code). Da sollten sich die Ergebnisse doch vergleichen lassen.
2. Standard-Sigmoid verwenden
3. Neuronen reduzieren
4. Daten reduzieren (nur wegen Zeit)

Es gibt auch noch die Möglichkeit, Daten zu "komprimieren" (Hauptkomponentanalyse), das wäre aber nur das letzte Mittel, weil hier natürlich Informationen verloren gehen.
 

Feeder

Bekanntes Mitglied
Rechnet er noch? Das Zeug dauert teilweise ewig.
Ansonsten:
1. neuroph hat doch Tutorials, probiere doch die mal aus (umgesetzt in Java-Code). Da sollten sich die Ergebnisse doch vergleichen lassen.
2. Standard-Sigmoid verwenden
3. Neuronen reduzieren
4. Daten reduzieren (nur wegen Zeit)

Es gibt auch noch die Möglichkeit, Daten zu "komprimieren" (Hauptkomponentanalyse), das wäre aber nur das letzte Mittel, weil hier natürlich Informationen verloren gehen.

An tutorials habe ich nichts verwertbares gefunden. Nein er hat nicht mehr gerechnet, sondern irgendwann ohne brauchbares aufgehört. Standard-Sigmoid müsste ich erst umstellen.... Ich propier es mal mit weniger Neuronen.
 

Feeder

Bekanntes Mitglied
Weniger Neuronen oder mehr Layer funktionieren auch nicht :( Ich verzweifle ...
Daten reduzieren bringt nicht. Das Spiel ist viel zu einfach für eine Hauptkomponentenanalyse...

Edit: Vllt kann die Fehlerfunktion nicht stimmen, da sie bei negativen Werten immernoch positiv ist, was die Gewichte bei negativen Werten in die falsche Richtung (also zu lokalen Maxima) konvergieren ließe.
 
Zuletzt bearbeitet:

Feeder

Bekanntes Mitglied
Ich raffs nicht, ich glaube langsam das es nicht an mir liegt, selbst so ein Netz funktioniert einfach nicht:

Java:
import java.util.ArrayList;

import java.util.Random;

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.nnet.MultiLayerPerceptron;
import org.neuroph.nnet.learning.BackPropagation;

import suchtytv.complexservice.game.maths.VectorND;
import suchtytv.complexservice.game.maths.artificialneuralnetwork.multilayerperceptron.BetterSigmoid;

public class Network  {
    MultiLayerPerceptron nn;
    public Network(int inputNodes, int outPutNodes) {
     

        nn = new MultiLayerPerceptron(inputNodes,5,5,outPutNodes);
        for(Layer l : nn.getLayers()) {
            for(Neuron n : l.getNeurons()) {
                n.setTransferFunction(new BetterSigmoid()); //Werte zwischen 0 und 2
            }
        }
        BackPropagation bp = new BackPropagation();
        bp.setLearningRate(0.1);
        bp.setErrorFunction(new MeanSquaredError());
        bp.setMaxError(0.1);
        nn.setLearningRule(bp);

    }
 
    public void train(ArrayList<VectorND> samples) {

        DataSet set = new DataSet(5, 1);
        for(int i = 0; i < 100; ++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}; // Werte könne maximal 2 sein , da double zwischen 0 und 1
        set.addRow(input, output);
     
     
        }
        set.shuffle();
        nn.learn(set);
        nn.setInput(new double[]{1,0.5,0.7,1,0.5}); //print 0.25+0.7+0.25 = 1.2
        System.out.println(nn.getOutput()[0]);
        System.out.println("Training Done");
    }

    public VectorND getOutput() {
        // TODO Auto-generated method stub
        double[] b = nn.getOutput();
        VectorND nd = new VectorND();
        nd.add(b);
        return nd;
    }
    public static void main(String args[]) {
        Network nn = new Network(5, 1);
        nn.train(null);
    }
 

}
 

mihe7

Top Contributor
Probier mal statt
Code:
        nn = new MultiLayerPerceptron(inputNodes,5,5,outPutNodes);
        for(Layer l : nn.getLayers()) {
            for(Neuron n : l.getNeurons()) {
                n.setTransferFunction(new BetterSigmoid()); //Werte zwischen 0 und 2
            }
        }
        BackPropagation bp = new BackPropagation();
        bp.setLearningRate(0.1);
        bp.setErrorFunction(new MeanSquaredError());
        bp.setMaxError(0.1);
        nn.setLearningRule(bp);

einfach nur

Code:
        nn = new MultiLayerPerceptron(TransferFunctionType.SIGMOID, inputNodes,5,5,outPutNodes);
 

Feeder

Bekanntes Mitglied
Probier mal statt
Code:
        nn = new MultiLayerPerceptron(inputNodes,5,5,outPutNodes);
        for(Layer l : nn.getLayers()) {
            for(Neuron n : l.getNeurons()) {
                n.setTransferFunction(new BetterSigmoid()); //Werte zwischen 0 und 2
            }
        }
        BackPropagation bp = new BackPropagation();
        bp.setLearningRate(0.1);
        bp.setErrorFunction(new MeanSquaredError());
        bp.setMaxError(0.1);
        nn.setLearningRule(bp);

einfach nur

Code:
        nn = new MultiLayerPerceptron(TransferFunctionType.SIGMOID, inputNodes,5,5,outPutNodes);

Funktioniert leider auch nicht :(
 

mihe7

Top Contributor
So, habe quick & dirty mal was zusammengeschustert:
Java:
import org.neuroph.core.data.*;
import org.neuroph.nnet.*;
import org.neuroph.util.TransferFunctionType;

public class Test {
  
    public static void main(String[] args) {
        MultiLayerPerceptron p = new MultiLayerPerceptron(TransferFunctionType.SIGMOID, 3,3,1);
        DataSet trainingSet = new DataSet(3,1);

        double[][] in = new double[][]{
            new double[]{1,0,0},
            new double[]{1,1,1},
            new double[]{1,0,1},
            new double[]{1,1,0}
        };
        double[][] exp = new double[][]{
            new double[]{0},
            new double[]{0},
            new double[]{1},
            new double[]{1},
        };

        for (int i = 0; i < in.length; i++) {
            trainingSet.addRow(new DataSetRow(in[i], exp[i]));
        }

        p.learn(trainingSet);

        for (int i = 0; i < in.length; i++) {
            p.setInput(in[i]);
            p.calculate();
            double[] out = p.getOutput();
            System.out.println(in[i][0] + " " + in[i][1] + " " + in[i][2] + ": " + out[0]);
        }   
    }
}

Funktioniert.
 

mihe7

Top Contributor
Noch besser (aus den Samples):
Java:
/**
 * Copyright 2010 Neuroph Project http://neuroph.sourceforge.net
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *    http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.neuroph.samples;

import java.util.Arrays;
import java.util.Random;
import org.neuroph.core.NeuralNetwork;
import org.neuroph.core.events.LearningEvent;
import org.neuroph.core.events.LearningEventListener;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.data.DataSetRow;
import org.neuroph.core.learning.LearningRule;
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.random.WeightsRandomizer;

/**
 * This sample shows how to create, train, save and load simple Multi Layer Perceptron for the XOR problem.
 * This sample shows basics of Neuroph API.
 * @author Zoran Sevarac <sevarac@gmail.com>
 */
public class XorMultiLayerPerceptronSample implements LearningEventListener {
    public static void main(String[] args) {
        new XorMultiLayerPerceptronSample().run();
    }

    /**
     * Runs this sample
     */
    public void run() {

        // create training set (logical XOR function)
        DataSet trainingSet = new DataSet(2, 1);
        trainingSet.addRow(new DataSetRow(new double[]{0, 0}, new double[]{0}));
        trainingSet.addRow(new DataSetRow(new double[]{0, 1}, new double[]{1}));
        trainingSet.addRow(new DataSetRow(new double[]{1, 0}, new double[]{1}));
        trainingSet.addRow(new DataSetRow(new double[]{1, 1}, new double[]{0}));

        // create multi layer perceptron
        MultiLayerPerceptron myMlPerceptron = new MultiLayerPerceptron(TransferFunctionType.SIGMOID, 2, 3, 1);
        myMlPerceptron.randomizeWeights(new WeightsRandomizer(new Random(123)));

        System.out.println(Arrays.toString(myMlPerceptron.getWeights()));

        myMlPerceptron.setLearningRule(new BackPropagation());

        myMlPerceptron.getLearningRule().setLearningRate(0.5);
        // enable batch if using MomentumBackpropagation
//        if( myMlPerceptron.getLearningRule() instanceof MomentumBackpropagation )
//              ((MomentumBackpropagation)myMlPerceptron.getLearningRule()).setBatchMode(false);

        LearningRule learningRule = myMlPerceptron.getLearningRule();
        learningRule.addListener(this);

        // learn the training set
        System.out.println("Training neural network...");
        myMlPerceptron.learn(trainingSet);

        // test perceptron
        System.out.println("Testing trained neural network");
        testNeuralNetwork(myMlPerceptron, trainingSet);

        // save trained neural network
        myMlPerceptron.save("myMlPerceptron.nnet");

        // load saved neural network
        NeuralNetwork loadedMlPerceptron = NeuralNetwork.createFromFile("myMlPerceptron.nnet");

        // test loaded neural network
        System.out.println("Testing loaded neural network");
        testNeuralNetwork(loadedMlPerceptron, trainingSet);
    }

    /**
     * Prints network output for the each element from the specified training set.
     * @param neuralNet neural network
     * @param testSet test set
     */
    public static void testNeuralNetwork(NeuralNetwork neuralNet, DataSet testSet) {

        for(DataSetRow testSetRow : testSet.getRows()) {
            neuralNet.setInput(testSetRow.getInput());
            neuralNet.calculate();
            double[] networkOutput = neuralNet.getOutput();

            System.out.print("Input: " + Arrays.toString( testSetRow.getInput() ) );
            System.out.println(" Output: " + Arrays.toString( networkOutput) );
        }
    }

    @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());
    }

}
 
X

Xyz1

Gast
allmählich reizt es mich es mal auszuprobieren... mal sehen.
mich auch ....

eine Version des Spiels versuche ich anzuhängen (selbst programmierter Quatsch :))
Ist aber nicht alles kommentiert ;( Du solltest aber selbst kompilieren können
Wir werden wohl gezwungen sein müssen es zu kompilieren im laufe des Tages :p

Einfach mal ein nn.calculate(); nach nn.setInput(...)
Dir ist doch nicht langweilig :p Wie viele AI Vorlesungen hast du schon gehört? 0, 1, 2,...?
Sie können furchtbar langweilig sein aber auch so das man etwas versteht :D
 

mrBrown

Super-Moderator
Mitarbeiter
Es funktioniert immer noch nicht - mihe7s Versuch werde ich morgen ausprobieren :)
Dein Beispiel (nicht das Original, das mit den 5 Werten), funktionier mit calculate halbwegs. Besser wirds wenn man maxError verringert und Anzahl der Trainingsdaten erhöht.
Größere Fehler gibts dann nur, wenn der erwartetet Wert > 1 ist, keine Ahnung ob man das vorher auf [0,1] normieren muss, wird sicher irgendwo in der Doku stehen...


Dir ist doch nicht langweilig :p Wie viele AI Vorlesungen hast du schon gehört? 0, 1, 2,...?
Sie können furchtbar langweilig sein aber auch so das man etwas versteht :D
Vermutlich mehr als du...
 

Feeder

Bekanntes Mitglied
Soll ich eine kommentierte Version der wesentlichen Stellen im Game zur Verfügung stellen?
Ansonsten versteht man in der Simulation.java nichts...
 

Ähnliche Java Themen

Neue Themen


Oben