Neuronales Netz

Feeder

Bekanntes Mitglied
Hier nochmal der Quellcode:

In der Simulation wird das Spiel berechnet,
im GamePlayingNetwork (das ist relativ selbst erklärend) die AI gebaut

mehr ist wohl nicht von nöten :)
 

Anhänge

  • testgameNNApproach 2.zip
    1 MB · Aufrufe: 1
X

Xyz1

Gast
Wie viele hast du denn besucht (inklusive körperlicher und geistiger Anwesenheit)?
Datenschutz. :p

Noch besser (aus den Samples):
Mihe, ich habe einfach mal Deines kopiert und etwas angepasst....
Auch mit einem Sigmoid kann ein MLP in unter 1000 Iterationen zum Beispiel das add von 2 ints lernen....

Java:
import java.util.Arrays;
import java.util.Random;
import org.neuroph.core.data.DataSet;
import org.neuroph.core.events.LearningEvent;
import org.neuroph.core.learning.LearningRule;
import org.neuroph.nnet.MultiLayerPerceptron;
import org.neuroph.nnet.learning.BackPropagation;
import org.neuroph.util.TransferFunctionType;

/**
 */
public class NeuroTest {

public static void main(String[] args) {
    System.out.println("create training set");
    Random ra = new Random(123);
    DataSet trset = new DataSet(6, 4);
    for (int i = 0; i < 100; i++) {
        int j1 = ra.nextInt(8), j2 = ra.nextInt(8), j3 = j1 + j2;
        double[] ds1 = intToDouble(j1, new double[3]);
        double[] ds2 = intToDouble(j2, new double[3]);
        double[] ds3 = intToDouble(j3, new double[4]);
        trset.addRow(
                new double[]{
                    ds1[0], ds1[1], ds1[2],
                    ds2[0], ds2[1], ds2[2],},
                ds3);
        System.out.println(j1 + " " + j2 + " " + j3 + " " + trset.getRowAt(i).toCSV());
    }

    System.out.println("create neural network...");
    MultiLayerPerceptron nn = new MultiLayerPerceptron(TransferFunctionType.SIGMOID, 6, 12, 4);

    System.out.println("randomize neural network's weights...");
    nn.randomizeWeights(ra);
    System.out.println(Arrays.toString(nn.getWeights()));

    System.out.println("set learning rule...");
    nn.setLearningRule(new BackPropagation());
    nn.getLearningRule().setLearningRate(0.1);
    nn.getLearningRule().setMaxIterations(5000);

    LearningRule learningRule = nn.getLearningRule();
    learningRule.addListener((LearningEvent event) -> {
        BackPropagation bp = (BackPropagation) event.getSource();
        System.out.println(
                bp.getCurrentIteration() /*+ " "
                + Arrays.toString(bp.getNeuralNetwork().getWeights())*/);
    });

    System.out.println("Training neural network...");
    nn.learn(trset);

    System.out.println("Testing trained neural network");
    for (int i = 0; i < 5; i++) {
        int j1 = ra.nextInt(8), j2 = ra.nextInt(8), j3 = j1 + j2;
        double[] ds1 = intToDouble(j1, new double[3]);
        double[] ds2 = intToDouble(j2, new double[3]);
        double[] ds3 = intToDouble(j3, new double[4]);
        double[] dsi = {
            ds1[0], ds1[1], ds1[2],
            ds2[0], ds2[1], ds2[2],};
        double[] dso = ds3;
        nn.setInput(dsi);
        nn.calculate();
        double[] dso2 = nn.getOutput();
        int j4 = doubleToInt(dso2);
        System.out.println(
                j1 + " " + j2 + " " + j3 + " "
                + Arrays.toString(dsi) + " "
                + Arrays.toString(dso) + " "
                + Arrays.toString(dso2) + " " + j4);
    }
}

static double[] intToDouble(int i, double[] ds) {
    String s = Integer.toBinaryString(i);
    for (int j = 0; j < s.length(); j++) {
        ds[j] = s.charAt(s.length() - j - 1) - '0';
    }
    return ds;
}

static int doubleToInt(double[] ds) {
    int r = 0;
    for (int j = 0; j < ds.length; j++) {
        r |= ((int) Math.round(ds[j])) << j;
    }
    return r;
}

}

Code:
create training set
5 1 6 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0
7 2 9 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0
2 4 6 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0
4 2 6 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0
6 4 10 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
7 4 11 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0
5 1 6 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0
0 5 5 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0
6 2 8 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0
4 1 5 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0
7 4 11 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0
1 1 2 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0
7 3 10 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0
0 0 0 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
0 0 0 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
0 2 2 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0
3 7 10 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0
6 5 11 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0
4 0 4 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0
3 3 6 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0
2 7 9 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0
1 6 7 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0
2 6 8 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0
3 0 3 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0
3 1 4 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0
1 3 4 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0
4 1 5 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0
0 3 3 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0
5 0 5 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0
5 6 11 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0
0 1 1 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0
7 3 10 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0
3 7 10 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0
5 3 8 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0
5 6 11 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0
5 5 10 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
4 0 4 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0
3 6 9 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0
1 3 4 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0
0 1 1 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0
0 4 4 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0
6 3 9 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0
5 6 11 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0
7 6 13 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0
6 2 8 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0
4 6 10 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0
4 4 8 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0
1 2 3 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0
2 1 3 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0
5 5 10 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
3 3 6 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0
7 3 10 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0
5 1 6 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0
2 2 4 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0
7 2 9 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0
3 2 5 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0
1 1 2 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0
5 3 8 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0
1 7 8 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0
0 6 6 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0
4 4 8 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0
4 5 9 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0
1 2 3 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0
4 6 10 0.0, 0.0, 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0
2 5 7 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0
2 6 8 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0
3 1 4 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0
1 1 2 1.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0
6 2 8 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0
2 1 3 0.0, 1.0, 0.0, 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0
3 0 3 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0
5 6 11 1.0, 0.0, 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0
0 4 4 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 1.0, 0.0
1 3 4 1.0, 0.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 0.0
7 0 7 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0
7 3 10 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0
6 1 7 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0
6 7 13 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0
0 0 0 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0
3 7 10 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0
1 0 1 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0
7 7 14 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0
4 7 11 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0, 0.0, 1.0
5 5 10 1.0, 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
0 6 6 0.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0
3 4 7 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0
1 7 8 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0
4 3 7 0.0, 0.0, 1.0, 1.0, 1.0, 0.0, 1.0, 1.0, 1.0, 0.0
6 4 10 0.0, 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0
0 3 3 0.0, 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0
5 3 8 1.0, 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0
7 1 8 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0
3 2 5 1.0, 1.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0, 1.0, 0.0
3 1 4 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0
4 5 9 0.0, 0.0, 1.0, 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 1.0
6 2 8 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0
6 1 7 0.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0, 1.0, 0.0
5 7 12 1.0, 0.0, 1.0, 1.0, 1.0, 1.0, 0.0, 0.0, 1.0, 1.0
6 2 8 0.0, 1.0, 1.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0
5 1 6 1.0, 0.0, 1.0, 1.0, 0.0, 0.0, 0.0, 1.0, 1.0, 0.0
create neural network...
randomize neural network's weights...
[0.647357215491136, 0.2833653573340025, 0.005186258410748934, 0.16071957622616795, 0.780309732765597, 0.7916784518594653, 0.3117819715124699, 0.02372128403098228, 0.5326884083087974, 0.36353401318531553, 0.3090342672889538, 0.20705779115056422, 0.15811812466802477, 0.3657232277640391, 0.01987654069995526, 0.2290447427367961, 0.14734378462417386, 0.3379430273493287, 0.3058032092686285, 0.08986786180559903, 0.4386703976376072, 0.2530810140170595, 0.4640270585612969, 0.13352451959402267, 0.4295248350895613, 0.766862374848878, 0.47373501995925704, 0.7569913113067654, 0.8456883679089797, 0.16013595159641492, 0.1262142127937652, 0.6332743310673092, 0.10775700279466349, 0.39289775562122153, 0.9347523077653593, 0.03394392388012901, 0.8236439887106316, 0.061219786676922405, 0.287600308100715, 0.9119509109778238, 0.4314473127762968, 0.07657290158990859, 0.780917184062471, 0.6369668764890946, 0.81876239832529, 0.571602524934773, 0.048499993353021575, 0.6631861738505911, 0.9525280776859375, 0.8772363457800377, 0.69123457180554, 0.9534726942627975, 0.16775194011929062, 0.4130733703648567, 0.10158617346993115, 0.683929913239893, 0.78396856157569, 0.9863243067977903, 0.07708076532512831, 0.6094176094725173, 0.1450425317246743, 0.30414317166082083, 0.12161176142807084, 0.4832345570371346, 0.010935340099124335, 0.47001064536583137, 0.24453886715828366, 0.09313137108600067, 0.46931354076562126, 0.8568998711539078, 0.8849290024162565, 0.8010129839502235, 0.180383052823047, 0.028275494081400843, 0.31192216524211536, 0.9551359430850607, 0.8200925219612185, 0.3125478738866171, 0.4820872714140031, 0.18130066238854037, 0.044856382804202344, 0.22742330102185093, 0.8707667708431337, 0.3534840566199541, 0.16520593574327203, 0.19766289887246657, 0.23679075583641251, 0.9945536151314497, 0.986284892071741, 0.9130820597278025, 0.6285746923090954, 0.9641490765376436, 0.9498632255728994, 0.2331931928649943, 0.1944973492064338, 0.5535130612324953, 0.7955515854223575, 0.7607146524531969, 0.5215886873681563, 0.52599755713938, 0.44815542624867843, 0.07823889965527187, 0.293939787517563, 0.21716842480174436, 0.733616898224158, 0.1706736992328015, 0.03588016591962406, 0.539875284603039, 0.8277494941255742, 0.7406401001426257, 0.5848504809078479, 0.627349569569006, 0.04997879437164565, 0.9648310259209602, 0.7250312103696261, 0.8913386056087402, 0.7285598966158668, 0.7364056067704764, 0.1051711542646484, 0.47247967319890505, 0.3842508861547216, 0.5918132108073756, 0.1626920823135357, 0.41656181725144326, 0.40617825701053334, 0.33001304992373603, 0.2810286227211517, 0.4230202484610498, 0.726639210030025, 0.7978741814026805, 0.8182956476969212, 0.6809521868110479, 0.7408426888498517, 0.43761188539425855, 0.9627579423239608, 0.13313888331066603]
set learning rule...
Training neural network...
1
....
933
Testing trained neural network
6 1 7 [0.0, 1.0, 1.0, 1.0, 0.0, 0.0] [1.0, 1.0, 1.0, 0.0] [0.9984149175208366, 0.9541509265284592, 0.9136515702001319, 0.029320530721152756] 7
7 4 11 [1.0, 1.0, 1.0, 0.0, 0.0, 1.0] [1.0, 1.0, 0.0, 1.0] [0.9970404893926246, 0.9996918910742172, 0.14573473999840167, 0.9838278417863412] 11
4 4 8 [0.0, 0.0, 1.0, 0.0, 0.0, 1.0] [0.0, 0.0, 0.0, 1.0] [0.06089073314012169, 0.030412914393122492, 0.022566630597148047, 0.9506610240186283] 8
3 3 6 [1.0, 1.0, 0.0, 1.0, 1.0, 0.0] [0.0, 1.0, 1.0, 0.0] [0.008202698117266503, 0.8748929075298061, 0.9810740327187619, 0.016224749669329543] 6
5 7 12 [1.0, 0.0, 1.0, 1.0, 1.0, 1.0] [0.0, 0.0, 1.0, 1.0] [0.03636031649520549, 0.3135859376072287, 0.7443468508986525, 0.9999670793296899] 12

@Feeder Das MLP sollte nicht zu groß sein, es sollte viele Trainigssets geben, die Lernrate sollte klein sein und die maximalen Iterationen nicht viel weniger als nötig - und das MLP sollte wenigstens "etwas sinnvoll" aufgebaut sein.
 
X

Xyz1

Gast
Doch jetzt weiß ich es wieder....
Aber eine lin. Regressionsgerade stellt doch auch ne einfache Klassifikation dar?
 

Feeder

Bekanntes Mitglied
Aber meine Zielfunktion (die die mein Gehirn besitzt) ist ja eben nicht linear. Ich verstehe den Sinn hinter XOR nicht. Klassifikation ist wahr oder eben nicht wahr... oder für MlPs

Giraffe, Affe, Hund...
 

mihe7

Top Contributor
Bei Regression bekommt man einen Wert heraus, z. B. Stückzahlen, bei Klassifikation geht es nur darum, ob etwas "dazu gehört" oder nicht.

Ich verstehe den Sinn hinter XOR nicht. Klassifikation ist wahr oder eben nicht wahr...
Nehmen wir mal Giraffe, Affe, Hund: Output-Neuron 1, 2 oder 3 aktiviert (bzw. welches hat den Größten :)) . Beim XOR ist es nicht anders: Output-Neuron 1 oder 2.
 
X

Xyz1

Gast
bei Klassifikation geht es nur darum, ob etwas "dazu gehört" oder nicht.
Aber durch Regressionsgerade geteilte Punkte können dadurch auch klassifiziert werden indem sie auf der einen oder anderen Seite liegen.
Gilt somit: Regression > Klassifikation?

Aber was tut das jetzt alles zum Thema bei.... ?
 

Feeder

Bekanntes Mitglied
Sorry, das mit der "berechtigten Frage" bezog ich stillschweigend auf das Thema Regression/Klassifikation.


Kann Dir nix versprechen, aber evtl. schaffe ich es noch, mal Deinen Code auszuprobieren. Sonst könnte es nächste Woche werden - allerdings: @DerWissende wollte ja auch :)
Ich bin euch allen mega dankbar ^^ Man bekommt als Schüler nur wenig rat - weil die Lehrer auch nicht raffen, was man da macht...
 

mihe7

Top Contributor
Das ist auch keine Aufgabe für den Lehrer in der Schule. Der Lehrer hat die Aufgabe, die Vorgaben aus dem Lehrplan didaktisch so aufzubereiten, dass die Schüler es verstehen. Der Lehrplan bewegt sich fachlich auf einem ganz anderen Niveau. Es gibt natürlich Lehrer, die sich zu ihrem eigenen Vergnügen mit z. B. Softwareentwicklung tiefer beschäftigen. Das darfst Du aber nicht voraussetzen.
 

Feeder

Bekanntes Mitglied
Das ist auch keine Aufgabe für den Lehrer in der Schule. Der Lehrer hat die Aufgabe, die Vorgaben aus dem Lehrplan didaktisch so aufzubereiten, dass die Schüler es verstehen. Der Lehrplan bewegt sich fachlich auf einem ganz anderen Niveau. Es gibt natürlich Lehrer, die sich zu ihrem eigenen Vergnügen mit z. B. Softwareentwicklung tiefer beschäftigen. Das darfst Du aber nicht voraussetzen.
Tue ich nicht natürlich nicht, aber es ist halt dennoch nicht immer einfach - wenn man sich mit Informatik hobbymäßig beschäftigt und viele Dinge vor hat, aber viele aufgrund des Wissenstandes einfach nicht umsetzen konnte...
Das ist - wie soll man sagen - frustriend. Um so dankbarer bin ich meiner Infolehrerin, die schon ach wie viele Konsultationen mit mir hatte ...
 
X

Xyz1

Gast
Bist Du auf einem Einstein-Gymnasium dass ihr NN behandelt? ;) ;) (Sorry, ich konnte nicht nachgeben....)
So es ist 0 Uhr durch und ich schlafe. :D
 

Feeder

Bekanntes Mitglied
Bist Du auf einem Einstein-Gymnasium dass ihr NN behandelt? ;) ;) (Sorry, ich konnte nicht nachgeben....)
So es ist 0 Uhr durch und ich schlafe. :D
Wir behandeln rein gar nichts in der Schule - ich durfte nicht mal Informatik als Grundkurs wählen (nicht genug Lehrer) ...
Ich habe mir all meine Programmierskills (wenn man das als Skills bezeichnen kann) in den letzten 4 Jahren aufgebaut mit einem Buch(Java), Internet, Kopfschmerzen, Ausratsern und gelegentlichen Extasen wenn es dann endlich klappt
Und ich fürchte, es werden noch viele schmerzhafte Momente folgen...

Informatiker sind allesamt fetischisten wer sich sowas freiwillig antut... (wie ich)
 
X

Xyz1

Gast
(nicht genug Lehrer)
Das ist ja auch nicht gerade wenig was da drankommt:
javascript:(function(){window.location.href="[URL]https://www.schulentwicklung.nrw.de/lehrplaene/lehrplannavigator-s-ii/gymnasiale-oberstufe/informatik/hinweise-und-beispiele/schulinterner-lehrplan/schulinterner-lehrplan.html[/URL]";window.onload=toggle("a211Q1GK");})();

Bereits in Q1gk unter Anderem Strukturierung, Algorithmen und Informatiksysteme....

Allerdings NN ist ein so weit fortgeschrittenes Thema das es nicht mit in den Lehrplan aufgenommen werden sollte :(
 

Feeder

Bekanntes Mitglied
Habe ich ja gemacht, indem ich meine Sigmoidfunktion angepasst habe.
f(net) = 2*sigmoid(net) - 1
f'(net) = 2 * sigmoid'(net)
 

mrBrown

Super-Moderator
Mitarbeiter
Die Werte solltest du trotzdem normalisieren, kannst das DataSet direkt mit zB MaxMinNormalizer normalisieren.
 

mihe7

Top Contributor
@Feeder: sorry, ich verwende immer die Standardfunktionen. Abgesehen davon liefert Sigmoid Werte zwischen 0 und 1, d. h. 2*wertZwischen0und1-1 liefert Werte zwischen -1 und 1.

Das Problem ist einfach, dass die erwartete Ausgabe z. B. 1.2 sein kann - das wird weder mit dem Standard-Sigmoid (0-1) noch mit Deinem (-1 bis +1) erreicht.
 

Feeder

Bekanntes Mitglied
@Feeder: sorry, ich verwende immer die Standardfunktionen. Abgesehen davon liefert Sigmoid Werte zwischen 0 und 1, d. h. 2*wertZwischen0und1-1 liefert Werte zwischen -1 und 1.

Das Problem ist einfach, dass die erwartete Ausgabe z. B. 1.2 sein kann - das wird weder mit dem Standard-Sigmoid (0-1) noch mit Deinem (-1 bis +1) erreicht.

Aber ich habe doch meine Werte extra zwischen -1 und 1 normalisiert. Die Kraft kann nicht höher als 1 und nicht niedriger als -1 sein.

Wie denormalisere ich den im Fall des MaxMinNormalizers
 
X

Xyz1

Gast
Das wäre mein Lehrplan:
Sowas ist immer sau komisch :D :
Schüler, Lehrer
Die Bezeichnungen Schüler und Lehrer werden im Lehrplan allgemein für Schülerinnen und Schüler bzw. Lehrerinnen und Lehrer gebraucht.


wenn es nicht genug Lehrer gibt
Das ist ein Problem dann kann der Lehrplan noch so gut sein. Es ist ganz einfach, wenn kein Personal: dann kann es nicht angeboten werden.... Zum Leidwesen der Schüler welche Kompetenzen entwickeln möchten....
Ich kann Dich verstehen

das DataSet direkt mit zB MaxMinNormalizer normalisieren
probier das mal bitte....
 

Feeder

Bekanntes Mitglied
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...
 

mihe7

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

Feeder

Bekanntes Mitglied
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?
 

Feeder

Bekanntes Mitglied
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...
 

Feeder

Bekanntes Mitglied
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:

mrBrown

Super-Moderator
Mitarbeiter
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...
 
X

Xyz1

Gast
Was hat der Duden denn mit Informatik zu tun :(
Brauchst nicht gleich patzig werden
und es heißt des Spiels....
 

Feeder

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

}
 

Ähnliche Java Themen


Oben