Monte Carlo-Simulation

Transkript

1 Monte Carlo-Simulation Sehr häufig hängen wichtige Ergebnisse von unbekannten Werten wesentlich ab, für die man allerhöchstens statistische Daten hat oder für die man ein Modell der Wahrscheinlichkeitsrechnung annimmt. So sind z.b. Betonfestigkeiten, Bodenfestigkeiten NIE exakt vorhersagbar, dennoch hängt die Sicherheit einer Konstruktion stark von diesen Parametern ab. Manchmal ist auch das mathematische Modell zu komplex, um selbst bei bekannten Daten das Ergebnis zu errechnen. Für solche Fälle bietet sich die Monte Carlo-Simulation an. Man modelliert das ganze System als Computermodell und lässt den Computer extrem viele Beispiele abarbeiten. Aus der statischen Erfassung der Ergebnisse lassen sich so Rückschlüsse auf die gesuchten Werte machen: z.b. ein Würfelspiel: A hat 2 Würfel, B hat einen Würfel. A schlägt B, wenn einer seiner Würfel mehr Augen anzeigt als der Würfel von B, andernfalls verliert er. Wie gut sind seine Chancen? Dieses Problem lässt sich mit der Wahrscheinlichkeitsrechnung bzw. Kombinatorik exakt lösen. Man kann aber ebenso leicht den Computer einige 1000 Mal gegen sich selbst würfeln und den Sieger ermitteln lassen. Ist p die Gewinnwahrscheinlichkeit von A und q jene von B, so gilt p+q = 1. Das Gesetz der großen Zahlen besagt, dass A unter N Spielen mit hoher Wahrscheinlichkeit (p * N) gewinnen wird. Hat er also in der Simulation genau a Spiele tatsächlich gewonnen, so folgt a ~ Np oder p ~ a/n Der Computer würfelt also N mal, zählt die Anzahl a der Siege von A und dividiert: p ~ a/n. Das Problem ist nur noch: Wie würfelt man in C/C++? Zufallszahlen: Das Würfeln ist ein Zufallsexperiment mit genau 6 möglichen Ergebnissen. Im Idealfall wird jede Augenzahl mit derselben Wahrscheinlichkeit gewürfelt werden, d.h. wir haben eine "Gleichverteilung" der Zahlen 1 bis 6 zu simulieren. Ein getürkter Würfel würde z.b. die Zahl 6 wesentlich öfter würfeln und hätte daher eine andere Verteilung. Andere Experimente liefern "kontinuierliche" Zufallszahlen, d.h. es sind alle Zahlen aus Intervallen oder gar alle reellen Zahlen zugelassen.

2 Gleichverteilung in [0,1) Das ist die wichtigste Verteilung in der Simulation. Sie simuliert ein Experiment, in dem jede Zahl aus [0,1) mit gleicher Wahrscheinlichkeit herauskommt. So eine Verteilung mit überabzählbar vielen Ergebnissen lässt sich nur mittels der Verteilungsfunktion F(x) oder deren Ableitung f(x) (der Dichtefunktion) beschreiben: F(x) = P(X <= x) Wahrscheinlichkeit, dass das Ergebnis X kleiner (oder gleich) x ist. Bei der Gleichverteilung in [0,1): F(x) = 0 falls x <= 0, F(x) = 1 falls x >= 1, und F(x) = x für 0 <= x <= 1 f(x) = 1, falls 0 < x < 1 und 0 sonst. Simulation einer Gleichverteilung, Zufallszahlen in C Zufallszahlen kann man in C (und auch in C++) so erzeugen: int rand() liefert eine Gleichverteilung der ganzen Zahlen 0,1,2,..., RAND_MAX (RAND_MAX ist ein Makro, der in stdlib.h bzw. cstdlib definiert ist), also approximiert double X = (double) rand()/rand_max // in C double X = static_cast<double>(rand()/rand_max // in C++ (ACHTUNG!!! Die Umwandlung zu double ist nötig, da es sich sonst um eine int-division handeln würde und meistens 0 herauskommt) eine Gleichverteilung in [0,1]. Da man den Wert 1 eigentlich nicht haben will, wird auch double X = rand()/(rand_max + 1.0) oder auch etwas ähnliches wie double X = rand()/(rand_max ) empfohlen, wodurch man sich die double-konvertierung spart und eine Gleichverteilung in [0,1) erhält (ohne die 1!). Ich verwende eigentlich fast immer die letzte Methode. Würfeln in C wir nehmen eine Gleichverteilung X in [0,1) : wir "würfeln" 1, falls 0 <= X < 1/6 gilt: 0 <= 6X < 1, 1 <= 6X+1 < 2 wir "würfeln" 2, falls 1/6 <= X < 2/6 gilt: 1 <= 6X < 2, 2 <= 6X+1 < 3...

3 Der Ausdruck 6X+1 liegt sicher im Intervall [1,7) und daher ist diese Vorschrift sehr leicht durch die Berechnung als int-ausdruck erledigt: int w = 6*X+1; // in C++ ist eine Warnung möglich, da rechts double steht int w = static_cast<int>(6*x+1); // daher besser in C++ auto w = static_cast<int>(6*x+1); Ganz allgemein: Sucht man eine Gleichverteilung der Zahlen n, n+1, n+2,..., n + (k-1) (k Zahlen), so bekommt man das mit der Formel int (oder auto) w = static_cast<int>(n + k*x); hin. So lassen sich auch Kopf/Zahl Spiele oder Roulette etc. simulieren. Nicht gleichverteilte Wahrscheinlichkeiten gehen etwas komplizierter und erfordern eine nichttriviale Modifikation obiger Formeln. Um eine gegebene diskrete Verteilung Y der n Zahlen y 0, y 1, y 2,, y n-1 mit vorgegebenen positiven Wahrscheinlichkeiten P(Y = y i ) = p i, deren Summe natürlich 1 sein muss, zu generieren, geht man so vor: 1) berechne die Teilsummen s 0 = p 0, s 1 = p 0 +p 1,, s n-1 = p 0 +p 1 + +p n-1 = 1 2) Generiere Stichproben x einer Gleichverteilung X in [0,1) s.o. 3) Finde den Index i, sodass s i x < s i+1 4) Gib y i zurück Hier muss man im Allgemeinen eine Menge Vergleiche abarbeiten, ehe man das Resultat y i erhält. Für den einfachen Fall n = 2 (z.b. Münzwurf oder Erfolg/Misserfolg) mit gegebenen P(Y = 0) = p und P(Y = 1) = q, p+q = 1 ist obiges Verfahren einfach zu implementieren. Die Teilsummen sind nämlich nur p und 1 und wir erhalten: 1) Generiere Stichproben x einer Gleichverteilung X in [0,1) s.o. 2) Gilt x < p, dann gib 0 zurück, sonst 1 int w = (x >= p); // hier ist es viel besser, int statt auto verwenden Simulation von kontinuierlichen Zufallsgrößen Sehr oft braucht man auch Stichproben von kontinuierlichen Zufallsgrößen mit bekannter Verteilung. Der C-Zufallszahlen-Generator ist mit Einschränkungen auch dazu zu gebrauchen. Mit double X = rand() / (RAND_MAX ); erzeugt man eine annähernde Gleichverteilung in [0,1). In der Warteschlangentheorie z.b.benötigt man meist exponentialverteilte Zufallsgrößen. Mathematischer Background: Ist Y eine Zufallsgröße mit Verteilungsfunktion F(x), d.h. es gilt P (Y < a) = F(a) dann ist X = F(Y) gleichverteilt in [0,1):

4 P(X < a) = P( F(Y) < a ) = P ( Y < F -1 (a) ) = F( F -1 (a) ) = a Umgekehrt erhält man durch Anwendung der Umkehrfunktion von F aus einer [0,1)-Gleichverteilung X die gewünschte Verteilung: Y = F -1 (X) Exponential-Verteilung: Diese Verteilung wird fast immer für zufällige Wartezeiten in der Warteschlagentheorie verwendet (z.b. Dauer einer Bearbeitung, Brenndauer einer Glühbirne, Funktionsdauer eines technischen Bauteils usw.). Für die Exponential-Verteilung ist daher ist die Umkehrfunktion F(x) = 1 - exp(- λ * x) für x > 0 0 für x<= 0 (es können keine negativen Werte auftreten). F -1 (x) = - (1/ λ) log(1 - x) log ist der natürliche Logarithmus (oft auch ln) Die Exponential-Verteilung hat den Erwartungswert (1/λ) und die Varianz (1/λ) 2. Wichtig ist, dass für x nie der Wert 1 möglich ist, d.h. X muss eine Gleichverteilung in [0,1), und nicht [0,1], besitzen. Beispiel: Erstelle einen zufälligen Zeitplan von Busabfahrten, die im Schnitt alle 5 Minuten stattfinden sollen. Als Verteilung ist eine Exponentialverteilung anzunehmen: Rechnet man in Minuten, so sucht man Stichproben einer Exponentialverteilung mit Erwartungswert 5 = 1/λ. Diese erzeugt man mittels: double wz(double ew) // zufällige Wartezeit mit Erwartungswert ew { double x = rand()/(rand_max ); // in [0,1)-gleichverteilt return -ew*log(1-x); } und konstruiert einen Zeitplan wie folgt: double start = 8*60; // 8 Uhr 00 double ende = 22*60; // um 22 Uhr schließt der Busservice int busse = 0; for (double t = start; t <= ende; t += wz()) cout <<"Abfahrt Bus Nr. " << ++busse << " um " << t << '\n'; Rechnet man in Sekunden, sind die Werte für start, ende und λ entsprechend zu ändern! Andere Verteilungen Leider sind die Verteilungsfunktionen F(x) von vielen anderen Verteilungen nicht so einfach zu invertieren. Hier liefert die Numerik manchmal gute Näherungsverfahren.

5 Initialisierung des Zufallszahlengenerators Der Zufallszahlengenerator (den wir durch den Aufruf von rand()) benutzen, liefert Pseudo- Zufallszahlen (d.h. die Zahlen werden mit einem Algorithmus erstellt, verhalten sich aber wie echt zufällige Werte), die aber stets dieselbe Folge von Zahlen durchlaufen. Will man mit anderen Werten starten, sollte man vor dem 1. Aufruf den Zufallszahlengenerator neu seed en, d.h. mit anderen Anfangsdaten belegen. Dazu dient die Funktion void srand(int seed); Bei gleichem seed Wert wiederholt sich natürlich auch hier die Zufallsfolge. Das kann man verhindern, indem man z.b. die time() Funktion aus <time.h> verwendet. Unter Linux kann man auch den Seedwert aus /dev/random lesen usw. Zufallszahlen in C++11 C++11 verfügt über wesentlich neuere und bessere Algorithmen für Zufallszahlen, die nach dem Inkludieren von <random> zur Verfügung stehen. Auch hier benötigt man einen Generator (der liefert z.b. gleichverteilte Zufallszahlen in [0,1)) und daraus simuliert die Distribution den gewünschten Zufallszahlentyp. Vor allem der Generator wurde stark verbessert und auf Geschwindigkeit und/oder mathematische Qualität optimiert. Alle diese Objekte liegen im Namespace std! Sehr häufig wird der Generator mt19937 (Mersenne Twister) verwendet (mit mt19937_64 gibt es auch eine 64 bit-version davon), der Generator random_device erzeugt echte Zufallszahlen, wie man sie in der Kryptografie verwendet. Die wichtigsten Verteilungen stehen als Distribution zur Verfügung: uniform_int_distribution, uniform_real_distribution bernoulli_distribution, binormal_distribution exponential_distribution, normal_distribution Wie baut man das nun zusammen: 1) Wir wollen eine diskrete Gleichverteilung in [1,6] (Würfel): unsigned seed = // zufälliger Startwert std::chrono::system_clock::now().time_since_epoch().count(); std::mt19937 gen(seed); // Definiere den Generator std::uniform_int_distribution<int> wuerfel(1, 6); // Verteilung wuerfel(gen); // die Zufallszahl wuerfel(gen); // die nächste Zufallszahl 2) Eine Exponentialverteilung mit Erwartungswert 6 (z.b. Wartezeit): unsigned seed = // zufälliger Startwert std::chrono::system_clock::now().time_since_epoch().count();

6 std::mt19937 gen(seed); // Definiere den Generator std::exponential_distribution<double> w(6.0);// die Verteilung w(gen); // die Zufallszahl w(gen); // die nächste Zufallszahl 3) Eine Normalverteilung mit Erwartungswert 4.0, Standardabweichung 5.0: unsigned seed = // zufälliger Startwert std::chrono::system_clock::now().time_since_epoch().count(); std::mt19937 gen(seed); // Definiere den Generator std::normal_distribution<double> n(4.0, 5.0);// die Verteilung n(gen); // die Zufallszahl n(gen); // die nächste Zufallszahl Verwendet man das Seeden des Generators wie oben, muss man auch <chrono> inkludieren. Ohne einen Zufalls-Startwert liefern alle Generatoren (außer der echte Zufallszahlen -Generator) stets dieselbe Folge von Zufallszahlen!