ohne Code könnten wir nur raten, wo Du da was falsch macht ...Wie kommt so etwas zustande ?
Hier wäre der Code :ohne Code könnten wir nur raten, wo Du da was falsch macht ...
package CreepyNet;
public abstract class Neuron {
public abstract float getValue();
}
package CreepyNet;
public class InputNeuron extends Neuron{
private float value;
public void setValue(float value) {
this.value = value;
}
@Override
public float getValue() {
return value;
}
}
package CreepyNet;
import java.util.ArrayList;
public class WorkingNeuron extends Neuron{
private ArrayList<Conection> connections;
public WorkingNeuron() {
connections = new ArrayList<>();
}
@Override
public float getValue() {
float v = 0;
for (Conection c : connections) {
v += c.getValue();
}
return v;
}
public void addConnection(Neuron target, float w) {
connections.add(new Conection(target, w));
}
ArrayList<Conection> getConnections() {
return connections;
}
public void deltaLearning(float diff, float lernfaktor) {
for (int i = 0; i < connections.size(); i++) {
float DeltaWeigth = lernfaktor * diff * connections.get(i).getValue();
connections.get(i).w += DeltaWeigth;
System.out.println(connections.get(i).w);
}
}
}
package CreepyNet;
import java.util.ArrayList;
import java.util.Random;
import javax.management.RuntimeErrorException;
public class NeuralNetwork {
private ArrayList<InputNeuron> inputs;
private ArrayList<WorkingNeuron>[] layer;
public NeuralNetwork(int layerCount) {
layer = new ArrayList[layerCount];
for (int i = 0; i < layerCount; i++) {
layer[i] = new ArrayList<WorkingNeuron>();
}
inputs = new ArrayList<InputNeuron>();
}
public ArrayList<WorkingNeuron> getOutputs() {
return layer[0];
}
public ArrayList<InputNeuron> getInputs() {
return inputs;
}
public InputNeuron createInput() {
InputNeuron neu = new InputNeuron();
inputs.add(neu);
return neu;
}
public WorkingNeuron createWorkingNeuron(int layer) {
if (layer >= this.layer.length) {
throw new RuntimeException();
}
WorkingNeuron neu = new WorkingNeuron();
this.layer[layer].add(neu);
return neu;
}
public void createFullMeshWithRandomWeigths(int layer, float max) {
if (layer >= this.layer.length || layer < 0) {
throw new RuntimeException();
}
Random r = new Random();
if (layer == 0) {
for (WorkingNeuron currentNeuron : this.layer[layer]) {
for (InputNeuron currentConnection : inputs) {
currentNeuron.addConnection(currentConnection, (r.nextFloat() % max) + 0.1f);
}
}
return;
}
for (WorkingNeuron currentNeuron : this.layer[layer]) {
for (WorkingNeuron currentConnection : this.layer[layer - 1]) {
currentNeuron.addConnection(currentConnection, r.nextFloat() % max);
}
}
}
public void createFullMesh(int layer, float... weigths) {
if (layer >= this.layer.length || layer < 0) {
throw new RuntimeException();
}
if (layer == 0) {
int index = 0;
for (WorkingNeuron currentNeuron : this.layer[layer]) {
for (InputNeuron currentConnection : inputs) {
currentNeuron.addConnection(currentConnection, weigths[index]);
index++;
}
}
return;
}
int index = 0;
for (WorkingNeuron currentNeuron : this.layer[layer]) {
for (WorkingNeuron currentConnection : this.layer[layer - 1]) {
currentNeuron.addConnection(currentConnection, weigths[index]);
index++;
}
}
}
public InputNeuron[] createInputNeuronArray(int size) {
InputNeuron[] r = new InputNeuron[size];
for (int i = 0; i < size; i++) {
r[i] = createInput();
}
return r;
}
public void deltaLearning(float[] sollWert, float lernfaktor) {
if (layer.length == 1 && sollWert.length != layer[0].size()) {
throw new RuntimeException();
}
for (int i = 0; i < sollWert.length; i++) {
float diff = sollWert[i] - layer[0].get(i).getValue();
layer[0].get(i).deltaLearning(diff, lernfaktor);
}
}
}
package CreepyNet;
public class Conection {
public Conection(Neuron target, float w) {
neuron = target;
this.w = w;
}
float w;
Neuron neuron;
public float getValue() {
return neuron.getValue() * w;
}
}
package CreepyNet;
import java.awt.image.BufferedImage;
import java.io.IOException;
import javax.imageio.ImageIO;
import NeuronalesNetz.Test;
public class Tester {
public static void main(String[] args) {
NeuralNetwork net = new NeuralNetwork(1);
InputNeuron[] input = net.createInputNeuronArray(256);
WorkingNeuron dirt = net.createWorkingNeuron(0);
WorkingNeuron ice = net.createWorkingNeuron(0);
net.createFullMeshWithRandomWeigths(0, 1);
float[] dirtData = getImage16x16("dirt.png");
float[] iceData = getImage16x16("ice.png");
learnData(dirtData, new float[] {1f,0f}, 1f, 10, net);
System.out.println(dirt.getValue());
System.out.println(ice.getValue());
}
public static float[] getImage16x16(String name) {
BufferedImage img;
float[] r;
try {
img = ImageIO.read(Tester.class.getResourceAsStream(name));
r = new float[256];
for (int i = 0; i < 16; i++) {
for (int j = 0; j < 16; j++) {
r[i * 16 + j] = img.getRGB(i, j);
}
}
return r;
} catch (IOException e) {
e.printStackTrace();
r = null;
return r;
}
}
public static void learnData(float[] in, float[] out, float lernfaktor, int anzahl, NeuralNetwork net) {
for (int i = 0; i < net.getInputs().size(); i++) {
net.getInputs().get(i).setValue(in[i]);
}
for (int j = 0; j < anzahl; j++) {
net.deltaLearning(out, lernfaktor);
}
}
}
Gibt es noch anddere Wege den Wert -Infinity zustandezubringen ?
double verySmallValue = Double.MIN_VALUE - 2.0 * Double.MAX_VALUE;
System.out.println(verySmallValue);
Woher weißt du das? Außerdem musst du es natürlich auf die Maximalgrößen der von dir verwendeten Datentypen beziehen. float deckt natürlich einen kleineren Bereich ab als double.Dort werden nie so riesige Zahlen erzeugt.
Ja ich habe die Fehler Stelle gefunden, weiss aber nicht , warum dieser Fehler ensteht :warum setzt du nicht einfach mal einen BreakPoint und debuggst das ganze statt rumzuraten?
public void deltaLearning(float diff, float lernfaktor) {
for (int i = 0; i < connections.size(); i++) {
float DeltaWeigth = lernfaktor * diff * connections.get(i).getValue(); //Hier ensteht der Fehler!!!!
System.out.println(lernfaktor + " * " + diff + " * " + connections.get(i).getValue() + " = " + DeltaWeigth); // Hier sind die Ausgaben enstanden !
connections.get(i).addWeigth(DeltaWeigth);
}
}
Ich denke, dass die Zahlen richtig sind.Sind die Zahlen denn richtig?
Leider auch nicht.Dann kannst du überlegen, ob double ausreicht.
Wie zu groß?Die Werte sind einfach zu groß für den Datentyp float.
Ist 0.1 * 4 * 5 zu groß für float?Mit Nachkommastellen hat das nichts zu tun
Die Zahlen stehen da ja nicht, sondern 0.1 * -394434580000000000000 * 47511674000000000000. Das "E" steht für "* 10 hoch".Ist 0.1 * 4 * 5 zu groß für float?
Dann würde da nichtGäbe es da einen Weg die Stellen nach x Dezimalen einfach abzuschneiden ?
sondern vielleicht nur noch 0.1 * -39443458 * 47511674 stehen oder gäbe es einen Weg , diesen Wert irgendwie zu speichern und damit rechnen zu können ?0.1 * -394434580000000000000 * 47511674000000000000
Ja ich habe die Fehler Stelle gefunden, weiss aber nicht , warum dieser Fehler ensteht :
0.1 * -3.9443458E20 * 4.7511674E19 = -Infinity
Nein, da würde dann eher so etwas stehen:Dann würde da nichtGäbe es da einen Weg die Stellen nach x Dezimalen einfach abzuschneiden ?
0.1 * -394434580000000000000 * 47511674000000000000sondern vielleicht nur noch 0.1 * -39443458 * 47511674 stehen
Das wusste ich zu diesem Zeitpunkt noch nicht. Das kommt in der 7. Jahrgangsstufe Mathe noch nicht dran......Du weist aber schon was eine Exponential Schreibweise einer Zahl ist o