long double Zufallswerte

fuse

Liebe Gemeinschaft,

für die Startwerte der Gewichtungen meines neuralen Backpropergation Netzes
hätte ich gern den Code eines geeigneten Zufallsgenerators.

Er soll schnell sein
und möglichst zufällige sowie gleichmäßig verteilte Fließkommazahlen
im Wertebereich -1,1E-4932 bis 1,1E4932 zurückgeben.

Zugunsten der Symetrie
und um einen Offsetwert zu im Sinne der Codeübersichtlichkeit zu vermeiden
wurde der negative long double Bereich nicht ganz ausgereizt.

Über entsprechende Lösungen für Borland C++ würde ich mich sehr freuen.

Nexus

Wäre die Bibliothek Boost.Random etwas für dich?

Eventuell kannst du auch den Linearen Kongruenzgenerator aus der Standardbibliothek benutzen, allerdings besitzt der nicht eine wahnsinnig gute Zufälligkeit. Ein naiver Ansatz wäre:

long double Random(long double begin, long double end)
{
    return static_cast<long double>(rand()) / RAND_MAX * (end - begin) + begin;
}

void generate_random_floating_point_number(double& number)
{
    for(unsigned int i = 0; i != sizeof(double); ++i)
        *reinterpret_cast<unsigned char*>(&number) = (unsinged char)rand();
}

Optimierbar wenn du festlegst, wie groß dein double typ sein soll.

SeppJ

Denke daran, dass bei einem long double die möglichen Werte ungleichmäßig auseinanderliegen (und es sind auch nicht so viele mögliche Werte wie man so denkt). Ein Zufallsgenerator der long double gleichverteilt abdeckt muss schon ziemlich speziell aufgebaut sein, glaube nicht, dass es das gibt, denn: Wozu soll das gut sein? Ich sehe auch bei deiner Anwendung keine Notwendigkeit derart großer Zahlen. Kannst du mich da mal erleuchten?

edit: @asdfasd: Dein Code macht genau das was ich meine: Unglaublich viele Zahlen nahe 0 und vergleichsweise wenige große Zahlen.

Nexus

@asdfasd:
Ich denke, das gibt Probleme, weil nicht jedes Bitmuster eine gültige Fliesskommazahl ist (NaN und so).

Nochmal korrigiert

void generate_random_floating_point_number(double& number)
{
    for(unsigned int i = 0; i != sizeof(double); ++i)
        *(reinterpret_cast<unsigned char*>(&number)+i) = (unsigned char)rand();
}

Ja, an Nan und +/- inf habe ich nicht gedacht. Dann wirds kniffeliger

Marc-O

Bischen Offtopic:

Nexus schrieb:

@asdfasd:
Ich denke, das gibt Probleme, weil nicht jedes Bitmuster eine gültige Fliesskommazahl ist (NaN und so).

Nexus kannst du mir kurz erklären oder einen link geben was es mit diesem NaN auf sich hat, hatte diesen Werten erste letztens bei Ausgaben vor mir und konnte mir nicht ganz vorstellen was dies zu bedeuten hat.

Mfg marco

Nexus

Marc-O schrieb:

Nexus kannst du mir kurz erklären oder einen link geben was es mit diesem NaN auf sich hat, hatte diesen Werten erste letztens bei Ausgaben vor mir und konnte mir nicht ganz vorstellen was dies zu bedeuten hat.

http://de.wikipedia.org/wiki/NaN

http://en.wikipedia.org/wiki/IEC_559#Cases

Marc-O

Danke schön

NaN (engl. Not a Number) => Zu leicht um selber drauf zu kommen

Mfg Marco

fuse

Es handelt sich um ein simples Buchstabenerkennungsnetz
von dem ich den Quellcode gern offen legen kann.

Hier meine Funktion:

void TForm1::GewichtungenRandomize(int netz)
{
Randomize(); // gleicher startwert für ganzes netz (algorhytmusabzeichnung?)
for(int quellschicht=1; quellschicht<=schichtanzahl-1;++quellschicht)  // quellschichtenanzahl = schichtanzahl-1
  {
  for(int verbindungsquelle=1; verbindungsquelle<=objektanzahl[quellschicht];++verbindungsquelle)
    {
    for(int verbindungsziel=1; verbindungsziel<=objektanzahl[quellschicht+1];++verbindungsziel)
      {
      // Randomize(); // für jede verbindung ein extra startwert (clockabzeichnung = zufallswert clockeperiodeisch(sekunde?) gleich)
      verbindung[netz][quellschicht][verbindungsquelle][verbindungsziel]=RandomRange(-1.1E-4932l,1.1E4932l);     // gewichtung   // geringster wert: -3.4E-4932l nicht genutzt um ein symetrisches verhältnis zu erzeugen
      }
    }
  }
}
//---------------------------------------------------------------------------

Randomize() und RandomRange() kann ich leider nich mehr verwenden,
da nur Integerwerte zurückgegeben werden.

Boost.Random habe ich überflogen. Vermutlich ist es da auch so.

Den Zahlenraum reize ich wie genannt nur symetrisch aus.

Ich habe schon darüber nachgedacht,
wie der Mersenne-Twister MT 19937 angepasst werden müsste.
http://de.wikipedia.org/wiki/Mersenne-Twister
Weiß jemand wie das am besten geht ?

Vielleicht gibt es aber auch bessere Lösungen.

life

Hab zwar von Boost Random keine Ahnung, aber die folgende Klasse von Boost Random sieht doch schon recht vielversprechend aus:

http://www.boost.org/doc/libs/1_43_0/doc/html/boost/uniform_real.html

SeppJ

life schrieb:

Hab zwar von Boost Random keine Ahnung, aber die folgende Klasse von Boost Random sieht doch schon recht vielversprechend aus:

http://www.boost.org/doc/libs/1_43_0/doc/html/boost/uniform_real.html

Note: The current implementation is buggy, because it may not fill all of the mantissa with random bits.

fuse

Die Bits sollten schon gefüllt werden.

Dies ist auch eine schöne Bibliothek:
http://lxnt.info/rng/randomc.htm
Long double Rückgaben konnte ich auch dort nicht entdecken.

Mir wurde erklährt,
daß das Netz kleine Unterschiede bei auflösenderen Werten besser erkennen kann.
Ein Professor hat mir double empfolen. Für einen Wert werden 8 Byte reserviert. Bei long double sind es 2 Byte mehr. Der Zahlenraum ist aber um vieles größer.

Deshalb habe ich mein ursprüngliches Integernetz mit nur positiven Werten bis 255 (unsigned char hätte ich verwenden können) schon bis auf den Zufallsgenerator umgestellt.

Ich bin sehr gespannt wie es sich dann verhält.

Ergäbe sich eine Wahrscheinlichkeitsverschiebung,
wenn ich Zufallsfunktionsergebnisse aufaddiere bis die maximalen Zufallszahlen
den kompletten Zahlenraum füllen würden ?

Bei long double vom Minimalwert zum Maximalwert zu zählen stelle ich mir Zeitaufwendig vor.

SeppJ schrieb:

Note: The current implementation is buggy, because it may not fill all of the mantissa with random bits.

Das würde ich persönlich jetzt nicht überbewerten, zumal die Anwendung "Startwerte der Gewichtungen meines neuralen Backpropergation Netzes" nicht so kritisch erscheint. Wenn man stattdessen selbst irgendwas frikelt, baut man desweiteren sicherlich noch mehr bugs rein..

SeppJ

fuse schrieb:

Ergäbe sich eine Wahrscheinlichkeitsverschiebung,
wenn ich Zufallsfunktionsergebnisse aufaddiere bis die maximalen Zufallszahlen
den kompletten Zahlenraum füllen würden ?

Ja, das geht dann gegen eine Gaußverteilung.

Außerdem kannst du nicht beliebig integer-Werte zu einem double addieren, denn schon bald wird der gespeicherte Wert so groß, dass eine Addition eines INT_MAX trotzdem wieder den alten Wert ergibt.

Bei long double vom Minimalwert zum Maximalwert zu zählen stelle ich mir Zeitaufwendig vor.

Ähem, selbst wenn es theoretisch ginge (siehe oben, warum es nicht geht), bräuchtest du etwa 10^4913 Rechenschritte. Du bräuchtest mit jetziger Technik etwa 10^4897 CPU-Jahre dafür.

Der long double ist auch nur um die 16 Byte groß. Nur die Interpretation ist anders als z.B. bei einem long int. Das heißt es gibt 2^16 mögliche Werte die ein double annehmen kann. Wenn du es so machst wie in diesem Thread gezeigt und einfach ein zufälliges 16 Byte Bitmuster reinterpretierst, dann hast du die möglichen Werte eines double gleichmäßig abgedeckt. Dabei willst du wahrscheinlich auch noch Sonderwerte wie inf und NaN abfangen.
Wenn es das ist, was du willst (was nichts anderes ist als eine 16 Byte Zufallszahl), dann mach es. Die Werte sind dann aber nicht gleichmäßig auf den reellen Zahlenraum verteilt. Angefangen damit, dass es zum Beispiel zwei verschiedene Nullen gibt, entspricht die Dichteverteilung der Zufallszahlen ungefähr so wie |1/x| aus^*. Falls die Gleichverteilung über einen so großen Zahlenbereich wichtig sein sollte, ist double der falsche Typ.

^*: Ja, es ist nicht |1/x|, weil das keine gültige dichtefunktion ist, aber es sieht so ähnlich aus und ich war zu faul zum Rechnen was es genau ist. Die Funktion |1/x| illustriert das Problem ganz gut.

fuse

Wenn es einen Datentyp mit einer ähnlichen Präzision gibt,
ist er vermutlich auch geeignet.

Beim Aufadieren würde ich das Komma durch teilen nachrücken.

Die beschrieben Lösung probiere ich gern aus.

Methode:

void TForm1::ZufallsgeneratorLongDouble1(double& number)
{
while((number < -1.1E-4932l) || IsNan(number) || IsInfinite(number))
  {
  for(unsigned int i = 0; i != sizeof(long double); ++i)
    *reinterpret_cast<unsigned char*>(&number) = (unsigned char)rand();
  }
}
//---------------------------------------------------------------------------

Aufruf:

ZufallsgeneratorLongDouble1(verbindung[netz][quellschicht][verbindungsquelle][verbindungsziel]);     // gewichtung   // geringster wert: -3.4E-4932l nicht genutzt um ein symetrisches verhältnis zu erzeugen

Fehlermeldung:
---------------------------
Benachrichtigung über Debugger-Exception
---------------------------
Im Projekt NNTwo.exe ist eine Exception der Klasse EOverflow aufgetreten. Meldung: 'Gleitkommaüberlauf'. Prozeß wurde angehalten. Mit Einzelne Anweisung oder Start fortsetzen.
---------------------------
OK Hilfe
---------------------------

Was müßte geändert werden ?

no_code

fuse schrieb:

Methode:

void TForm1::ZufallsgeneratorLongDouble1(double& number)
{
while((number < -1.1E-4932l) || IsNan(number) || IsInfinite(number))
  {
  for(unsigned int i = 0; i != sizeof(long double); ++i)
    *reinterpret_cast<unsigned char*>(&number) = (unsigned char)rand();
  }
}

Was müßte geändert werden ?

alles

fuse

Welchen Code ergibt die vorgeschlagene Änderung ?

fuse schrieb:

für die Startwerte der Gewichtungen meines neuralen Backpropergation Netzes
hätte ich gern den Code eines geeigneten Zufallsgenerators.

Er soll schnell sein
und möglichst zufällige sowie gleichmäßig verteilte Fließkommazahlen
im Wertebereich -1,1E-4932 bis 1,1E4932 zurückgeben.

Für die Gewichte eines solchen Netzes würde ich mich auf einen viel kleineren Zahlenbereich beschränken, zB so etwas:

/// liefert Zufallszahl zwischen 0...1
double rectangularPDF();

/// liefert Zufallszahl zwischen -1...1
double triangularPDF()
{
  double t = rectangularPDF();
  t -= rectangularPDF();
  return t;
}

  ...
  gewicht = triangularPDF() * 10;
  ...

(oder so)