long double Zufallswerte

[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.

[life@work]

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 ?

[krümelkacker]

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)

[fuse]

Das ist auch interessant
und wenn sich der Überlauf bei der ersten Lösung vermeiden lässt
gäbe es schon 2 Lösungsansätze.

[seldon]

SeppJ schrieb:

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.

2^128. (Byte != Bit)

Dementsprechend braucht man, um von einem Ende zum nächsten zu zählen, auch nur etwa etwa 10^38,5 Schritte. Das ist auch eines der Probleme, in das man mit einer Gleichverteilung über einen derart großen Bereich in Fließkommazahlen läuft - Wenn du einem long double 1,1e-4932 zuweist und eins draufzählst, ändert sich der Wert nicht, weil der Datentyp nicht genau genug ist, beide Werte darzustellen.

Aus diesem Grund generiert man Fließkommazufallswerte üblicherweise zwischen 0 und 1, wo der Exponent keine Rolle spielt, und multipliziert dann ggf. mit der gewünschten Bereichsgröße, nach dem Muster

(double) rand() / RAND_MAX

Um das ganze zu erweitern, wäre eine Reihenentwicklung wahrscheinlich das einfachste. Ich stelle mir das etwa so vor:

long double float_rand() {
  static long double const precise_max = std::pow(2.0L, std::numeric_limits<long double>::digits) - 1;
  static long double const rand_mod = RAND_MAX + 1.0L;

  long double x = 0;
  long double divisor = 1;

  do {
    x = x * rand_mod + rand();
    divisor *= rand_mod;
  } while(divisor < precise_max / rand_mod);

  x = x * (precise_max / divisor) + (rand() / precise_max * divisor);

  return x / precise_max;
}

[Nexus]

seldon schrieb:

Aus diesem Grund generiert man Fließkommazufallswerte üblicherweise zwischen 0 und 1, wo der Exponent keine Rolle spielt, und multipliziert dann ggf. mit der gewünschten Bereichsgröße, nach dem Muster

(double) rand() / RAND_MAX

Du meinst

Nexus (1. Antwort) schrieb:

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

[fuse]

Welche Schrittweite zwischen 1 und -1 ist am kleinsten, ändert den Wert aber noch ?

[fuse]

Für den long double Datentyp verwendet der Borlnd C++ Compiler 80 Bit.

[Gast]

fuse schrieb:

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.

Interessante Frage,
für ein neuronales Netz würde ich dir persönlich allerdings kleine Werte bevorzugen wie z.B. zwischen
-1 und 1 empfehlen oder -0,5 und 0,5

EDIT: Beim vollen Ausschöpfen des Wertebereichs kriegst du auch noch Probleme mit Überläufen... Inwiefern sie die Leistungsfähigkeit deines Netzes beeinflussen, vermag ich jetzt nicht zu beurteilen

[fuse]

Ich beabsichtige meine Wertigkeit nun zwischen 1 und -1 zu legen
und möchte noch die Schrittweite für long double herrausfinden.
Anhand des Aufbaus lässt sich das wahrscheinlich ausrechnen.

Auch wenn long double nicht dem Standard entspriicht
würde ich zunächst gern daran festhalten, da das Netz dann vermutlich auch gut
mit kleinen Unterschieden zwischen hochauflösenden Bildern umgehen kann.

[SeppJ]

fuse schrieb:

Ich beabsichtige meine Wertigkeit nun zwischen 1 und -1 zu legen
und möchte noch die Schrittweite für long double herrausfinden.
Anhand des Aufbaus lässt sich das wahrscheinlich ausrechnen.

Auch wenn long double nicht dem Standard entspriicht
würde ich zunächst gern daran festhalten, da das Netz dann vermutlich auch gut
mit kleinen Unterschieden zwischen hochauflösenden Bildern umgehen kann.

Die Auflösung in der Gegend von 1 ist wiederum das epsilon von dem Typen (herauszufinden mit numeric_limits). Nach wie vor gilt jedoch, dass die Auflösung sich mit dem Wert ändert, nahe Null ist die Auflösung viel feiner, bis hin zu 1*(2 hoch min_exponent). Wenn du tatsächlich einfach nur zufällige Bitmuster im double erzeugst, musst du dies beachten. Die Verteilung müsste dann logarithmisch sein.