Variablen Variablen mit unendlichem Wert

[CreepyPvP]

Ich schreibe derzeit an einem kleinem Neuronalen Netz. Das Problem ist , dass die Float Variable , die als Ausgabe dient den Wert -Infinity hat. Wie kommt so etwas zustande ?

 

[fhoffmann]

Du teilst irgendwo durch Null.

 

[VfL_Freak]

Moin,

Wie kommt so etwas zustande ?

ohne Code könnten wir nur raten, wo Du da was falsch macht ...
VG Klaus

 

[CreepyPvP]

ohne Code könnten wir nur raten, wo Du da was falsch macht ...

Hier wäre der Code :
Klasse Neuron

package CreepyNet;

public abstract class Neuron {

    public abstract float getValue();
  
}

Klasse InputNeuron

package CreepyNet;

public class InputNeuron extends Neuron{

    private float value;
  
    public void setValue(float value) {
        this.value = value;
    }
  
    @Override
    public float getValue() {
        return value;
    }
  
}

Klasse WorkingNeuron

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

Klasse NeuralNetwork

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

Klasse Conection

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;
    }
  
}

Klasse Tester

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 ? Denn im meinem gesamten Code kommt kein einziges mal "/" vor.
Grüsse Creepy

 

[stg]

Gibt es noch anddere Wege den Wert -Infinity zustandezubringen ?

Ja.

double verySmallValue = Double.MIN_VALUE - 2.0 * Double.MAX_VALUE;
System.out.println(verySmallValue);

 

[CreepyPvP]

Und wo liegt dann mein Fehler im obrigen Code ? Dort werden nie so riesige Zahlen erzeugt.

 

[Thallius]

Ich würde mir mal die Anzahl der Connections ausgeben lassen. Wenn die groß genug werden dann werden auch deine Zahlen entsprechend groß.

 

[CreepyPvP]

Die Anzahl beträgt 512. 2 Output Neuronen mit jeweils einer Verbindung zu jedem Pixel des Bildes. Bei einer Bildgrösse von 16 auf 16 Pixel sind es 256 Pixel.

 

[Thallius]

gelöscht wegen *blödsinn*

brauche mehr Kaffeee

 

[CreepyPvP]

Ich habe gerade was verändert , jetzt kommt nicht mehr der Wert -Infinity raus , sondern NaN. Wie kommt so etwas zustande ?

 

[Thallius]

warum setzt du nicht einfach mal einen BreakPoint und debuggst das ganze statt rumzuraten?

 

[fhoffmann]

Zum Beispiel so:

public class Test {
   public static void main(String[] args) {
      float f = -1.0f / 0.0f;
      System.out.println(f);   // Ausgabe: -Infinity
      System.out.println(f-f); // Ausgabe: NaN
   }
}

 

[Meniskusschaden]

Dort werden nie so riesige Zahlen erzeugt.

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.

 

[CreepyPvP]

warum setzt du nicht einfach mal einen BreakPoint und debuggst das ganze statt rumzuraten?

Ja ich habe die Fehler Stelle gefunden, weiss aber nicht , warum dieser Fehler ensteht :
0.1 * -3.9443458E20 * 4.7511674E19 = -Infinity
0.1 * -3.9443458E20 * 3.469229E20 = -Infinity
0.1 * -1.8462315E21 * 3.1463255E20 = -Infinity
0.1 * -1.8462315E21 * 1.531599E21 = -Infinity
(Ich habe ein paar Ausgaben generieren lassen)
Das passiert an einer Stelle in der WorkingNeuron Klasse :

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

Wodurch wird hier die Aufgabe falsch ausgerechnet. Meine Vermutung war , dass die Zahlen zu viele Dezimalen besitzen. Gäbe es da einen Weg die Stellen nach x Dezimalen einfach abzuschneiden ?
Grüsse Creepy

 

[Meniskusschaden]

Mit Nachkommastellen hat das nichts zu tun. Die Werte sind einfach zu groß für den Datentyp float. Sind die Zahlen denn richtig? Dann kannst du überlegen, ob double ausreicht. Oder sind sie falsch? Dann mußt du die Ursache dafür finden.

 

[CreepyPvP]

Sind die Zahlen denn richtig?

Ich denke, dass die Zahlen richtig sind.

Dann kannst du überlegen, ob double ausreicht.

Leider auch nicht.

Die Werte sind einfach zu groß für den Datentyp float.

Wie zu groß?

Mit Nachkommastellen hat das nichts zu tun

Ist 0.1 * 4 * 5 zu groß für float?

 

[Meniskusschaden]

Ist 0.1 * 4 * 5 zu groß für float?

Die Zahlen stehen da ja nicht, sondern 0.1 * -394434580000000000000 * 47511674000000000000. Das "E" steht für "* 10 hoch".

 

[CreepyPvP]

Gäbe es da einen Weg die Stellen nach x Dezimalen einfach abzuschneiden ?

Dann würde da nicht

0.1 * -394434580000000000000 * 47511674000000000000

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 ?

 

[temi]

Ja ich habe die Fehler Stelle gefunden, weiss aber nicht , warum dieser Fehler ensteht :
0.1 * -3.9443458E20 * 4.7511674E19 = -Infinity

Dann such jetzt weiter, warum der übergebene Wert, z.B. für "diff" so groß ist.

 

[Thallius]

Du weist aber schon was eine Exponential Schreibweise einer Zahl ist oder?

 

[Meniskusschaden]

Gäbe es da einen Weg die Stellen nach x Dezimalen einfach abzuschneiden ?

Dann würde da nicht

0.1 * -394434580000000000000 * 47511674000000000000

sondern vielleicht nur noch 0.1 * -39443458 * 47511674 stehen

Nein, da würde dann eher so etwas stehen:
0.1 * -300000000000000000000 * 40000000000000000000
Die Nachkommastellen von beispielsweise 1.23456E3 sind ja nicht 23456 sondern 56, denn es handelt sich um die Zahl 1234,56. Bezüglich der Größenordnung würde sich also nichts Wesentliches ändern.

Es hindert dich natürlich niemand daran, einfach 0.1 * -39443458 * 47511674 zu berechnen. Nur wozu soll das gut sein? Wenn du das Ergebnis von 0.1 * -3.9443458E20 * 4.7511674E19 gar nicht benötigst, kannst du die Berechnung auch gleich ganz weglassen. Und wenn du es benötigst, bringt es dir doch nichts, etwas ganz anderes auszurechnen. Oder willst du danach die entsprechende Anzahl von Nullen wieder anhängen? Dann wäre das Ergebnis aber wieder zu groß für float.

Aus #16 ergibt sich, dass du eigentlich 0.1 * 4 * 5 (also 2) für richtig oder zumindest plausibel hältst. Das Ergebnis von 0.1 * -3.9443458E20 * 4.7511674E19 ist aber ungefähr folgendes:
-1874000000000000000000000000000000000000
Das ist ja nun nicht exakt dasselbe wie 2. Ich kann nicht nachvollziehen, warum du die Zahlen gar nicht hinterfragst, sondern sie trotzdem ausrechnen willst, obwohl sie offensichtlich völlig von deinem erwarteten Ergebnis abweichen.

 

[CreepyPvP]

Du weist aber schon was eine Exponential Schreibweise einer Zahl ist o

Das wusste ich zu diesem Zeitpunkt noch nicht. Das kommt in der 7. Jahrgangsstufe Mathe noch nicht dran......

 

[MiMij]

Wenn du ein Programm schreibst, solltest du bei Berechnungen auch verstehen welche Zahlen wo rauskommen (sollten) um dann weiter zu verstehen was schief geht. Wenn ich also zb eine Addition von 2 Zahlen hab und ich erwarte das 5 rauskommt, das passiert aber nicht, dann schau ich mir die Zahlen an welche er benutzt hat für die Addition. Eventuell erwarte ich auch das die erste Zahl eine 2 ist, dann weiß ich das die zweite eine 3 sein muss, ist dies nicht der Fall muss ich prüfen warum diese Zahlen nicht stimmen. Und nicht einfach wieterhin das ERgebnis in Frage stellen