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.

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

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

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

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

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

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

Mfg Marco

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.

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

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.

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.

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

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.

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 ?

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

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)

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

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

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