Algorithmik kontinuierlicher Systeme

Transkript

1 Algorithmik kontinuierlicher Systeme Iterative Verfahren (2/2)

2 Ziel dieser Vorlesung Wie schnell können wir Gleichungssysteme lösen? O(n 3 ) LR- oder QR-Zerlegung: Immer anwendbar Komplexität im Allgemeinen optimal Aber: n kann sehr groß werden Können wir wichtige Spezialfälle schneller lösen? Iterative Verfahren! 2

3 Wieso lineare Gleichungssysteme? Das einfachste sinnvolle Modell Können effizient ausgewertet werden Nichtlineare Probleme können linear approximiert werden 3

4 Motivation Mit linearen Gleichungssystemen können wir vor Tsunamis und Hurricanes warnen Auswirkungen globaler Erwärmung abschätzen Krebs frühzeitig diagnostizieren Autos, Flugzeuge etc. sicherer machen 4

5 Briefwechsel Am 26. Dezember 1823 schreibt C.F. Gauss an seinen Schüler Christian Gerling [ ] 5

6 [ ] 6

7 7

8 Iterative Verfahren Der Brief von Gauss im Jahre 1823 beschreibt das erste iterative Lösungsverfahren Das Verfahren wurde erst 1874 von Ludwig Seidel publiziert Varianten vom Gauss-Seidel-Verfahren sind das Jacobi- Verfahren und das SOR-Verfahren Vorteile: Schneller als Gauss-Elimination weniger anfällig gegen Rechenfehler 8

9 Fragestellungen der Algorithmik Algorithmik: Was ist der zugrundeliegende Algorithmus? Wann ist der Algorithmus anwendbar? Wie schnell ist der Algorithmus? Können wir weitere Verbesserungen vornehmen? Diese Fragen sind gleichzeitig der Fahrplan dieser Vorlesung 9

10 Kurzer Werbeblock Junior Consulting Team e.v. gemeinnütziger Verein von Studenten professionelle Unternehmensberatung Studenten der FAU und TH Nürnberg Website: jct.de Meinungsumfrage unter lang=de 10

11 Übersicht Was ist der zugrundeliegende Algorithmus? Wann ist der Algorithmus anwendbar? Wie schnell ist der Algorithmus? Können wir weitere Verbesserungen vornehmen? 11

12 Von 1823 nach 2017 Die Matrixnotation wurde erst 1850 eingeführt! Heute würde man schreiben a 6b 7 4c5 = d

13 Von 1823 nach 2017 Startwert: x 0 = T Koeffizient d optimieren: x 1 = T Residuum berechnen: b Ax 1 = T nächster Koeffizient, Residuum weiter verkleinern 13

14 Das Residuum Definition: r = b A x Das Residuum ist ein Maß für den absoluten Fehler, denn A( x e) =b A x Ae = b Ae = b A x {z } r Je nach Gestalt von A wird der Fehler mehr oder weniger gut durch das Residuum beschrieben In jedem Fall gilt aber r =0, e =0 14

15 Von 1823 nach 2017 Tabelle mit Residuen In jedem Schritt wir das Residuum kleiner Gauss wählt stets den Koeffizienten mit dem größten Residuum 15

16 Von 1823 nach 2017 Am Ende werden alle Korrekturen aufsummiert Nach 7 Schritten ist das Verfahren konvergiert 16

17 Der Gauss-Seidel-Algorithmus Gauss-Seidel in Python: x = np.zeros((n,1)) while np.linalg.norm(b - x) > eps: for k in range(n): left = sum(a[k,0:k] * x[0:k,0]) right = sum(a[k,k+1:] * x[k+1:,0]) x[k] = (b[k] - left - right) / a[k,k] return x Im Wesentlichen wird pro Zeile a[k,k] so gesetzt, dass in dieser Zeile das Residuum gleich 0 ist Anders als bei Gauss werden die Zeilen einfach zyklisch durchlaufen 17

18 Problem des Gauss-Seidel Verfahrens Problem: inhärent sequentiell x = np.zeros((n,1)) while np.linalg.norm(b - x) > eps: for k in range(n): left = sum(a[k,0:k] * x[0:k,0]) right = sum(a[k,k+1:] * x[k+1:,0]) x[k] = (b[k] - left - right) / a[k,k] return x Immer wenn a[k,k-j] 0 hängt x[k] von x[k-j] ab! Im allgemeinen nicht parallel ausführbar 18

19 Jacobi-Verfahren Besser parallelisierbar: Jacobi-Verfahren x = np.zeros((n,1)) while np.linalg.norm(b - x) > eps: x_new = np.zeros((n,1)) for k in range(n): left = sum(a[k,0:k] * x[0:k,0]) right = sum(a[k,k+1:] * x[k+1:,0]) x_new[k] = (b[k] - left - right)/a[k,k] return x_new Nachteil: Neue, bessere Werte x[k-j] werden ignoriert 19

20 Relaxation Konvergenzbeschleunigung durch Relaxation: Ersetze x i+1 durch! x i+1 +(1!) x i! > 1 : Überrelaxation 0 <! < 1 : Unterrelaxation x i+1 x i+1 tmp x i+1 x i+1 tmp x i SOR = Successive Over Relaxation 1 <! < 2 Gauss-Seidel! =1 20

21 SOR-Verfahren Schnellere Konvergenz durch Überrelaxation x = np.zeros((n,1)) while np.linalg.norm(b - x) > eps: for k in range(n): left = sum(a[k,0:k] * x[0:k,0]) right = sum(a[k,k+1:] * x[k+1:,0]) x_tmp = (b[k] - left - right)/a[k,k] x[k] = (1 - w) * x[k] + x_tmp * w return x 21

22 Übersicht Was ist der zugrundeliegende Algorithmus? Wann ist der Algorithmus anwendbar? Wie schnell ist der Algorithmus? Können wir weitere Verbesserungen vornehmen? 22

23 Mathematische Analyse Wir splitten die Matrix A = L + D + R strikte untere Dreiecksmatrix L Diagonale D strikte obere Dreiecksmatrix R D = 2 3 a a , L = 0 0 a nn a , R = a n1 a n a 12 a 1n 0 0 a 2n und schreiben Gauss-Seidel: Jacobi: (L + D) x i+1 + Rx i = b Dx i+1 +(L + R) x i = b 23

24 Gauss-Seidel-Iterationsschritt Gauss-Seidel (L + D) x i+1 + Rx i = b x i+1 =(L + D) 1 (b Rx i ) for k in range(n): left = sum(a[k,0:k] * x[0:k,0]) right = sum(a[k,k+1:] * x[k+1:,0]) x[k] = (b[k] - left - right) / a[k,k] Wichtig: (L + D) wird nicht wirklich invertiert! Stattdessen: Vorwärtssubstitution 24

25 Jacobi-Iterationsschritt Jacobi Dx i+1 +(L + R) x i = b x i+1 = D 1 (b (L + R) x i ) for k in range(n): x_new = np.zeros((n,1)) left = sum(a[k,0:k] * x[0:k,0]) right = sum(a[k,k+1:] * x[k+1:,0]) x_new[k] = (b[k] - left - right) / a[k,k] Keine Datenabhängigkeiten, es wird jeweils einfach durch das Diagonalelement geteilt 25

26 SOR-Iterationsschritt SOR ( 1! D + L)xi+1 +((1 1! )D + R) xi = b x i+1 =(D +!L) 1 (!b (!R +(! 1)D) x i ) for k in range(n): left = sum(a[k,0:k] * x[0:k,0]) right = sum(a[k,k+1:] * x[k+1:,0]) x_tmp = (b[k] - left - right)/a[k,k] x[k] = (1-w)*x[k] + x_tmp*w Fazit: Iterative Verfahren können elegant mathematisch modelliert werden 26

27 Allgemeine Splitting-Verfahren Allgemein Splitte A =  + E einfach invertierbare Matrix  Restmatrix E Iteration x i+1 =  1 (b Ex i ) Resultat: Fixpunkt-Iteration für für affine Abbildungen: (x) =Vx+ d wobei und V =  1 E d =  1 b 27

28 Fixpunkt-Iteration für affine Abbildungen: (x) =Vx+ d Dabei ist V eine n n Matrix und d ein n - Vektor Fragen: Wann konvergiert diese Folge? Gegen welchen Wert konvergiert sie? Wie schnell konvergiert sie? 28

29 Allgemeine Konvergenzanalyse Wann konvergiert die Folge x i+1 = Vx i + d? hinreichende Bedingung: V < 1 für irgendeine Operatornorm. ebenfalls hinreichende Bedingung: < 1 für alle Eigenwerte von V bzw. Spektralradius (V ) < 1 Konvergenz-Geschwindigkeit: linear (Banachscher Fixpunktsatz) x i x 0 = C (V ) i In der Praxis: Konvergenzgeschwindigkeit ist problemabhängig Nur für einfache Beispiele lässt sich der Spektralradius abschätzen 29

30 Konvergenzanalyse - Theorie Ob Jacobi-, Gauss-Seidel oder SOR-Verfahren konvergieren hängt somit vom Spektralradius der jeweiligen Iterationsmatrizen ab: Im Einzelnen mit A = L + D + R (V J ): V J = D 1 (L + R) (V GS ): V GS = (L + D) 1 R (V SOR ): V SOR = ( 1! D + L) 1 ((! 1)/!D + R) 30

31 Praktische Konvergenzkriterien Ist A strikt diagonaldominant, d.h. nx a i,i > a i,j 8i 2 1,...,n j=1 j6=i Dann konvergieren Gauss-Seidel, Jacobi und SOR- Verfahren (für 0 <! < 2 ) Ist A positiv definit (alle Eigenwerte positiv), dann konvergiert das SOR-Verfahren für 0 <! < 2 und damit auch das Gauss-Seidel Verfahren Ist sowohl A, als auch D 2A positiv definit, dann konvergiert auch das Jacobi-Verfahren 31

32 Konvergenzanalyse SOR-Verfahren Ist (!) der Spektralradius der Iterationsmatrix V SOR (!) des SOR-Verfahrens, so ist ein typischer Verlauf des Spektralradius ρ(ω) 1 ρ GS ρ opt 0 1 ω opt 2 ω 32

33 Diagonaldominanz und Unzerlegbarkeit Eine Matrix heißt schwach-diagonaldominant, wenn nx a i,i a i,j 8i 2 1,...,n Beispiele: j=1 j6=i Eine Matrix heißt unzerlegbar, wenn der Graph von A (Kanten für alle von Null verschiedenen Einträge) stark zusammenhängend ist, d.h. es gibt zwischen beliebigen Knoten einen durchgehenden Pfad

34 Wichtiges praktisches Konvergenzkriterium Wichtigstes praktisches Resultat: Ist A unzerlegbar und schwach-diagonaldominant, dann konvergieren Gauss-Seidel-, Jacobi- und SOR-Verfahren Schwache Diagonaldominanz ist typisch bei Modellen mit Erhaltungsgrößen (z.b. Energie, Masse, Impuls) Die wirkliche Welt ist unzerlegbar 34

35 Weitere Hinweise zur Konvergenz Bei SOR und Gauss-Seidel hängt das Ergebnis auch von der Reihenfolge der Unbekannten ab, bei Jacobi nicht Erfahrungsgemäß konvergiert das Gauss-Seidel-Verfahren etwa doppelt so schnell wie das Jacobi-Verfahren Splitting-Verfahren konvergieren nicht in jedem Fall, sondern nur für bestimmte Problemklassen Oft hängt der Spektralradius auch von der Größe des Gleichungssystems ab, d.h. je größer das Problem desto schlechter konvergieren diese Verfahren 35

36 Übersicht Was ist der zugrundeliegende Algorithmus? Wann ist der Algorithmus anwendbar? Wie schnell ist der Algorithmus? Können wir weitere Verbesserungen vornehmen? 36

37 Effizienz von iterativen Verfahren Beispiel: Diskretisierung der Poisson-Gleichung Kontinuierlich: u =0 Diskret: 4u i,j u i+1,j u i 1,j u i,j+1 u i,j 1 =0 u i,j+1 u i-1,j u i,j u i+1,j y j u i,j-1 x i 37

38 Modellproblem: Temperaturverteilung 4Das -1 resultierende -1-1 Gleichungssystem (ui+1,j + ui,j+1 + ui-1,j + ui,j-1 - u4ui,j)= 1,1 0 u 1,n u 2, u 2,n = u n,n 4u i,j u i+1,j u i 1,j u i,j+1 u i,j 1 =0 0 38

39 Modellproblem: Temperaturverteilung Achtung: Das (N + 1) (N + 1) Gitter U ist nicht Koeffizienten-Matrix! Die Werte im Innern des Gitters sind die Unbekannten! Matrix des Gleichungssystems hat Größe (N 1) 4! Rechte Seite enthält vorgegebene Randwerte und Temperaturquellen an den Gitterpunkten (dies ist eine Verallgemeinerung des Problems). Aufstellen der Matrix in geeignetem Sparse-Matrix-Format Alternativ (besser): Direkte (Matrix-freie) Implementierung eines iterativen Verfahrens 39

40 Modellproblem Matrixfreie Implementierung des SOR-Verfahrens def SOR(U, F, h, omega): for iy in range(1, m-1): for ix in range(1, n-1): U_tmp = (2*h*h * F[iy, ix] + U[iy-1, ix] + U[iy+1, ix] + U[iy, ix-1] + U[iy, ix+1]) * 0.25 U[iy, ix] = U[iy, ix]*(1-omega) + omega*u_tmp return U 40

41 Experimente zur Konvergenzgeschwindigkeit Gauss-Seidel vs. Jacobi Konvergenz in Abhängigkeit von h Relaxationsparameter U(x, y) = cos(2 x) cos(2 y) 41

42 Erkenntnisse Das Gauss-Seidel-Verfahren ist in etwa doppelt so schnell wie das Jacobi-Verfahren Beide benötigen etwa O(n) Iterationen Das SOR-Verfahren benötigt bei optimalem Relaxationsparameter nur O( p n) Iterationen Der optimale Relaxationsparameter wächst mit der Systemgröße Diese Aussagen gelten nicht generell, aber für viele ähnliche Probleme 42

43 Iterationen abschätzen In der Praxis ist es typisch, dass der Spektralradius von Iterationsmatrizen nahe 1 ist. Die Tendenz ist GS/J 1 n SOR 1 p n Fazit: Vorsicht bei sehr großen Gleichungssystemen! 43

44 Übersicht Was ist der zugrundeliegende Algorithmus? Wann ist der Algorithmus anwendbar? Wie schnell ist der Algorithmus? Können wir weitere Verbesserungen vornehmen? 44

45 Verbesserungen Unmittelbar anwendbare Techniken Durchlaufreihenfolge geschickt wählen Matrixfreie Implementierung Dynamische Anpassung des Relaxationsparameters Fortgeschrittene Techniken Mehrere Iterationen speichern und sinnvoll ausnutzen, führt zu Krylov-Unterraum-Verfahren, z.b. CG, GMRES Hierarchische Gleichungssysteme konstruieren um unterschiedliche Frequenzen jeweils Optimal zu behandeln -> Mehrgitterverfahren Kombinationen aus verschiedenen Verfahren, z.b. Systeme vorkonditionieren 45

46 Zusammenfassung Umformung von Ax = b über A = Â + E zu einem iterativen Verfahren x i+1 = Â 1 (b Ex i ) Allgemeine Form: (x) =Vx+ d Entscheidend für die lineare Konvergenz ist (V ) < 1 Faustregeln Gauss-Seidel konvergiert doppelt so schnell wie Jacobi Gauss-Seidel und Jacobi benötigen O(n) Iterationsschritte, SOR nur O( p n) (im Idealfall) Nur Jacobi ist einfach parallelisierbar 46

47 LGS : direkte Verfahren vs. iterative Verfahren In der Theorie: exakte Lösung vs. Näherungslösung Rundungsfehler vs. Iterationsfehler DV: Rundungsfehler pflanzen sich fort u.u. mit Verstärkung IV: Iterations- und Rundungsfehler werden abgeschwächt IV : schnell eine (grobe) Näherung, kann ggf. abbrechen. DV : erst am Ende kennt man die Lösung Oftmals genügt eine Näherungslösung Aufwand: voll besetzt : O(n 3 ) vs. O(n 3 ) bzw. O(n 2.5 ) dünn besetzt: O(n 2 ) vs. O(n 2 ) bzw. O(n 1.5 ) je größer die Matrix und je dünner sie besetzt ist, desto interessanter werden iterative Verfahren 47

48 48

49 Besser Python programmieren Die meisten Teilnehmer haben die Übungen sehr gut gemeistert Wir freuen uns auf Feedback -> Evaluation Dennoch gibt es einige kleine Tricks, wie man sich das Leben einfacher machen kann PS: Manche dieser Dinge sind sogar Prüfungsrelevant 49

50 Arrays und Listen Listen eindimensional (können aber verschachtelt werden) primitiver Python Datentyp, besondere Syntax keine Mathematische Bedeutung NumPy Arrays "Nur" eine Bibliothek Beliebig viele Dimensionen Automatisches Broadcasting mathematischer Operatoren Können als Matrix verwendet werden Effiziente Implementierung Müssen explizit angelegt werden 50

51 Arrays und Listen Bitte weniger solchen Code: res = [] for i in range(n): res.append(de_casteljau(p, P0)) P0 += d return np.array(res) Besser: res = np.zeros(n) for i in range(n): res[i] = de_casteljau(p, P0 + i * d) 51

52 Matrixmultiplikation Operator erlaubt es, Matrizen zu multiplizieren b - x A == R Genauer: Operator multipliziert zweidimensionale NumPy Arrays, als wären sie Matrizen 52

53 Indexnotation In Python können nicht nur einzelne Elemente eines Arrays, sondern auch ganze Zeilen, Spalten oder generelle Slices ausgewählt werden Diese Notation spart typischerweise mindestens eine for- Schleife und macht den Code damit lesbarer for k in range(n): left = sum(a[k,0:k] * x[k, 0:k]) right = sum(a[k,k+1:] * x[k,k+1:]) x[k] = (b[k] - left - right) / a[k,k] 53

54 Indexnotation (2) Mehrere eindimensionale Indices: A[5][6][7] Mehrdimensionale Indizierung: A[5,6,7] Vorteile letzterer Syntax: Performance Lesbarkeit geringere Fehleranfälligkeit Wichtige Features von Indizes: Start, (exklusives) Ende, Schrittweite Negative Indices greifen auf das Ende zu 54

55 Beispiel zur Indexnotation moire.py: Wählen Sie von einem gegebenen Bild nur die N-te Zeile und Spalte aus return image[::n, ::N] Außerdem: Man kann eine Jacobi-Iteration auf einem Rechteck in nur einer einzigen Zeile schreiben 55

56 Tupel, Listen, Arrays & Funktionsaufrufe Runde Klammern Funktionsaufruf: foo(x,y) Konstruieren Tupel: (5, 6, y) Klammern von Ausdrücken (5 + 6) (5) ist kein Tupel, (5,) schon Eckige Klammern Array, Tupel oder Listenindex: foo[x] Konstruieren Listen: [1, 2, 3, 4] Nicht verwirren lassen, z.b. bei ((2,3,4))[2] 56

57 Referenzsemantik In Python wird nie implizit kopiert Insbesondere NumPy Slices zeigen immer auf die ursprünglichen Daten Im Zweifel eine Kopie anlegen >>> A = np.array([2,3,4]) >>> B = A[:] >>> C = B[1:2] >>> C[0] = 5 >>> print(a) array([2,5,4]) 57

58 Krone für den langsamsten Code 2017 Berechnung von Primzahlen über Wilson's Theorem def is_prime(n): if n == 0 or n == 1: return False return (factorial(n-1)+1) % n == 0 Leider: Der Aufruf is_prime( ) terminiert nicht, oder ist SEHR ineffizient 58

59 Betrugsversuche Öffentliche Tests Unsere Tests Wir prüfen auf init, code u.ä. Wir haben zusätzliche Testfälle Wir prüfen verdächtige Funktionsaufrufe Unser Testsystem ist sehr gut gesichert Bleibt anständig! Wir erstellen die Übungen, um euch auf das Leben vorzubereiten, nicht um euch zu quälen. Wenn ihr mit einer Aufgabe unzufrieden seid, nutzt die Evaluation! 59