Author Archives: Andreas Krassnigg

FMCA-25 10: Machine Learning Grundlagen

Inhalt des Skriptums seit dem Sommersemester 2025

Hier finden Sie die Kapitel aus den Vergangenen Jahren (legacy):

Die Jupyter-Notebooks zur Legacy-Variante der Lehrveranstaltung finden Sie im zugehörigen GitHub-Repository.

10: Grundlagen des Machine-Learning¶

Willkommen zu einem der spannendsten und einflussreichsten Bereiche der modernen Informatik und Mathematik, dem Machine Learning! In dieser Lektion tauchen wir in die Welt der lernenden Algorithmen ein – Systeme, die aus Daten Muster erkennen, Vorhersagen treffen und Entscheidungen automatisieren können.

Machine Learning ist heute überall um uns herum: von Empfehlungssystemen bei Netflix und Spotify über Spracherkennung in Smartphones bis hin zu medizinischen Diagnosesystemen und autonomen Fahrzeugen. Die Fähigkeit, Maschinen das “Lernen” beizubringen, hat unsere Welt grundlegend verändert und wird dies auch weiterhin tun, und zwar in rasantem Tempo.

Aufbau auf vorherigen Inhalten¶

In dieser Einheit wird noch mehr als sonst deutlich, wie viel der bisherigen Algorithmen, Ideen und Konzepte aus den vorangegangenen Einheiten hier einfließen. Hier sind die wichtigsten:

Vektoren und Matrizen (Einheit 3): Ob Inputdaten, Outputdaten oder die Gewichte in künstlichen neuronalen Netzwerken: Hier arbeitet man zentral mit Vektoren, Matrizen und höherdimensionaleren Arrays
Arbeiten mit Daten (Einheit 5): Die Datenvorbereitung und -analyse ist fundamental für erfolgreiches Machine Learning und eigentlich das, wo am meisten Arbeit begraben wird, wenn es darum geht, das Modell noch besser zu machen
Graphen (Einheit 6): Die Netzwerk-Topologie in künstlichen neuronalen Netzwerken ist ein ausgezeichnetes Beispiel für die Relevanz eines guten Verständnisses von Graphen
Optimierung (Einheit 7): Machine Learning ist im Kern ein Optimierungsproblem, denn wir suchen die besten Parameter für unsere Modelle, und die werden optimiert, z.B. mittels Stochastic Gradient Descent

Nach dem Studium dieser Einheit sollten Sie zumindest folgende drei der wichtigsten Punkte hier verstehen:¶

Was Machine Learning ist und wie es funktioniert: Was bedeutet “Lernen” in diesem Kontext?
Die Unterschiede zwischen Supervised und Unsupervised Learning sowie deren Anwendungsgebiete
Warum Daten für Machine Learning so wichtig sind und worauf man achten muss

10.1 Einführung in das Machine-Learning (ML)¶

Bevor wir mit GPUs und künstlichen neuronalen Netzwerken auf irgendwelche Daten stürzen, müssen wir einiges an Begriffen klären. Keine Sorge, vieles davon kennen Sie bereits, es bekommt hier nur ein paar neue Bezeichnungen oder Namen.

10.1.1 Grundbegriffe: Wie und was lernt eine Maschine?¶

Machine Learning ist ein Teilbereich der Künstlichen Intelligenz (KI), bei dem Computer-Algorithmen entwickelt werden, die automatisch aus Erfahrungen lernen und sich verbessern können, ohne explizit für jede spezifische Aufgabe programmiert zu werden. Den Unterschied zur traditionellen Programmierung könnte man dabei ganz kurz wie folgt zusammenfassen:

Traditionelle Programmierung: Input + Programm → Output
Machine Learning: Input (+ Output) → Programm (Modell) → Vorhersage/Analyse

Bei der traditionellen Programmierung schreiben wir explizite Regeln und Anweisungen. Beim Machine Learning hingegen zeigen wir dem Computer Beispiele (z.B. Input-Output-Paare beim Supervised Learning) und lassen ihn die zugrundeliegenden Muster und Regeln selbst erkennen. Die Maschine lernt dabei im Wesentlichen eine Funktion $f$, die im einfachsten Fall Eingaben (Input) auf Ausgaben (Output) abbildet:

$$f: X \rightarrow Y$$

Dabei kann es sich um verschiedene Arten von Funktionen handeln:

Klassifikation: Zuordnung von Objekten (Inputs) zu Output-Kategorien (z.B. Erkennung von Spam vs. Nicht-Spam)
Regression: Vorhersage von kontinuierlichen Werten (z.B. Immobilienpreise auf der Basis von Lage, qm, Zimmer, etc.)
Clustering: Gruppierung ähnlicher Objekte ohne vorgegebene Kategorien und ohne vorgegebene Outputs

Der Lernprozess geht dabei normalerweise etwa folgendermaßen vor sich: Aus Rohdaten wird ein bereinigter und gut strukturierter Datensatz erzeugt, der für das Machine-Learning verwendet werden soll. Je nach Problemstellung wird dann ein ML-Modell “trainiert” (wie genau, das sehen wir weiter unten). Das Modell wird nach Abschluss des Trainings bzw. schon währenddessen in regelmäßigen Abständen verschiedenen Tests und Evaluierungen unterzogen, um zu sehen, wie gut es die Daten bereits beschreibt, und ob es idealerweise generalisieren kann (auch dazu kommen wir unten noch genauer).

10.1.2 Die Rolle von Daten im Machine-Learning¶

Im Machine Learning sind Daten das Fundament des Lernprozesses. Ohne qualitativ hochwertige und ausreichende Daten kann selbst der beste Algorithmus nicht erfolgreich sein. Der Ausspruch “Garbage in, garbage out” gilt hier besonders. Verschiedene Aspekte von Daten sind hier wichtig, insbesondere die Rollen, die verschiedene Teile der verewndeten Daten spielen.

Zunächst: Features sind die Eingangsvariablen oder Attribute, die zur Beschreibung jener Objekte verwendet werden, die die Daten repräsentieren. Sie sind die “Bausteine”, aus denen ein ML-Algorithmus lernt. Typische Beispiele für Features sind folgende Variablen, aber der Fantasie sind hier keine Grenzen gesetzt:

Bei der Hauspreisvorhersage: Größe, Lage, Anzahl Zimmer, Baujahr
Bei der Spam-Erkennung: Anzahl bestimmter Wörter, Absender-Domain, E-Mail-Länge
Bei der Bilderkennung: Pixelwerte, Farben, Formen, Texturen

Am anderen Ende des Lern-Algorithmus stehen die Labels. Diese sind die Ausgangsvariablen oder Zielwerte, die vorhergesagt werden sollen. Sie sind nur beim Supervised Learning bekannt. Beispiele für mögliche Labels für die gerade beschriebenen Inputs/Features könnten folgende Werte sein:

Hauspreise (kontinuierlicher Wert)
Spam/Nicht-Spam (kategorisch)
Krankheitsdiagnose (kategorisch)

Um Daten genauer zu beschreiben, unterscheidet man die folgenden Typen und Eigenschaften:

Numerische Daten:
- Kontinuierlich: Können jeden Wert in einem Bereich annehmen (z.B. Temperatur, Gewicht)
- Diskret: Nur bestimmte Werte möglich (z.B. Anzahl Kinder, Würfelaugen)
Kategorische Daten:
- Nominal: Keine natürliche Reihenfolge (z.B. Farben, Länder)
- Ordinal: Mit natürlicher Reihenfolge (z.B. Schulnoten, Größenkategorien)
Zeitreihendaten: Daten mit zeitlicher Komponente
Textdaten: Unstrukturierte Textinformationen (z.B. Email-Inhalt)
Bild- und Multimediadaten: Pixelwerte, Audio-Signale, Videos

Wenn man ein Bisschen über diese Typen nachdenkt, stellt man fest, dass es meist möglich ist, bestimmte Typen in andere umzuwandeln, sollte das aus irgendeinem Grund nötig sein. Z.B. kann man Kategorien erzeugen/definieren, indem man kontinuierliche Zahlenwerte in Intervalle einteilt.

Abseits der Daten, die in ein Modell während des Trainings gefüttert werden, gibt es noch weitere Parameter, die an dieser Stelle erwähnt werden sollen. Während alle Parameter in einem ML-Modell durch das Training an optimale Werte angepasst werden (diese sind die sogenannten “freien” Parameter, von denen auch immer die Rede ist, wenn man z.B. hört, wie “groß” ein bestimmtes Modell ist), gibt es noch vorab fixierte Parameter, die zwar eingestellt werden können, um das Modell zu verbessern, aber nicht während eines Trainingsruns selbst.

Diese nennt man Hyperparameter und meint damit Konfigurationseinstellungen des Lernalgorithmus, die also vor dem Training festgelegt werden. Typische Beispiele für Hyperparameter sind:

Lernrate bei Gradient Descent
Anzahl der Cluster bei K-Means (siehe unten)
Tiefe eines Entscheidungsbaums (siehe unten)
Anzahl der Neuronen bzw. die genaue Netzwerktopologie in einem neuronalen Netzwerk

Im folgenden werden wir uns zunächst einen Überblick über verschiedene Arten des Machine-Learnings verschaffen, und danach werden wir sehen, wie Daten bei den einzelnen Zugängen zum Einsatz kommen.

10.1.3 Supervised Learning im Kurzüberblick¶

Zunächst zum einfachen Grundprinzip: Supervised Learning (überwachtes Lernen) ist wie Lernen mit eineR LehrerIn. Der Algorithmus erhält gelabelte Trainingsdaten, das heißt, sowohl die Eingaben (Features) als auch die korrekten Ausgaben (Labels) sind bekannt. Die Hoffnung ist, ein Modell zu trainieren, das diese Zusammenhänge möglichst korrekt, aber auch mit der Fähigkeit zu generalisieren, lernen kann. Der Lernprozess läuft dabe folgendermaßen ab:

Training: Der Algorithmus lernt aus gelabelten Beispielen, indem die Modellparameter aus dem jeweils gemachten Fehler heraus angepasst werden.
Validation: Laufende Überprüfung der Leistung auf separaten Validierungsdaten, bereits während das Training läuft. Dies dient hauptsächlich dazu, das schlichte Auswendiglernen der Trainingsdaten durch das Modell zu verhindern.
Testing: Finale Bewertung nach beendetem Training auf völlig ungesehenen Testdaten (der Moment der Wahrheit).
Anwendung: Vorhersagen auf neue, ungelabelte Daten, also der Einsatz des Modells für den geplanten Zweck.

Wie bereits kurz angeklungen, unterscheidet man im wesentlichen zwei Ziele des Trainings: Klassifikation und Regression. Bei der Klassifikation wird versucht, Objekte diskreten Kategorien oder Klassen korrekt zuzuordnen. Man unterscheidet hier weiter zwischen binärer Klassifikation (Spam/Nicht-Spam, Krank/Gesund, etc.) und Mehrklassen-Klassifikation (Handschriftenerkennung der Ziffern 0-9, Bildkategorisierung, etc.).

Einige interessante Klassifikationsalgorithmen sind z.B.:

Entscheidungsbäume
Support Vector Machines (SVM)
Naive Bayes
k-Nearest Neighbors (k-NN)
Logistische Regression

Im Prinzip kann man am Ende jedes ML-Modells eine Einheit einbauen, die Kategorien als Vorhersage ausgibt.

Bei der Regression hingegen wird versucht, kontinuierliche numerische Werte möglichst genau vorherzusagen. Regression lässt sich überall anwenden, wo man solche kontinuierlichen Zielwerte hat. Alle ML-Modelle können wiederum einen kontinuierlichen Output hervorbringen, wenn sie entsprechend angepasst werden.

10.1.4 Unsupervised Learning im Kurzüberblick¶

Unsupervised Learning (unüberwachtes Lernen) ist wie Lernen, aber diesmal ohne LehrerIn. Der Algorithmus erhält nur die Eingabedaten ohne korrekte Antworten und muss selbstständig versteckte Muster und Strukturen in den Daten entdecken. Mögliche Ziele für Unsupervised Learning sind daher an diese Herausforderung angepasst, z.B.:

Mustererkennung: Identifikation wiederkehrender Strukturen
Datenexploration: Verstehen der Datenverteilung und -struktur
Dimensionsreduktion: Vereinfachung komplexer Datenräume
Feature Learning: Automatische Erkennung relevanter Merkmale in den Eingabedaten

Eine spezielle Form des Unsupervised Learning ist das Clustering. Es teilt Daten in Gruppen oder Cluster ein, wobei Objekte innerhalb eines Clusters ähnlicher sind (bzw. sein sollten) als Objekte verschiedener Cluster. So etwas ist z.B. im Kundensegmentierung im Marketing oder für Genanalysen in der Bioinformatik interessant.

Beim Clustering kommen verschiedene Algorithmen zum Einsatz, je nach der Art der Daten und der Zielsetzung:

K-Means: Partitioniert die Daten in eine vorgegebene Zahl von Clustern, indem ähnliche Eigenschaften iterativ zusammengefasst werden.
Hierarchisches Clustering: Baut eine Hierarchie von Clustern aus den Daten zusammen und verwendet dafür der Reihe nach ein Maß für die Ähnlichkeit zwischen einzelnen Datenpunkten.
DBSCAN: Dichtebasierte Clustering-Methode, die sich lokal von einem Punkt zum nächsten weiter durch den Datensatz vorarbeitet, bis alle ähnlichen Datenpunkte gruppiert sind. Kann gut mit Ausreißern umgehen.

Eine weitere spezielle Art des Unsupervised Learning ist die Anomaly Detection. Dabei identifiziert man ungewöhnliche oder verdächtige Datenpunkte, die nicht dem normalen Muster entsprechen. Das kann so einfach sein, wie Punkte außerhalb von $2\sigma$ einer Gaußverteilung zu markieren. Typische Anwendungsmöglichkeiten sind:

Betrugserkennung im Finanzwesen
Netzwerksicherheit (Intrusion Detection)
Qualitätskontrolle in der Produktion
Medizinische Diagnose

Insgesamt ist Unsupervised Learning also sehr vielfältig, obwohl man aufgrund der fehlenden Labels vom Gegenteil ausgehen könnte.

10.1.5 Andere Paradigmen für Machine Learning¶

Supervised und Unsupervised Learning sind zwar die grundlegenden Ausprägungen von Machine-Learning, es gibt aber noch weitere interessante Varianten. Die wichtigsten davon besprechen wir hier kurz.

Beim Reinforcement Learning (Verstärkenden Lernen) lernt ein Agent durch Trial-and-Error mit Belohnungen und Bestrafungen. Der Agent interagiert dabei mit einer Umgebung und lernt durch Feedback, welche Aktionen zu positiven Ergebnissen führen. Das Feedback kann unmittelbar sein, aber auch erst nach langer Zeit bekannt werden (wie z.B. am Ende einer Partie eines Strategiespiels wie Schach oder Go). Wichtig zu verstehen sind hier folgende Begriffe:

Agent: Das lernende System bzw. ML-Modell in diesem Fall
Environment: Die Umgebung, in der der Agent agiert, sie muss grundsätzlich bekannt, wahrnehmbar oder simulierbar sein.
State: Aktueller Zustand der Umgebung
Actions: Mögliche Handlungen des Agenten, sind je nach Spiel- oder Simulationsprinzip sehr unterschiedlich, aber grundsätzlich vorgegeben, denn sie sind als mögliche Outputs des ML-Modells (Agenten) vorab implementiert.
Reward: Belohnung oder Bestrafung für eine Aktion bzw. für ein Simulations-/Spielergebnis, die dann rückwärts durch alle Schritte propagiert wird.

Bekannte Anwendungen oder Beispiele sind AlphaGo bzw. AlphaZero für die Welt der Strategiespiele, aber auch in der Robotik und dem autonomen Fahren (bzw. extremeren Formen der autonomen Bewegung wie Fliegen) kommt Reinforcement Learning, hauptsächlich in simulierten Umgebungen, zum Einsatz.

Als nächstes ist Bayesian Inference eine Erwähnung wert. Sie basiert auf dem Satz von Bayes und berücksichtigt Unsicherheiten in den Vorhersagen durch Wahrscheinlichkeitsverteilungen. Hier macht das ML-Modell nicht unbedingt aus klaren Inputs auch eindeutige Outputs, sondern der Input ist eine Prior Distribution, in der vorab-Annahmen über die Parameter stecken. Der Output des Modells entspricht dann einer Posterior Distribution, die einer aktualisierten Erwartung an das betrachtete System nach “Beobachtung” eines (Trainings-)Datensatzes entspricht.

Konkrete Vorteile dieser Art von Machine Learning sind die Quantifizierung von Unsicherheit, die im System bzw. den Daten vorkommt, die Möglichkeit, Vorwissen zu berücksichtigen (und zwar über die Prior Distribution), sowie eine gewisse Robustheit, wenn man nur wenige Trainigsdaten zur Verfügung hat.

Analogiebasiertes Lernen schließlich nutzt Ähnlichkeiten zwischen bekannten und neuen Problemen, um Lösungsstrategien zu übertragen. Das Grundprinzip dabei ist die Identifikation struktureller Ähnlichkeiten, auf deren Basis man dann Lösungsmuster auf neue Bereiche übertragen und anpassen kann. Transfer Learning kann man als so ein Beispiel bezeichnen, obwohl der Ansatz viel allgemeiner einsetzbar ist.

Und hier ganz zum Schluss noch ein paar weitere Begriffe in diesem Zusammenhang:

Semi-Supervised Learning: Die verfügbaren Daten sind eine Kombination aus gelabelten und ungelabelten Daten
Self-Supervised Learning: Lernen von Repräsentationen, die beim Lernen aus den Daten selbst entstehen
Few-Shot Learning: Lernen mit sehr wenigen Beispielen
Meta-Learning: “Lernen zu lernen”

Insgesamt ist Machine Learning ein faszinierendes und sich schnell entwickelndes Feld, das unser Verständnis von Intelligenz und Automatisierung revolutioniert. Die verschiedenen Paradigmen bieten unterschiedliche Ansätze für verschiedene Arten von Problemen, und oft werden mehrere Techniken kombiniert, um optimale Ergebnisse zu erzielen.

10.2 Supervised Learning¶

Nachdem wir uns einen Überblick über die verschiedenen Machine Learning Paradigmen verschafft haben, tauchen wir nun tiefer in das Supervised Learning ein – den Bereich des Machine Learning, der in der Praxis am häufigsten angewendet wird und die besten Ergebnisse liefert, wenn gelabelte Trainingsdaten verfügbar sind.

10.2.1 Datenvorbereitung¶

Die Datenvorbereitung (Data Preprocessing) ist oft der zeitaufwändigste und kritischste Schritt im gesamten Machine Learning Prozess. Erfahrene Data Scientists verbringen typischerweise den Löwenanteil ihrer Zeit mit der Datenvorbereitung. Der Grund ist einfach: Selbst der beste Algorithmus kann keine guten Ergebnisse liefern, wenn die Eingangsdaten schlecht aufbereitet sind.

Was genau man jetzt mit “schlecht aufbereiteten Daten” meint, kann verschieden sein, je nach Ursache. Hier sind die wichtigsten Schritte der Datenvorbereitung, die dafür sorgen sollen, dass alles astrein ist (einiges davon kennen Sie bereits aus unserer Einheit zur Arbeit mit Daten):

1. Datensammlung und -import Klingt alles logisch, ist es auch:

Zusammenführung von Daten aus verschiedenen Quellen
Handling verschiedener Dateiformate (CSV, JSON, Datenbanken)
Überprüfung der Datenintegrität und -vollständigkeit

2. Explorative Datenanalyse (EDA)

Verstehen der Datenstruktur und -verteilungen
Identifikation von Mustern und Anomalien
Visualisierung der Daten zur ersten Einschätzung Hier verschwimmt übrigens auch die Grenze zum Unsupervised Machine Learning etwas.

3. Behandlung fehlender Werte (Missing Values) Hier kann man verschieden vorgehen, um am Ende einen vollständigen Datensatz ohne Lücken zu erhalten:

Entfernen: Löschen von Zeilen/Spalten mit zu vielen fehlenden Werten
Imputation: Ersetzen durch Mittelwert, Median, Modus oder etwas ausgefeiltere Methoden
Prediction: Vorhersage fehlender Werte basierend auf anderen Features

4. Behandlung von Ausreißern (Outliers) Ausreißer gehören im Prinzip zu jedem Datensatz dazu. Manchmal sind sie sogar die interessanten Elemente. Daher kann man die folgenden Schritte setzen oder auch nicht, je nach Zweck der Daten.

Identifikation: Durch statistische Methoden oder Visualisierung
Entscheidung: Entfernen, transformieren oder beibehalten
Domain Knowledge: Berücksichtigung fachspezifischen Wissens

5. Feature Engineering Hier beginnt man bereits, den Datensatz aktiv zu verändern oder zu erweitern. War mal eine Kunst, ist aber in Zeiten des Deep Learning nicht mehr unbedingt nötig.

Feature Creation: Ableitung neuer Features aus bestehenden
Feature Selection: Auswahl der relevantesten Features
Feature Transformation: Mathematische Transformationen (log, sqrt, etc.)

6. Encoding kategorischer Variablen Encoding ist, vor allem für moderne ML-Modelle wie auch LLMs gängige Praxis geworden. Diese mathematische Formulierung egal welcher Daten hilft kräftig dabei, die Daten in gängige ML-Modelle einspeisen zu können.

One-Hot Encoding: Umwandlung nominaler Kategorien in binäre Features (also de facto in Vektoren mit Nullen und einer Eins)
Label Encoding: Numerische Kodierung ordinaler Kategorien
Target Encoding: Kodierung basierend auf der Zielvariable

7. Skalierung und Normalisierung Hilft, wie bereits bei der Optimierung erwähnt, dabei, in mehrdimensionalen Problemen Features mit verschiedenen Skalen vergleichbar zu machen.

Min-Max Scaling: Skalierung auf einen bestimmten Bereich (z.B. 0-1)
Standard Scaling: Mittelwert 0, Standardabweichung 1
Robust Scaling: Weniger anfällig für Ausreißer

8. Aufteilung der Daten Das ist beim Supervised Learning unerlässlich und wird von vornherein von allen gängigen Software-Lösungen unterstützt. Üblich ist Train-Validation-Test-Aufteilung. Die Teile werden wie folgt verwendet:

Training Set: Zum Trainieren des Modells (typisch 60-70%)
Validation Set: Zur Validierung bzw. für Hyperparametertuning und Modellauswahl (typisch 15-20%)
Test Set: Zur finalen Evaluation (typisch 15-20%) Wichtig ist hier, dass die Aufteilung ausgewogen erfolgt, d.h. es sollten von allen Kategorien aliquote Anteile in Train, Validation und Test landen. Man verteilt die Daten üblicherweise zufällig, was bereits ein guter Ansatz ist, aber bei Klassen mit sehr wenigen Elementen nicht ausreicht – in solchen Fällen muss man auf diese Minderheiten besonderes Augenmerk legen.

10.2.2 Der typische Trainingszyklus beim Supervised Learning: Training, Validation, Testing, Evaluation¶

Der Supervised Learning Lern-Prozess folgt einem strukturierten Zyklus, der systematisches Experimentieren und kontinuierliche Verbesserung ermöglicht. Manchmal wird die Validierung etwas nachlässig behandelt, davon ist aber abzuraten.

Phase 1: Training (Lernen), idealerweise bereits gekoppelt mit Validation

In der Trainingsphase lernt das Modell aus den gelabelten Trainingsdaten. Dabei passiert folgendes: Die freien Parameter des Modells werden angepasst, indem die Features (X_train) in das Modell geschickt werden und die Ergebnisse des forward pass durch das Modell mit den tatsächichen zugehörigen Labels (y_train) verglichen werden. Dieser Vergleich passiert mit Hilfe einer sogenannten Kosten-Funktion bzw. Loss-Funktion, und ja, das entspricht genau dem Prinzip einer Zielfunktion bei der Optimierung (denn das passiert hier ja auch).

Die Optimierung betrifft hier die freien Modellparameter, die so lange angepasst werden, bis man “zufrieden” ist. Dazu beobachtet man den Wert der Kosten-Funktion, der sich im Allgemeinen während des Trainings verringert. Genauer gesagt berechnet man diesen Funktionswert auf den Trainingsdaten und zusätzlich auf den Validation-Daten, die nicht zum Lernen verwendet werden. Auf diese Weise sieht man, wenn das Modell beginnt, den Trainingsdatensatz “auswendig” zu lernen und die Validierungsdaten nicht so gut wiederzugeben wie die Trainingsdaten. An dieser Stelle ist es Zeit, das Training abzubrechen.

Wichtige Konzepte beim Training:

Epochen: Anzahl der Durchläufe des Optimierungsalgorithmus durch den gesamten Trainingsdatensatz
Batch Size: Die Anzahl der Datenpunkte aus dem Datensatz, die gleichzeitig vom Modell verarbeitet werden. Größere Batch-Sizes brauchen mehr Speicher, kleinere mehr Zeit.
Learning Rate: Die Schrittgröße bei der Parameteranpassung, das kennen wir bereits vom Gradient-Descent Algorithmus

Die gleichzeitig mit dem Training laufende Validierung dient zunächst der Entscheidung, wann der Trainingsrun gestoppt wird. Sie dient aber dadurch auch der Modellauswahl und Hyperparameter-Optimierung, denn bei verschiedenen Hyperparameter-Werten kann (und wird) das Training unterschiedlich effektiv sein. So können sich verschiedene Runs z.B. in der erreichten Genauigkeit auf dem Validierungsdatensatz oder in ihrer Fähigkeit zu generalisieren unterscheiden.

Phase 2: Testing (Testen)

Nach abgeschlossenem Training mit Validation liefert der Test eine unvoreingenommene Schätzung der Modellleistung, denn die dafür verwendeten Daten sind ja sowohl von Training als auch von Validation verschieden. Dabei kann man nun verschiedene Modelle hinsichtlich ihrer Leisung auf komplett neuen Daten vergleichen. Man sollte allerdings die Testdaten nicht für Modellauswahl oder Hyperparameter-Tuning verwenden! Beim Test wird insbesondere wieder die Kostenfunktion berechnet und mit den Werten von Training und Validation verglichen.

Phase 3: Evaluation (Bewertung)

Die Evaluation beurteilt schließlich die Qualität des Modells anhand verschiedener Metriken, die über die doch etwas unintuitive Kostenfunktion hinausgehen:

Für Klassifikation:

Accuracy: Anteil korrekter Vorhersagen
Precision: Anteil der als zur Zielkategorie gehörig vorhergesagten Datenpunkte, die tatsächlich der Zielkategorie angehören
Recall: Anteil der Datenpunkte aus der Zielkategorie, die auch als solche vorhergesagt wurden
F1-Score: Harmonisches Mittel aus Precision und Recall
Confusion Matrix: Detaillierte Aufschlüsselung aller Vorhersagekombinationen (false/true positives/negatives)

Für Regression:

Mean Absolute Error (MAE): Durchschnittlicher absoluter Fehler
Mean Squared Error (MSE): Durchschnittlicher quadratischer Fehler
Root Mean Squared Error (RMSE): Quadratwurzel des MSE

Der iterative Verbesserungszyklus führt dann insgesamt wiederholt über alle Phasen, so lange bis man zufrieden ist oder das gesamte Projektbudget aufgebraucht ist.

10.2.3 Machine-Learning als Optimierungsproblem¶

An dieser Stelle möchte ich nocheinmal erwähnen, dass Machine-Learning generell ein Optimierungsproblem ist. Das wird beim Supervised Learning unmittelbar deutlich, wenn man einen Label mit Modell-Ergebnissen vergleichen kann und daraus eine Richtung für die Optimierung der Modellparameter berechnet wird. Aber auch sonst folgt ML grundsätzlich dem Prinzip der Optimierung. Die konkrete Aufgabenstellung ist dann im Allgemeinen nur noch, etwas (eine konkrete Funktion) zu finden, die man optimieren kann.

10.2.4 Beispiel: Trainieren eines Entscheidungsbaums¶

Nach all dieser grauen Theorie wollen wir uns nun endlich einem Beispiel zuwenden. Dazu bietet sich ein Entscheidungsbaum als ML-Modell an, weil man hier intuitiv nachvollziehen kann, was im Modell passiert und wie das Ergebnis zu interpretieren ist. Entscheidungsbäume sind also intuitive und interpretierbare Modelle, die Entscheidungen durch eine Folge von Ja/Nein-Fragen treffen. Sie eignen sich sowohl für Klassifikation als auch für Regression.

Die Struktur eines Entscheidungsbaums sieht im Ganzen tatsächlich aus wie ein Baum. Dabei gibt es folgende Begriffe zu beachten:

Root Node: Wurzelknoten mit der ersten Entscheidung
Internal Nodes: Innere Knoten mit weiteren Entscheidungskriterien
Leaf Nodes: Blätter mit den finalen Vorhersagen
Branches: Äste, die die Entscheidungswege repräsentieren

Um Overfitting (das Auswendiglernen der Trainingsdaten) zu vermeiden, kann man verschiedene Hyperparameter einschränken. Am wichtigsten ist dabei aber die maximale Tiefe (also Maximallänge der Äste) des Baumes. Wir lassen uns unseren Entscheidungsbaum samt Datensatz und Lernen mit der Package Scikit-Learn von Gemini 2.5 Pro zusammenbauen, so wie auch die anderen Codebeispiele dieser Einheit.

In [2]:

# prevent library-related crashes
import os
os.environ['MKL_NUM_THREADS'] = '1'
os.environ['NUMEXPR_NUM_THREADS'] = '1'
os.environ['OMP_NUM_THREADS'] = '1'

# standard imports
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.datasets import make_moons
from sklearn.model_selection import train_test_split
from sklearn.tree import DecisionTreeClassifier, plot_tree
from sklearn.metrics import accuracy_score, classification_report

# --- 1. Generate a Suitable Dataset ---
# make_moons is great for visualizing decision boundaries.
n_samples_total = 1000 # Generate more samples
X_sample, y_sample = make_moons(n_samples=n_samples_total, noise=0.25, random_state=42)

feature_names = ["Feature 1", "Feature 2"]
target_names = ["Class 0", "Class 1"]

# --- 2. Split Data into Train, Validation, and Test Sets ---
# First, split into training + validation (80%) and test (20%)
X_train_val, X_test, y_train_val, y_test = train_test_split(
    X_sample, y_sample, test_size=0.2, random_state=42, stratify=y_sample
)

# Then, split training + validation into training (60% of original) and validation (20% of original)
X_train, X_val, y_train, y_val = train_test_split(
    X_train_val, y_train_val, test_size=0.25, random_state=42, stratify=y_train_val # 0.25 * 0.8 = 0.2
)

print(f"Total generated samples: {X_sample.shape[0]}")
print(f"Training set shape: {X_train.shape}")
print(f"Validation set shape: {X_val.shape}")
print(f"Test set shape: {X_test.shape}")

# --- 3. Visualize the Data Splits ---
plt.figure(figsize=(18, 5))

plt.subplot(1, 3, 1)
scatter_train = plt.scatter(X_train[:, 0], X_train[:, 1], c=y_train, cmap='viridis', edgecolor='k', s=50, alpha=0.7)
plt.title(f"Training Data ({len(X_train)} samples)")
plt.xlabel(feature_names[0])
plt.ylabel(feature_names[1])
plt.legend(handles=scatter_train.legend_elements()[0], labels=list(target_names))
plt.grid(True)

plt.subplot(1, 3, 2)
scatter_val = plt.scatter(X_val[:, 0], X_val[:, 1], c=y_val, cmap='viridis', edgecolor='k', s=50, alpha=0.7)
plt.title(f"Validation Data ({len(X_val)} samples)")
plt.xlabel(feature_names[0])
plt.ylabel(feature_names[1])
plt.legend(handles=scatter_val.legend_elements()[0], labels=list(target_names))
plt.grid(True)

plt.subplot(1, 3, 3)
scatter_test = plt.scatter(X_test[:, 0], X_test[:, 1], c=y_test, cmap='viridis', edgecolor='k', s=50, alpha=0.7)
plt.title(f"Test Data ({len(X_test)} samples)")
plt.xlabel(feature_names[0])
plt.ylabel(feature_names[1])
plt.legend(handles=scatter_test.legend_elements()[0], labels=list(target_names))
plt.grid(True)

plt.tight_layout()
plt.show()

# --- 4. Set up Decision Tree, Train, and Display Accuracy vs. Max Depth ---
max_depths = range(1, 16) # Explore depths, can go deeper for more complex data
train_accuracies = []
val_accuracies = []

for depth_iter in max_depths: # Renamed to avoid conflict
    dt_classifier_iter = DecisionTreeClassifier(max_depth=depth_iter, random_state=42)
    dt_classifier_iter.fit(X_train, y_train)

    y_train_pred_iter = dt_classifier_iter.predict(X_train)
    train_accuracies.append(accuracy_score(y_train, y_train_pred_iter))

    y_val_pred_iter = dt_classifier_iter.predict(X_val)
    val_accuracies.append(accuracy_score(y_val, y_val_pred_iter))

plt.figure(figsize=(10, 6))
plt.plot(max_depths, train_accuracies, 'o-', label='Training Accuracy')
plt.plot(max_depths, val_accuracies, 's-', label='Validation Accuracy')
plt.xlabel("Max Depth of Tree")
plt.ylabel("Accuracy")
plt.title("Training and Validation Accuracy vs. Max Tree Depth")
plt.legend()
plt.grid(True)
plt.xticks(max_depths)
plt.show()

# Choose a max_depth based on the plot. Let's pick one that is reasonably good but not too overfit.
# And another one that is clearly deeper.
chosen_max_depth = 4 # Adjusted based on typical make_moons behavior
dt_classifier = DecisionTreeClassifier(max_depth=chosen_max_depth, random_state=42)
dt_classifier.fit(X_train, y_train)
print(f"\n--- Initial Decision Tree (max_depth={chosen_max_depth}) ---")

# --- 5. Show Predictions Compared to Labels with Decision Boundaries ---

def plot_decision_boundary_and_predictions(clf, X_data, y_data, y_pred_data, title, ax):
    # Create a mesh to plot the decision boundary
    x_min, x_max = X_data[:, 0].min() - 0.5, X_data[:, 0].max() + 0.5
    y_min, y_max = X_data[:, 1].min() - 0.5, X_data[:, 1].max() + 0.5
    xx, yy = np.meshgrid(np.arange(x_min, x_max, 0.02),
                         np.arange(y_min, y_max, 0.02))
    Z = clf.predict(np.c_[xx.ravel(), yy.ravel()])
    Z = Z.reshape(xx.shape)
    ax.contourf(xx, yy, Z, alpha=0.3, cmap='viridis')

    # Plot correctly classified points
    correct_mask = (y_pred_data == y_data)
    ax.scatter(X_data[correct_mask, 0], X_data[correct_mask, 1],
               c=y_data[correct_mask], cmap='viridis', marker='o',
               edgecolor='black', s=50, label='Correctly Classified', alpha=0.9)

    # Plot misclassified points
    ax.scatter(X_data[~correct_mask, 0], X_data[~correct_mask, 1],
               c=y_data[~correct_mask], cmap='viridis', marker='o', # Same marker
               edgecolor='red', linewidth=2, s=70, label='Misclassified', alpha=0.9) # Red border for incorrect

    ax.set_title(f"{title} (Accuracy: {accuracy_score(y_data, y_pred_data):.2f})")
    ax.set_xlabel(feature_names[0])
    ax.set_ylabel(feature_names[1])
    # Create custom legend handles if needed, or rely on labels
    handles, labels = ax.get_legend_handles_labels()
    # Filter out duplicate labels for a cleaner legend (if contourf adds one)
    # For this specific scatter setup, standard legend should be fine.
    ax.legend(loc='lower left') # Adjust legend position
    ax.grid(True, linestyle='--', alpha=0.7)


y_train_pred = dt_classifier.predict(X_train)
y_val_pred = dt_classifier.predict(X_val)
y_test_pred = dt_classifier.predict(X_test)

fig, axes = plt.subplots(1, 3, figsize=(24, 7)) # Increased figure size for better boundary plots
plot_decision_boundary_and_predictions(dt_classifier, X_train, y_train, y_train_pred, "Training Set", axes[0])
plot_decision_boundary_and_predictions(dt_classifier, X_val, y_val, y_val_pred, "Validation Set", axes[1])
plot_decision_boundary_and_predictions(dt_classifier, X_test, y_test, y_test_pred, "Test Set", axes[2])
plt.tight_layout()
plt.show()


# --- 6. Visualize the Resulting Decision Tree ---
plt.figure(figsize=(18, 12)) # Adjust size as needed
plot_tree(dt_classifier,
          filled=True,
          rounded=True,
          class_names=list(target_names),
          feature_names=list(feature_names),
          fontsize=10)
plt.title(f"Decision Tree Visualization (max_depth={chosen_max_depth})")
plt.show()

print("\nEvaluation Metrics for Initial Tree (max_depth=", chosen_max_depth, ") on Test Set:")
print(classification_report(y_test, y_test_pred, target_names=list(target_names)))

# --- 7. Train with a Deeper Tree and Compare ---
deeper_max_depth = 10 # Adjusted for make_moons, can lead to clear overfitting
dt_classifier_deep = DecisionTreeClassifier(max_depth=deeper_max_depth, random_state=42)
dt_classifier_deep.fit(X_train, y_train)
print(f"\n--- Deeper Decision Tree (max_depth={deeper_max_depth}) ---")

y_train_pred_deep = dt_classifier_deep.predict(X_train) # For visualization
y_val_pred_deep = dt_classifier_deep.predict(X_val)     # For visualization
y_test_pred_deep = dt_classifier_deep.predict(X_test)   # For metrics

# Visualize predictions for the deeper tree
fig, axes_deep = plt.subplots(1, 3, figsize=(24, 7))
plot_decision_boundary_and_predictions(dt_classifier_deep, X_train, y_train, y_train_pred_deep, f"Deeper Tree (d={deeper_max_depth}) - Training", axes_deep[0])
plot_decision_boundary_and_predictions(dt_classifier_deep, X_val, y_val, y_val_pred_deep, f"Deeper Tree (d={deeper_max_depth}) - Validation", axes_deep[1])
plot_decision_boundary_and_predictions(dt_classifier_deep, X_test, y_test, y_test_pred_deep, f"Deeper Tree (d={deeper_max_depth}) - Test", axes_deep[2])
plt.tight_layout()
plt.show()


# Visualize the Deeper Decision Tree
plt.figure(figsize=(30, 20)) # May need a very large figure for a deep tree
plot_tree(dt_classifier_deep,
          filled=True,
          rounded=True,
          class_names=list(target_names),
          feature_names=list(feature_names),
          fontsize=7, # Smaller font for complex trees
          max_depth=5) # Optionally, only display top N levels if tree is too massive
plt.title(f"Deeper Decision Tree Visualization (max_depth={deeper_max_depth}, showing top 5 levels if large)")
plt.show()

print("\nEvaluation Metrics for Deeper Tree (max_depth=", deeper_max_depth, ") on Test Set:")
print(classification_report(y_test, y_test_pred_deep, target_names=list(target_names)))


# --- Summary Comparison of Metrics ---
metrics_initial = classification_report(y_test, y_test_pred, target_names=list(target_names), output_dict=True)
metrics_deep = classification_report(y_test, y_test_pred_deep, target_names=list(target_names), output_dict=True)

comparison_df = pd.DataFrame({
    f'Initial Tree (depth={chosen_max_depth})': {
        'accuracy': metrics_initial['accuracy'],
        'macro_avg_precision': metrics_initial['macro avg']['precision'],
        'macro_avg_recall': metrics_initial['macro avg']['recall'],
        'macro_avg_f1-score': metrics_initial['macro avg']['f1-score']
    },
    f'Deeper Tree (depth={deeper_max_depth})': {
        'accuracy': metrics_deep['accuracy'],
        'macro_avg_precision': metrics_deep['macro avg']['precision'],
        'macro_avg_recall': metrics_deep['macro avg']['recall'],
        'macro_avg_f1-score': metrics_deep['macro avg']['f1-score']
    }
}).T

print("\n--- Comparison of Test Set Metrics ---")
print(comparison_df)

# Also compare training accuracies to highlight overfitting
train_acc_initial = accuracy_score(y_train, dt_classifier.predict(X_train))
train_acc_deep = accuracy_score(y_train, dt_classifier_deep.predict(X_train))

print(f"\nTraining Accuracy (Initial Tree, depth={chosen_max_depth}): {train_acc_initial:.3f}")
print(f"Training Accuracy (Deeper Tree, depth={deeper_max_depth}): {train_acc_deep:.3f}")

print(f"\nTest Accuracy (Initial Tree, depth={chosen_max_depth}): {metrics_initial['accuracy']:.3f}")
print(f"Test Accuracy (Deeper Tree, depth={deeper_max_depth}): {metrics_deep['accuracy']:.3f}")

if train_acc_deep > train_acc_initial and metrics_deep['accuracy'] < metrics_initial['accuracy']:
    print("\nThe deeper tree shows signs of overfitting (higher train accuracy, lower test accuracy).")
elif train_acc_deep > train_acc_initial and metrics_deep['accuracy'] <= metrics_initial['accuracy'] + 0.01: # small tolerance
     if metrics_deep['accuracy'] < metrics_initial['accuracy']:
        print("\nThe deeper tree might be slightly overfitting or providing diminishing returns on the test set.")
     else:
        print("\nThe deeper tree has higher training accuracy and similar/slightly better test accuracy.")
else:
    print("\nObserve the training and test accuracies to assess overfitting.")

Total generated samples: 1000
Training set shape: (600, 2)
Validation set shape: (200, 2)
Test set shape: (200, 2)

No description has been provided for this image

--- Initial Decision Tree (max_depth=4) ---

Evaluation Metrics for Initial Tree (max_depth= 4 ) on Test Set:
              precision    recall  f1-score   support

     Class 0       0.87      0.97      0.92       100
     Class 1       0.97      0.86      0.91       100

    accuracy                           0.92       200
   macro avg       0.92      0.92      0.91       200
weighted avg       0.92      0.92      0.91       200


--- Deeper Decision Tree (max_depth=10) ---

Evaluation Metrics for Deeper Tree (max_depth= 10 ) on Test Set:
              precision    recall  f1-score   support

     Class 0       0.93      0.95      0.94       100
     Class 1       0.95      0.93      0.94       100

    accuracy                           0.94       200
   macro avg       0.94      0.94      0.94       200
weighted avg       0.94      0.94      0.94       200


--- Comparison of Test Set Metrics ---
                        accuracy  macro_avg_precision  macro_avg_recall  \
Initial Tree (depth=4)     0.915             0.920083             0.915   
Deeper Tree (depth=10)     0.940             0.940176             0.940   

                        macro_avg_f1-score  
Initial Tree (depth=4)            0.914742  
Deeper Tree (depth=10)            0.939994  

Training Accuracy (Initial Tree, depth=4): 0.917
Training Accuracy (Deeper Tree, depth=10): 0.997

Test Accuracy (Initial Tree, depth=4): 0.915
Test Accuracy (Deeper Tree, depth=10): 0.940

Observe the training and test accuracies to assess overfitting.

Die Bezeichnungen mit “macro” meinen hier übrigens einfache arithmetische Mittel der jeweiligen Größen über alle Klassen.

10.3 Unsupervised Learning¶

Während beim Supervised Learning ein “Lehrer” in Form von gelabelten Daten zur Verfügung steht, müssen wir beim Unsupervised Learning versteckte Strukturen und Muster in den Daten ohne vorgegebene Antworten entdecken. Dies macht Unsupervised Learning sowohl herausfordernder als auch in gewisser Weise natürlicher und gleichzeitig mächtiger – schließlich lernen Menschen oft auch durch selbstständige Exploration und Mustererkennung, und das mit Erfolg.

10.3.1 Clustering von Daten: Grundprinzipien¶

Clustering ist der Prozess der Gruppierung von Datenpunkten in Cluster (Gruppen), sodass Punkte innerhalb eines Clusters einander ähnlicher sind als Punkte in verschiedenen Clustern. Es ist eine der fundamentalsten Aufgaben im Unsupervised Learning. Die grundlegendste Funktion, die man vorab klären bzw. definieren muss, ist, was genau mit “ähnlich” gemeint ist. Das kann z.B. eine Euklidsche Distanz sein, muss es aber nicht. Im Allgemeinen ist Ähnlichkeit ein sehr dehnbarer Begriff.

Das Herzstück jedes Clustering-Algorithmus ist also ein Ähnlichkeitsmaß oder eine Distanzfunktion. Häufige Distanzmetriken sind die bereits erwähnte Euklidische Distanz, die Manhattan Distanz (die rechteckigen “Straßen”-Grids folgt), oder die Cosinus-Distanz, die auf dem Winkel zwischen Vektoren basiert. Als Cluster-Qualitätskriterien kennt man hauptsächlich solche, die im Cluster bzw. zwischen den Clustern definiert sind:

Intra-Cluster-Ähnlichkeit: Punkte innerhalb eines Clusters sollen sich ähnlich sein

Minimale Streuung: Geringe Varianz innerhalb der Cluster
Hohe Dichte: Viele Punkte in einem kompakten Bereich

Inter-Cluster-Unterschiede: Cluster sollen sich voneinander unterscheiden

Maximale Trennung: Große Distanzen zwischen Cluster-Zentren
Geringe Überlappung: Klare Abgrenzung zwischen Clustern

Als typische Cluster-Formen und -eigenschaften haben sich folgende Merkmale herauskristallisiert: Sphärische Cluster sind, wie der Name schon sagt, rund und ideal für K-Means. Beliebige Formen werden besser durch DBSCAN erkannt, weil dieser Algorithmus im Prinzip den Cluster entlanggeht, bis alle Punkte zugeordnet sind. Wenn es Cluster in den Clustern gibt, eignet sich hierarchisches Clustering am besten. Gibt es verschiedenförmige Cluster mit unterschiedlichen Dichten, muss man einfach sein Glück versuchen und herausfinden, welcher Algorithmus am besten mit den Daten zurecht kommt.

Clustering kann mitunter auch grundsätzlich herausfordernd sein. Das kommt daher, dass man eigentlich immer etwas (genauer gesagt, Hyperparameter) fixieren muss. Das einfachste Beispiel dafür ist die Anzahl der Cluster, die man z.B. bei K-Means vorgeben muss. Bei DBSCAN ist es eine Dichte und eine Größenskala für die Kernelemente. Eine weitere Herausforderung, die wir bereits aus anderen Zusammenhängen kennen, ist der Fluch der Dimensionalität, d.h. je höherdimensional das Problem, desto schwieriger ist generell die Datenverarbeitung.

Auch Rauschen, also Daten, die eigentlich zu keinem Cluster gehören, können ein Problem sein. Für solche Daten empfehlen sich dichte-basierte Algorithmen wie DBSCAN, siehe unten.

10.3.2 Cluster-Algorithmen: K-Means vs. DBSCAN¶

Als zwei Paradebeispiele möchte ich Ihnen hier K-Means und DBSCAN kurz vorstellen. K-Means ist einer der bekanntesten und am häufigsten verwendeten Clustering-Algorithmen. Er partitioniert die Daten in k vordefinierte Cluster. Hier ist der K-Means Algorithmus:

1. Initialisierung:
   - Wähle Anzahl k der Cluster
   - Platziere k Zentroide zufällig im Datenraum

2. Wiederhole bis Konvergenz:
   a) Assignment Step:
      - Ordne jeden Datenpunkt dem nächstliegenden Zentroid zu
   
   b) Update Step:
      - Berechne neue Zentroide als Mittelwert aller zugeordneten Punkte

3. Konvergenz:
   - Wenn sich Zentroide nicht mehr signifikant bewegen
   - Oder maximale Iterationszahl erreicht

Vorteile von K-Means:

Einfachheit: Leicht zu verstehen und implementieren
Effizienz: O(n·k·i·d) Komplexität (n=Punkte, k=Cluster, i=Iterationen, d=Dimensionen)
Skalierbarkeit: Funktioniert gut mit großen Datensätzen
Garantierte Konvergenz: Algorithmus konvergiert immer

Nachteile von K-Means:

k muss vorab gewählt werden: Nicht immer trivial
Gut für sphärische Cluster: Funktioniert aber eventuell schlecht bei anderen Formen
Sensitive to Initialization: Verschiedene Startpunkte → verschiedene Ergebnisse
Ausreißer-sensitiv: Zentroide werden stark durch Outlier beeinflusst

Der Algorithmus DBSCAN identifiziert Cluster basierend auf der lokalen Datendichte und kann so relativ einfach Cluster beliebiger Form finden. Die Kernkonzepte von DBSCAN sind:

1. ε-Nachbarschaft: Alle Punkte innerhalb Radius ε von einem Punkt 2. MinPts: Mindestanzahl Punkte in der ε-Nachbarschaft 3. Core Point: Punkt mit mindestens MinPts Nachbarn 4. Border Point: Nicht-Core-Punkt in der Nachbarschaft eines Core-Points 5. Noise Point: Weder Core noch Border Point

Und hier ist der DBSCAN Algorithmus:

1. Beginne bei einem beliebigen unbesuchten Punkt und besuche ihn
2. Für jeden unbesuchten Punkt p:
   a) Markiere p als besucht
   b) Finde alle Nachbarn von p in ε-Distanz
   c) Wenn |Nachbarn| < MinPts:
      - Markiere p als Noise (vorerst)
   d) Sonst:
      - Erstelle neuen Cluster C
      - Füge p zu C hinzu
      - Für jeden Nachbarn n von p:
        - Wenn n unbesucht: wiederhole Prozess rekursiv
        - Wenn n keinem Cluster zugeordnet: füge n zu C hinzu

Vorteile von DBSCAN:

Beliebige Cluster-Formen: Nicht auf sphärische Cluster beschränkt
Automatische Cluster-Anzahl: k muss nicht vorab gewählt werden
Noise Detection: Identifiziert Ausreißer als Noise
Robustheit: Weniger anfällig für Ausreißer

Nachteile von DBSCAN:

Parameter-Sensitivität: ε und MinPts müssen sorgfältig gewählt werden
Varying Densities: Probleme bei Clustern unterschiedlicher Dichte
Hochdimensionale Daten: Distanzkonzept wird weniger bedeutsam
Memory Requirements: Kann speicherintensiv bei großen Datensätzen sein

Hier noch ein kurzer Vergleich von K-Means und DBSCAN:

Aspekt	K-Means	DBSCAN
Cluster-Form	Sphärisch	Beliebig
Cluster-Anzahl	Muss gewählt werden	Automatisch
Ausreißer	Problematisch	Robuste Behandlung
Parameter	k	ε, MinPts
Komplexität	O(nki)	O(n log n)
Determinismus	Nein (Init-abhängig)	Ja

10.3.3 Spezialfall für Distanzmatrizen: Agglomeratives Hierarchisches Clustering¶

Als nächstes möchte ich Ihnen noch etwas zeigen, das Sie eventuell dann brauchen, wenn Ihre Daten zwar keine Koordinaten haben, Sie aber trotzdem einen Abstand zwischen zwei Datenpunkten (also eine Distanzmatrix für den gesamten Datensatz) berechnen können. So ein Algorithmus ist das Hierarchische Clustering.

Hierarchisches Clustering erstellt eine Hierarchie von Clustern in Form eines Baums (Dendrogramm), anstatt eine flache Partitionierung wie K-Means oder DBSCAN. Es gibt zwei Hauptansätze: agglomerativ (bottom-up) und divisiv (top-down). Hier sehen wir uns nur das erste Beispiel an. Beim agglomerativen Ansatz beginnt jeder Datenpunkt als eigener Cluster und wird schrittweise mit dem nächstähnlichen Cluster verschmolzen.

Hier einmal der Agglomerative Algorithmus:

1. Initialisierung:
   - Jeder Datenpunkt bildet einen eigenen Cluster
   - Berechne Distanzmatrix zwischen allen Punkten

2. Wiederhole bis nur ein Cluster übrig:
   a) Finde das Paar von Clustern mit kleinster Distanz
   b) Verschmelze diese beiden Cluster
   c) Aktualisiere die Distanzmatrix
   d) Dokumentiere die Verschmelzung für das Dendrogramm

3. Ergebnis:
   - Dendrogramm mit vollständiger Cluster-Hierarchie
   - Wahl der finalen Cluster-Anzahl durch "Schnitt" im Baum

Soviel zum Clustering Algorithmus selbst. Dabei ist aber die Art, wie die Distanz zwischen Clustern berechnet wird (die Linkage), noch nicht fixiert, diese bestimmt aber die Form der resultierenden Cluster entscheidend mit. Hier sind die wichtigsten Möglichkeiten. Zunächst gibt es die Single Linkage, die einfach die kürzeste Entfernung von zwei Punkten aus zwei Clustern als die Clusterdistanz festlegt. Analog einfach funktioniert die Complete Linkage, bei der man die größte Entfernung irgendwelcher Punkte aus den Clustern als Distanz verwendet.

Üblicher ist allerdings die Average Linkage, bei der der Durchschnitt aller Punkt-zu-Punkt Distanzen verwendet wird, oder z.B. auch die Ward Linkage, welche die Varianz-Zunahme bei Verschmelzung zweier Cluster minimiert. Letztere hat zwar Vorteile, ist aber nur für Euklidische Distanzen anwendbar. Das bedeutet auch, dass sie für jene Fälle ausscheidet, bei denen ein Riesenvorteil des hierarchischen Clusterings zum Tragen kommt: Wenn man, wie bereits erwähnt, nämlich keine Koordinaten zur Verfügung hat, sondern nur eine Distanzmatrix.

Beim hierarchischen Clustering erhält man außerdem die Möglichkeit, die Hierarchie in einem Dendrogramm abzubilden. Dort sieht man, wie die Blätter, die ursprünglichen Datenpunkte, über diverse innere Knoten, wo die Verschmelzungen von Clustern stattfinden, zu einem riesigen gesamten Cluster (alle Daten zusammen) zusammengebaut würden, wenn man das wollte. Und hier kommen wir gleich zu einer anschaulichen Sache: Je nach gewünschter Cluster-Anzahl oder Distanz-Parameter sieht man durch eine nachträglich eingeführte Schnittlinie, wie die Cluster zustande kommen. Wir werden uns das unten in einem Beispiel ansehen.

Vorteile des Hierarchischen Clustering:

Vollständige Information: Alle möglichen Cluster-Strukturen sind sichtbar
Keine k-Wahl vorab nötig: Die Cluster-Anzahl kann nachträglich bestimmt werden
Determinismus: Reproduzierbare Ergebnisse
Interpretierbarkeit: Das Dendrogramm zeigt alle Cluster-Beziehungen

Nachteile des Hierarchischen Clustering:

Komplexität: O(n³) Zeit, O(n²) Speicher
Skalierbarkeit: Problematisch für sehr große Datensätze
Sensitivität: Frühe Entscheidungen sind nicht korrigierbar
Outlier-Einfluss: Ausreißer können die gesamte Struktur beeinflussen

10.3.4 Beispiel: Clustern von Beispieldaten¶

Hier möchte ich Ihnen nun wieder an Beispieldaten zeigen, was Clustering zu leisten im Stande ist. Wir sehen uns konkret die drei besprochenen Algorithmen im Vergleich an.

In [4]:

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_moons, make_blobs # make_blobs is not used but kept for easy switching
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans, DBSCAN, AgglomerativeClustering
from scipy.cluster.hierarchy import dendrogram, linkage
import pandas as pd # For potential tabular summaries if needed, not used in plots

# --- 0. Setup and Data Generation ---
# Using make_moons as it's good for showing differences between algorithms
n_samples = 200
X, y_true = make_moons(n_samples=n_samples, noise=0.1, random_state=42)

# Standardize the data - good practice for many clustering algorithms, esp. DBSCAN (eps) and K-Means
X_scaled = StandardScaler().fit_transform(X)

# Updated Helper Function for Plotting Clusters
predefined_colors = ['#1f77b4', '#ff7f0e', '#2ca02c', '#d62728', '#9467bd', '#8c564b']
noise_color = 'silver'

def plot_clusters(X_data, labels, title, ax, centers=None, algorithm_name=""):
    unique_labels = np.sort(np.unique(labels))

    plot_handles = []
    plot_labels_list = []

    for k_label in unique_labels:
        is_noise = (k_label == -1 and algorithm_name == "DBSCAN")

        # Assign color and marker
        if is_noise:
            current_color = noise_color
            marker = 'x'
            label_text = 'Noise'
        else:
            color_idx = k_label if k_label >= 0 else 0
            current_color = predefined_colors[color_idx % len(predefined_colors)]
            marker = 'o'
            label_text = f'Cluster {k_label}'

        class_member_mask = (labels == k_label)
        xy = X_data[class_member_mask]

        # Conditional edgecolor
        scatter_kwargs = {
            's': 50,
            'c': [current_color], # Pass color as a list for a single color to avoid colormap interpretation
            'marker': marker,
            'label': label_text,
            'alpha': 0.8
        }
        if not is_noise: # Only add edgecolor for non-noise points (e.g., marker 'o')
            scatter_kwargs['edgecolor'] = 'k'

        handle = ax.scatter(xy[:, 0], xy[:, 1], **scatter_kwargs)
        plot_handles.append(handle)
        plot_labels_list.append(label_text)


    if centers is not None:
        center_handle = ax.scatter(centers[:, 0], centers[:, 1], s=250, marker='P',
                                   c='red', edgecolor='black', label='Centroids', alpha=0.9)
        plot_handles.append(center_handle)
        plot_labels_list.append('Centroids')

    ax.set_title(title, fontsize=14)
    ax.set_xlabel("Feature 1 (Scaled)", fontsize=12)
    ax.set_ylabel("Feature 2 (Scaled)", fontsize=12)

    ax.legend(loc='best', fontsize=10)
    ax.grid(True, linestyle='--', alpha=0.6)
    
print(f"Generated {n_samples} samples using make_moons with noise=0.1 and scaled them.")

# --- 1. K-Means Clustering ---
print("\n--- K-Means Clustering ---")
# We expect 2 clusters for make_moons
k_values = [2, 3, 4] # Number of clusters to try

fig_kmeans, axes_kmeans = plt.subplots(1, len(k_values), figsize=(5 * len(k_values), 5))
if len(k_values) == 1: axes_kmeans = [axes_kmeans] # Ensure axes_kmeans is iterable

for i, k in enumerate(k_values):
    # print(k, "clusters")
    kmeans = KMeans(n_clusters=k, random_state=42, n_init=10)
    labels_kmeans = kmeans.fit_predict(X_scaled)
    centers_kmeans = kmeans.cluster_centers_
    plot_clusters(X_scaled, labels_kmeans, f'K-Means (k={k})', axes_kmeans[i], centers=centers_kmeans, algorithm_name="KMeans")

plt.tight_layout()
plt.show()

# --- 2. DBSCAN Clustering ---
print("\n--- DBSCAN Clustering ---")
# For DBSCAN, `eps` and `min_samples` are important.
# `eps` is the maximum distance between two samples for one to be considered as in the neighborhood of the other.
# `min_samples` is the number of samples in a neighborhood for a point to be considered as a core point.
# These values are dataset-dependent. For scaled make_moons with noise=0.1:
eps_values = [0.2, 0.3, 0.4] # Epsilon values to try
min_samples_fixed = 5

fig_dbscan, axes_dbscan = plt.subplots(1, len(eps_values), figsize=(5 * len(eps_values), 5))
if len(eps_values) == 1: axes_dbscan = [axes_dbscan]

for i, eps in enumerate(eps_values):
    dbscan = DBSCAN(eps=eps, min_samples=min_samples_fixed)
    labels_dbscan = dbscan.fit_predict(X_scaled)
    plot_clusters(X_scaled, labels_dbscan, f'DBSCAN (eps={eps}, min_pts={min_samples_fixed})', axes_dbscan[i], algorithm_name="DBSCAN")
    num_clusters = len(np.unique(labels_dbscan)) - (1 if -1 in labels_dbscan else 0)
    axes_dbscan[i].set_title(f'DBSCAN (eps={eps}, min_pts={min_samples_fixed})\nFound {num_clusters} clusters + Noise', fontsize=12)


plt.tight_layout()
plt.show()


# --- 3. Hierarchical Agglomerative Clustering ---
print("\n--- Hierarchical Agglomerative Clustering ---")
linkage_methods = ['ward', 'complete', 'average'] # 'ward' minimizes variance, 'complete' uses max distance, 'average' uses avg distance
n_clusters_hierarchical = 2 # We expect 2 clusters for make_moons

# Plot Dendrograms
fig_dendrogram, axes_dendrogram = plt.subplots(1, len(linkage_methods), figsize=(6 * len(linkage_methods), 5.5))
if len(linkage_methods) == 1: axes_dendrogram = [axes_dendrogram]

print("Plotting Dendrograms...")
for i, method in enumerate(linkage_methods):
    # Calculate linkage matrix
    linked_matrix = linkage(X_scaled, method=method)

    dendrogram(linked_matrix,
               ax=axes_dendrogram[i],
               orientation='top',
               distance_sort='descending',
               show_leaf_counts=False, # True can be very cluttered for n_samples > 30
               truncate_mode='lastp', # Show only the last p merged clusters
               p=12) # Number of merged clusters to show at the bottom

    axes_dendrogram[i].set_title(f'Dendrogram ({method} linkage)', fontsize=14)
    axes_dendrogram[i].set_xlabel("Sample index or (Cluster size)", fontsize=12)
    axes_dendrogram[i].set_ylabel("Distance", fontsize=12)
    axes_dendrogram[i].grid(axis='y', linestyle='--', alpha=0.6)

plt.tight_layout()
plt.show()

# Plot Cluster Assignments from Hierarchical Clustering
fig_hierarchical, axes_hierarchical = plt.subplots(1, len(linkage_methods), figsize=(5 * len(linkage_methods), 5))
if len(linkage_methods) == 1: axes_hierarchical = [axes_hierarchical] # Ensure iterable

print("\nPlotting Cluster Assignments from Hierarchical Clustering...")
for i, method in enumerate(linkage_methods):
    # Ward linkage is only defined for euclidean distance
    # For other linkages, affinity can be specified if not euclidean.
    # AgglomerativeClustering uses euclidean by default.
    if method == 'ward' and X_scaled.shape[0] < 2: # Ward requires at least 2 samples
        axes_hierarchical[i].text(0.5, 0.5, 'Ward linkage requires >=2 samples', horizontalalignment='center', verticalalignment='center')
        axes_hierarchical[i].set_title(f'Hierarchical ({method} linkage)', fontsize=14)
        continue

    hac = AgglomerativeClustering(n_clusters=n_clusters_hierarchical, linkage=method)
    labels_hac = hac.fit_predict(X_scaled)
    plot_clusters(X_scaled, labels_hac, f'Hierarchical ({method} linkage)\n{n_clusters_hierarchical} clusters', axes_hierarchical[i], algorithm_name="HAC")

plt.tight_layout()
plt.show()

print("\n--- End of Unsupervised Clustering Demo ---")

Generated 200 samples using make_moons with noise=0.1 and scaled them.

--- K-Means Clustering ---

--- DBSCAN Clustering ---

--- Hierarchical Agglomerative Clustering ---
Plotting Dendrograms...

Plotting Cluster Assignments from Hierarchical Clustering...

--- End of Unsupervised Clustering Demo ---

10.4 Übungsaufgabe: Supervised Learning mit Scikit-Learn¶

Nachdem wir die theoretischen Grundlagen des Supervised Learning kennengelernt haben, ist es Zeit, diese Konzepte in der Praxis anzuwenden! In dieser Übung werden wir das Wine Quality Dataset verwenden, um die Qualität von portugiesischem Vinho Verde Wein basierend auf seinen chemischen Eigenschaften vorherzusagen.

Hier sind die Details zu diesem Datensatz:

This dataset is public available for research. The details are described in [Cortez et al., 2009]. Please include this citation if you plan to use this database:
P. Cortez, A. Cerdeira, F. Almeida, T. Matos and J. Reis. Modeling wine preferences by data mining from physicochemical properties. In Decision Support Systems, Elsevier, 47(4):547-553. ISSN: 0167-9236.
Available at: [@Elsevier] http://dx.doi.org/10.1016/j.dss.2009.05.016
[Pre-press (pdf)] http://www3.dsi.uminho.pt/pcortez/winequality09.pdf
[bib] http://www3.dsi.uminho.pt/pcortez/dss09.bib

Hier zunächst der Code, um den Datensatz für Rotwein zu laden. Kommentieren Sie die entsprechenden Zeilen aus oder ein, um den zweiten Datensatz für Weißwein zu laden.

In [5]:

import pandas as pd
import os

# Define the expected column names based on your provided string
# (Pandas should pick these up automatically from the header row if the CSV is well-formed)
# column_names = [
#     "fixed acidity", "volatile acidity", "citric acid", "residual sugar",
#     "chlorides", "free sulfur dioxide", "total sulfur dioxide", "density",
#     "pH", "sulphates", "alcohol", "quality"
# ]

# Define the file path
file_path = os.path.join('data','winequality-red.csv')
# file_path = os.path.join('data','winequality-white.csv')

try:
    # Read the CSV file. Based on your column string, the delimiter is likely a semicolon.
    wine_df = pd.read_csv(file_path, sep=';')

    print("Successfully loaded winequality-red.csv")
    print("\n--- First 5 Rows (head) ---")
    print(wine_df.head())

    print("\n--- Statistical Summary (describe) ---")
    print(wine_df.describe())

    print("\n--- Data Info (dtypes and non-null counts) ---")
    print(wine_df.info())

except FileNotFoundError:
    print(f"Error: The file '{file_path}' was not found.")
    print("Please make sure the file is in the correct directory or provide the full path.")
except Exception as e:
    print(f"An error occurred while reading or processing the file: {e}")

Successfully loaded winequality-red.csv

--- First 5 Rows (head) ---
   fixed acidity  volatile acidity  citric acid  residual sugar  chlorides  \
0            7.4              0.70         0.00             1.9      0.076   
1            7.8              0.88         0.00             2.6      0.098   
2            7.8              0.76         0.04             2.3      0.092   
3           11.2              0.28         0.56             1.9      0.075   
4            7.4              0.70         0.00             1.9      0.076   

   free sulfur dioxide  total sulfur dioxide  density    pH  sulphates  \
0                 11.0                  34.0   0.9978  3.51       0.56   
1                 25.0                  67.0   0.9968  3.20       0.68   
2                 15.0                  54.0   0.9970  3.26       0.65   
3                 17.0                  60.0   0.9980  3.16       0.58   
4                 11.0                  34.0   0.9978  3.51       0.56   

   alcohol  quality  
0      9.4        5  
1      9.8        5  
2      9.8        5  
3      9.8        6  
4      9.4        5  

--- Statistical Summary (describe) ---
       fixed acidity  volatile acidity  citric acid  residual sugar  \
count    1599.000000       1599.000000  1599.000000     1599.000000   
mean        8.319637          0.527821     0.270976        2.538806   
std         1.741096          0.179060     0.194801        1.409928   
min         4.600000          0.120000     0.000000        0.900000   
25%         7.100000          0.390000     0.090000        1.900000   
50%         7.900000          0.520000     0.260000        2.200000   
75%         9.200000          0.640000     0.420000        2.600000   
max        15.900000          1.580000     1.000000       15.500000   

         chlorides  free sulfur dioxide  total sulfur dioxide      density  \
count  1599.000000          1599.000000           1599.000000  1599.000000   
mean      0.087467            15.874922             46.467792     0.996747   
std       0.047065            10.460157             32.895324     0.001887   
min       0.012000             1.000000              6.000000     0.990070   
25%       0.070000             7.000000             22.000000     0.995600   
50%       0.079000            14.000000             38.000000     0.996750   
75%       0.090000            21.000000             62.000000     0.997835   
max       0.611000            72.000000            289.000000     1.003690   

                pH    sulphates      alcohol      quality  
count  1599.000000  1599.000000  1599.000000  1599.000000  
mean      3.311113     0.658149    10.422983     5.636023  
std       0.154386     0.169507     1.065668     0.807569  
min       2.740000     0.330000     8.400000     3.000000  
25%       3.210000     0.550000     9.500000     5.000000  
50%       3.310000     0.620000    10.200000     6.000000  
75%       3.400000     0.730000    11.100000     6.000000  
max       4.010000     2.000000    14.900000     8.000000  

--- Data Info (dtypes and non-null counts) ---
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 1599 entries, 0 to 1598
Data columns (total 12 columns):
 #   Column                Non-Null Count  Dtype  
---  ------                --------------  -----  
 0   fixed acidity         1599 non-null   float64
 1   volatile acidity      1599 non-null   float64
 2   citric acid           1599 non-null   float64
 3   residual sugar        1599 non-null   float64
 4   chlorides             1599 non-null   float64
 5   free sulfur dioxide   1599 non-null   float64
 6   total sulfur dioxide  1599 non-null   float64
 7   density               1599 non-null   float64
 8   pH                    1599 non-null   float64
 9   sulphates             1599 non-null   float64
 10  alcohol               1599 non-null   float64
 11  quality               1599 non-null   int64  
dtypes: float64(11), int64(1)
memory usage: 150.0 KB
None

Unser Dataset enthält 1599 Rotwein-Samples mit 11 chemischen Features:

Säuren: Fixed acidity, volatile acidity, citric acid
Zucker und Salze: Residual sugar, chlorides
Schwefelverbindungen: Free/total sulfur dioxide, sulphates
Physikalische Eigenschaften: Density, pH, alcohol

Die Zielvariable ist eine Qualitätsbewertung von 0-10, unter “quality”.

Die Schritte für diese Übungsaufgabe sind¶

Nehmen Sie sich etwas Zeit für die Daten und versuchen Sie, ein Gefühl für den Datensatz zu bekommen
Diskutieren Sie mit Ihrem LLM zunächst, ob bereits mit Unsupervised ML-Methoden sinnvolle Erkenntnisse über die Daten gewonnen werden könnten
Diskutieren Sie dann mit Ihrem LLM, welche ML-Modelle hier für Supervised Learning in Frage kommen; das Supervised Learning ist die Hauptaufgabenstellung
Trainieren Sie ein Supervised Modell (oder auch mehrere verschiedene, die Sie geeignet finden)
Sehen Sie sich die Evaluations-Metriken an und Visualisieren Sie die Ergebnisse, um ein Gefühl dafür zu bekommen, was gut funktioniert hat und was nicht
Versuchen Sie, wenn möglich, belegbare sinnvolle Schlussfolgerungen darüber zu ziehen, welche Eigenschaften für die Qualität des Weins wichtig oder sogar wesentlich sind. Kann man die Ergebnisse irgendwie praktisch verwenden?
Wenn Zeit bleibt, vergleichen Sie die Situation für Rot- und Weißweine. Sind Ihre Schlussfolgerungen auf beide Arten anwendbar? Gibt es generell irgendwelche Unterschiede zwischen rot und weiß?

Viel Vergnügen und gutes Gelingen!

In [ ]:

FMCA-25 09: Monte-Carlo Methoden

Inhalt des Skriptums seit dem Sommersemester 2025

Hier finden Sie die Kapitel aus den Vergangenen Jahren (legacy):

Die Jupyter-Notebooks zur Legacy-Variante der Lehrveranstaltung finden Sie im zugehörigen GitHub-Repository.

9: Monte-Carlo Methoden¶

Monte-Carlo-Methoden gehören zu den leistungsstärksten und vielseitigsten Werkzeugen in der angewandten Mathematik und Informatik. Der Name stammt von dem berühmten Casino in Monaco und deutet auf den Kern dieser Methoden hin: die Verwendung von Zufallszahlen und Wahrscheinlichkeiten zur Lösung bzw. Approximation komplexer Probleme.

Nach dem Studium dieser Einheit sollten Sie zumindest folgende drei der wichtigsten Punkte hier verstehen:¶

Sampling und wie es zu einer Monte-Carlo-Simulation beiträgt bzw. deren Basis bereitstellt.
Die typischen Eigenschaften einer MC-Simulation und wie man damit Werte für Kenngrößen eines untersuchten Systems abschätzen kann.
Monte-Carlo-Integration als konkrete Sampling-Anwendung.

9.1 Grundlagen einer Monte-Carlo (MC) Simulation¶

Monte-Carlo-Simulationen basieren auf einem einfachen, aber mächtigen Prinzip: Wir nutzen eine große Anzahl von Zufallsexperimenten, um Näherungslösungen für Probleme zu finden, die deterministisch schwer zu lösen sind. Die Grundidee dabei ist, dass man durch Mitschreiben der Ergebnisse für bestimmte Größen im System über viele viele “Runs” einer Simulation eine Statistik dieser Ergebnisse bekommt. Für diese beobachtete Statistik des Systems kann man dann idealerweise einen Mittelwert samt Fehlerabschätzung für die Gesuchte Variable berechnen. Während diese Idee intuitiv einleuchtend erscheint, ist es wichtig zu verstehen, wie und warum dieser Ansatz funktioniert, und wo seine Grenzen liegen.

9.1.1 Sampling, Sample-Größe und Anzahl der Samples¶

Der grundlegende Begriff für das Verstehen einer MC-Simulation ist Sampling. Sampling (oder Stichprobenentnahme) bezeichnet den Prozess, zufällige Werte aus einer bestimmten Verteilung zu ziehen. Wir sind Zufallszahlen aus einer Verteilung bereits im Rahmen der Stochastischen Optimierung begegnet. Für eine MC-Simulation erzeugen wir nun eine Anzahl solcher Samples um damit dann die Berechnungen der Simulation durchzuführen.

Die wichtigsten Begriffe dabei sind:

Sample: Ein Satz vorgegebener Größe von Zufallszahlen aus einer Verteilung
Sample-Größe: Die Anzahl der Elemente in einem Sample
Anzahl der Samples: Wie oft wir den Prozess wiederholen, d.h. wie viele solcher Gruppen von Zufallszahlen wir nacheinander verwenden.

Ein einfaches Beispiel: Wenn wir 1000-mal einen fairen Würfel werfen, dann haben wir 1000 Samples der Größe 1. Wenn wir dagegen 100-mal jeweils 10 Würfel gleichzeitig werfen und die Menge der Augenzahlen eines Wurfes gemeinsam betrachten, dann haben wir 100 Samples der Größe 10.

Die Sample-Größe beeinflusst direkt die Genauigkeit unserer Schätzungen. Je größer unsere Stichprobe, desto genauer wird in der Regel unsere Approximation. Dies folgt aus dem Gesetz der großen Zahlen, einem fundamentalen Prinzip der Wahrscheinlichkeitstheorie: Wenn wir ein zufälliges Experiment oft genug wiederholen, nähert sich der Durchschnitt der Ergebnisse dem Erwartungswert an. Das leuchtet ein, ist aber nicht alles (dazu gleich noch mehr). Vorerst kann man dazu aber bereits sagen:

Je präziser das Ergebnis sein soll, desto größere Samples werden insgesamt benötigt.
Die verfügbare Rechenleistung berschränkt die praktikable Menge von Samples und Runs insgesamt.
Die Dimensionalität des Problems spielt eine grundlegende Rolle beim Ziehen von Stichproben, wobei es in höheren Dimensionen unwahrscheinlicher ist, etwas Bestimmtes durch Sampling zu “sehen” oder zu “finden” (auch bekannt als Fluch der Dimensionalität).

Ein Hauptresultat gleich vorab: Die Genauigkeit einer Monte-Carlo-Schätzung verbessert sich typischerweise mit $\sqrt{N}$, wobei $N$ die Anzahl der Gesamtzahl der Runs ist. Das bedeutet, um die Genauigkeit zu verdoppeln, benötigen wir viermal so viele Runs, um den Fehler um eine Kommastelle zu drücken, bereits 100 mal so viele!

9.1.2 Sample-Means, Means of Sample-Means und Fehlerabschätzung¶

Was man bei Monte-Carlo-Simulationen eigentlich immer berechnet, sind arithmetische Mittelwerte für Größen, die in der Simulation interessant sind. Gemittelt wird dabei über die Runs innerhalb eines Samples, das Resultat nennt man daher einen Sample-Mean, also den Mittelwert im Sample. Davon kann es mehrere geben, für jede interessante Variable einen.

Diese Sample-Means sind allerdings selbst Zufallsvariablen, die um den jeweils tatsächlichen Wert $\mu$ in den Daten schwanken. Aus diesem Grund ist es hilfreich, mehrere gleich große Samples innerhalb einer MC-Simulation zu verwenden. Der Grund dafür ist, dass man zwar auf naive Art und Weise einen Mittelwert über ein Sample berechnen kann, aber eigentlich nicht von vornherein eine Standardabweichung zu so einem Sample-Mean, denn man weiß im Allgemeinen nichts über die zugrundeliegende Verteilung der Größe, die man untersucht.

Konkret ist das übliche Verständnis einer mit $\sigma$ angegebenen Standardabweichung das einer zugrundeliegenden Gauß-Verteilung, was aber im Allgemeinen nicht der Fall ist. Daher benützt man den zentralen Grenzwertsatz (auf Englisch “Central-Limit Theorem”) und mittelt die Mittelwerte einer Größe aus mehreren Samples nochmals zu einem Mean of Sample-Means. Der Zentrale Grenzwertsatz besagt dabei, dass für mehrere Zufallsvariablen, die der gleichen Verteilung folgen, die Verteilung der Sample-Means normalverteilt ist. Das bedeutet:

Nimmt man nur ein Sample und berechnet damit einen Mittelwert, dann hat man zwar einen Anhaltspunkt für den Mittelwert der tatsächlichen zugrundeliegenden Verteilung, aber nicht mehr.
Nimmt man die Sample-Means und berechnet deren Mean und Standardabweichung (das darf man dann, denn die Verteilung ist ja eine Normalverteilung), dann hat man sowohl eine bessere Näherung für den tatsächlichen Mittelwert, als auch gleichzeitig eine Abschätzung für den statistischen Fehler in der Bestimmung dieses Mittelwerts.
Wenn man nun die Anzahl der Elemente eines Samples erhöht (also die Samplegröße), dann bekommt man grundsätzlich genauere Werte für den Mittelwert, d.h. auch kleinere Fehler.
Wenn man allerdings auch mehrere Samples verwendet, dann bekommt man eine insgesamt bessere Einschätzung des Mittelwerts und dessen Fehler. In der Praxis empfiehlt es sich, die Anzahl der Samples groß genug zu wählen, damit die Gaußverteilung der Sample-Means gut genug abgebildet werden kann. Als guter Anfangs-Wert eignet sich hier etwa 20.

Diese Methode bietet dabei zwei wesentliche Vorteile:

Sie ermöglicht also eine Abschätzung des Fehlers aus den Daten selbst
Sie erlaubt eine effiziente Parallelisierung der Berechnung durch die mögliche Verteilung von Samples auf CPUs etc.

Die Konvergenzrate von Monte-Carlo-Simulationen ist unabhängig von der Dimensionalität des Problems und beträgt immer $O(1/\sqrt{N})$. Dies macht sie besonders wertvoll für hochdimensionale Probleme, bei denen andere numerische Methoden oft und sehr schnell an ihre Grenzen stoßen. Allerdings bedeutet diese relativ langsame Konvergenzrate auch, dass für sehr präzise Ergebnisse eine große Anzahl von Runs erforderlich sein kann. Dazu kommt außerdem, dass der Fehler anfähnglich, also für z.B. eine gesamte Anzahl von 1 000 000 Runs, sehr groß im Vergleich mit konventionellen Methoden sein kann. In der Praxis werden daher oft Techniken zur Varianzreduktion eingesetzt, um die Effizienz zu verbessern, wie zum Beispiel Importance Sampling oder Markov-Chain Monte Carlo (MCMC), die hier aber leider den Rahmen sprengen.

9.2 Random Walk¶

Nach dieser recht ausführlichen etwas trockenen Einleitung geht es jetzt endlich mit den ersten Simulationen los. Das Beispiel, das wir uns hier ansehen, nennt man Random Walk. Der Random Walk ist eines der fundamentalsten Konzepte in der Wahrscheinlichkeitstheorie und findet Anwendungen in zahlreichen wissenschaftlichen Disziplinen – von der Physik und Chemie bis hin zur Finanzwirtschaft und Informatik. Ein Random Walk ist im Wesentlichen eine mathematische Formalisierung einer Pfadentwicklung, bei der jeder Schritt nach bestimmten Regeln zufällig bestimmt wird.

9.2.1 Definition und Setup¶

In seiner einfachsten Form ist ein Random Walk eine Folge von Zufallsschritten in einem mathematischen Raum. Beginnen wir mit dem eindimensionalen Fall:

Ein eindimensionaler Random Walk auf den ganzen Zahlen der Zahlengeraden kann wie folgt definiert werden:

Wir starten an einem Punkt, üblicherweise bei $x = 0$
In jedem Zeitschritt bewegen wir uns entweder um eine Einheit nach rechts oder eine Einheit nach links
Die Richtung jedes Schritts wird zufällig und unabhängig von vorherigen Schritten bestimmt

Mathematisch können wir dies als Summe von Zufallsvariablen ausdrücken:

$$X_n = \sum_{i=1}^{n} S_i$$

wobei:

$X_n$ die Position nach $n$ Schritten ist
$S_i$ die Zufallsvariable für den $i$-ten Schritt ist, mit $P(S_i = 1) = p$ und $P(S_i = -1) = 1-p$

Im Fall eines symmetrischen Random Walks haben wir $p = 0.5$, das heißt, Bewegungen nach rechts und links sind gleich wahrscheinlich. Die kumulative Summe der zufälligen Schritte gibt uns die Position zu jedem Zeitpunkt.

9.2.2 Varianten: Dimensionen, Bias und Diskretisierung¶

Random Walks lassen sich auf verschiedene Weise verallgemeinern und anpassen, um unterschiedliche Phänomene zu modellieren. Ein Random Walk muss natürlich nicht auf eine Dimension beschränkt sein. In zwei Dimensionen bewegt sich unser “Wanderer” auf einem Gitter und kann in jedem Schritt in eine von vier Richtungen gehen: oben, unten, links oder rechts. Analog können wir Random Walks in drei oder mehr Dimensionen definieren.

Hier als Beispiel ein Satz von 1000 Random Walks in zwei Dimensionen mit diskreter endlicher Schrittweite und eingeschränkt auf die Richtungen der Koordinatenachsen. Die Code Snippets für diese Einheit stammen wieder von Gemini 2.5 pro.

In [21]:

import numpy as np
import matplotlib.pyplot as plt

def generate_random_walks_2d_discrete(num_walks, num_steps):
    """
    Generates a specified number of 2D discrete random walks.

    Each walk starts at (0,0). Steps are of size 1 and can be in
    one of four directions: right, left, up, or down.

    Args:
        num_walks (int): The number of random walks to generate.
        num_steps (int): The number of steps each walk should take.

    Returns:
        list: A list of numpy arrays, where each array represents a
              walk and contains (x, y) coordinates for each step.
    """
    walks = []
    # Define possible steps: right, left, up, down
    # Each row is a [dx, dy]
    step_directions = np.array([[1, 0], [-1, 0], [0, 1], [0, -1]])

    for _ in range(num_walks):
        # Initialize walk at (0,0)
        # Shape: (num_steps + 1, 2) to include the starting point
        path = np.zeros((num_steps + 1, 2))

        for i in range(num_steps):
            # Randomly choose one of the four directions
            step = step_directions[np.random.randint(0, 4)]
            # Update position
            path[i+1] = path[i] + step
        walks.append(path)
    return walks

def plot_random_walks(walks, title="2D Discrete Random Walks"):
    """
    Plots a collection of 2D random walks on a single Matplotlib plot.

    Args:
        walks (list): A list of numpy arrays, where each array represents a
                      walk (output from generate_random_walks_2d_discrete).
        title (str): The title for the plot.
    """
    if not walks:
        print("No walks to plot.")
        return

    num_walks = len(walks)
    # Create a colormap to assign a different color to each walk
    colors = plt.cm.viridis(np.linspace(0, 1, num_walks))

    plt.figure(figsize=(10, 10)) # Adjust figure size for better visibility

    for i, walk_path in enumerate(walks):
        # Plot x and y coordinates of the walk
        plt.plot(walk_path[:, 0], walk_path[:, 1], color=colors[i], alpha=0.7, linewidth=0.8)

    plt.title(title)
    plt.xlabel("X position")
    plt.ylabel("Y position")
    plt.grid(True, linestyle='--', alpha=0.6) # Add a grid for readability
    plt.axis('equal') # Ensure steps have equal visual length in x and y
    plt.show()

# --- Main execution ---
if __name__ == '__main__':
    # Parameters for the random walks
    number_of_walks = 1000
    steps_per_walk = 100  # You can adjust the number of steps per walk

    # 1. Generate the random walks
    all_walks = generate_random_walks_2d_discrete(number_of_walks, steps_per_walk)

    # 2. Visualize the walks
    plot_title = f"{number_of_walks} Two-Dimensional Discrete Random Walks ({steps_per_walk} steps each)"
    plot_random_walks(all_walks, title=plot_title)

Ein “biased” oder verzerrter Random Walk ist einer, bei dem die Wahrscheinlichkeiten für verschiedene Richtungen nicht gleich sind. So könnte beispielsweise ein Teilchen in einer Flüssigkeit, das einem elektrischen Feld ausgesetzt ist, eine höhere Wahrscheinlichkeit haben, sich in Richtung einer der Elektroden zu bewegen. In unserem eindimensionalen Beispiel würde ein Bias bedeuten, dass $p \neq 0.5$. Wenn $p > 0.5$, besteht eine höhere Wahrscheinlichkeit, sich nach rechts zu bewegen, was zu einer durchschnittlichen Drift in diese Richtung führt.

Eine Andere Erweiterung betrifft die Diskretisierung des Raumes: Bisher haben wir diskrete Schritte in Raum und Zeit betrachtet, aber in vielen Anwendungen ist es sinnvoller, die Zeit und Raum als kontinuierliche Variable zu behandeln. Bei einem Continuous-Time Random Walk (CTRW) sind nicht nur die räumlichen Schritte, sondern auch die Zeitintervalle zwischen den Schritten zufällig.

Man lässt Random Walks also im Allgemeinen in beliebige Richtungen und verschieden weit pro Schritt gehen, und passt die Anzahl der Dimensionen des Raums and das konkrete Problem an. Zusätzlich zu einem generellen Bias in eine Richtung kann man auch noch einbauen, dass ein Random-Walk nicht in genau jene Richtung zurückgehen darf, aus der er gerade gekommen ist. Das ist bei diskreten Random Walks wie in unserem obigen Beispiel interessant, wo de facto bei jedem Schritt eine von vier Möglichkeiten ausgeschlossen wäre.

Sehen wir uns einen allgemeinen Random Walk an:

In [9]:

import numpy as np
import matplotlib.pyplot as plt

def generate_random_walks_2d_continuous(num_walks, num_steps):
    """
    Generates a specified number of 2D continuous random walks.

    Each walk starts at (0,0). Steps have a random direction (0 to 2*pi)
    and a random length (uniformly distributed between 0 and 1).

    Args:
        num_walks (int): The number of random walks to generate.
        num_steps (int): The number of steps each walk should take.

    Returns:
        list: A list of numpy arrays, where each array represents a
              walk and contains (x, y) coordinates for each step.
    """
    walks = []
    for _ in range(num_walks):
        # Initialize walk at (0,0)
        # Shape: (num_steps + 1, 2) to include the starting point
        path = np.zeros((num_steps + 1, 2))

        for i in range(num_steps):
            # 1. Generate a random angle (direction) between 0 and 2*pi
            angle = np.random.uniform(0, 2 * np.pi)

            # 2. Generate a random step size between 0 and 1
            step_size = np.random.uniform(0, 1)

            # 3. Calculate the change in x and y (dx, dy)
            dx = step_size * np.cos(angle)
            dy = step_size * np.sin(angle)

            # 4. Update position
            path[i+1] = path[i] + [dx, dy]
        walks.append(path)
    return walks

def plot_random_walks(walks, title="2D Random Walks"):
    """
    Plots a collection of 2D random walks on a single Matplotlib plot.

    Args:
        walks (list): A list of numpy arrays, where each array represents a
                      walk (output from a generate_random_walks function).
        title (str): The title for the plot.
    """
    if not walks:
        print("No walks to plot.")
        return

    num_walks = len(walks)
    # Create a colormap to assign a different color to each walk
    # Using plt.cm.get_cmap for newer Matplotlib versions if cm.viridis is an issue
    try:
        colors = plt.cm.viridis(np.linspace(0, 1, num_walks))
    except AttributeError: # Fallback for older versions or specific environments
        cmap = plt.get_cmap('magma')
        colors = cmap(np.linspace(0, 1, num_walks))


    plt.figure(figsize=(10, 10)) # Adjust figure size for better visibility

    for i, walk_path in enumerate(walks):
        # Plot x and y coordinates of the walk
        plt.plot(walk_path[:, 0], walk_path[:, 1], color=colors[i], alpha=0.6, linewidth=0.5)

    plt.title(title)
    plt.xlabel("X position")
    plt.ylabel("Y position")
    plt.grid(True, linestyle='--', alpha=0.6) # Add a grid for readability
    plt.axis('equal') # Ensure steps have equal visual length in x and y initially,
                      # though step sizes vary. This maintains aspect ratio.
    plt.show()

# --- Main execution ---
if __name__ == '__main__':
    # Parameters for the random walks
    number_of_walks = 1000
    steps_per_walk = 100  # You can adjust the number of steps per walk

    # 1. Generate the continuous random walks
    all_walks_continuous = generate_random_walks_2d_continuous(number_of_walks, steps_per_walk)

    # 2. Visualize the walks
    plot_title_continuous = (
        f"{number_of_walks} Continuous 2D Random Walks\n"
        f"({steps_per_walk} steps each, random direction & step size [0,1])"
    )
    plot_random_walks(all_walks_continuous, title=plot_title_continuous)

9.2.3 Eigenschaften und interessante Fragen zu Random Walks¶

Soweit, so gut, aber was kann man nun eigentlich mit so etwas anfangen? Um diese Frage zu beantworten, sehen wir uns einfach ein paar konkrete Eigenschaften an, die man bezüglich der Pfade und der Walks untersuchen kann.

Rückkehrwahrscheinlichkeit von Random Walks auf Diskreten Gittern¶

Eine grundlegende Frage ist: Mit welcher Wahrscheinlichkeit kehrt ein Random Walk jemals zum Ausgangspunkt zurück? Das erscheint vielleicht für unser gerade eben gesehenes Beispiel ziemlich sinnlos, weil unwahrscheinlich, aber für das zuerst erwähnte eindimensionale Problem mit Schritten $\pm 1$ ist es, auch unmittelbar einsichtigerweise, eine sehr relevante Frage.

Die Antwort für Random Walks auf diskreten Gittern (so wie oben) hängt im Allgemeinen von der Dimension ab (der Beweis dafür stammt von Pólya):

In einer Dimension: Die Rückkehrwahrscheinlichkeit beträgt 1 (der Walk kehrt mit Sicherheit zurück)
In zwei Dimensionen: Die Rückkehrwahrscheinlichkeit beträgt ebenfalls 1
In drei oder mehr Dimensionen: Die Rückkehrwahrscheinlichkeit ist kleiner als 1 (es besteht eine positive Wahrscheinlichkeit, nie zurückzukehren)

Erwarteter Abstand vom Ausgangspunkt¶

Wie weit entfernt vom Startpunkt erwarten wir den Walk nach $n$ Schritten zu finden? Für einen unbiased Random Walk gilt: Der erwartete Abstand vom Ursprung nach $n$ Schritten ist proportional zu $\sqrt{n}$. Diese $\sqrt{n}$-Skalierung ist ein charakteristisches Merkmal von diffusiven Prozessen und unterscheidet Random Walks von gerichteteren Bewegungen.

First-Passage Time und Hitting Time¶

Weitere interessante statistische Größen bei Random Walks sind:

First-Passage Time: Die Zeit, die benötigt wird, um einen bestimmten Punkt zum ersten Mal zu erreichen
Hitting Time: Die Zeit, die benötigt wird, um eine bestimmte Menge von Punkten zu erreichen

Diese Konzepte sind in vielen Anwendungen wichtig, beispielsweise beim Modellieren von chemischen Reaktionen, bei denen Moleküle zusammentreffen müssen, oder in der Finanzwirtschaft, wenn ein Aktienkurs einen bestimmten Wert erreicht.

Self-Avoiding Random Walks¶

Ein Self-Avoiding Random Walk ist ein Pfad, der sich nicht selbst kreuzt. Dies ist ein komplexeres Modell, das beispielsweise verwendet wird, um die Konformationen von Polymeren zu modellieren, bei denen sich zwei Teile des Moleküls nicht am selben Ort befinden können. Im Gegensatz zum einfachen Random Walk gibt es für Self-Avoiding Walks keine exakten analytischen Lösungen, und ihre Untersuchung erfordert daher grundsätzlich numerische Methoden wie eben MC-Simulationen.

Praktische Anwendungen von Random Walks¶

Random Walks finden Anwendung in verschiedenen wissenschaftlichen und praktischen Bereichen:

Physik: Brownsche Bewegung, Diffusion, thermisches Rauschen
Chemie: Molekulare Diffusion, Reaktionskinetik
Biologie: Bewegung von Zellen, Ausbreitung von Krankheiten
Informatik: Suchstrategien, Netzwerkanalyse
Finanzwirtschaft: Aktienkurse, Option Pricing (Black-Scholes-Modell)
Künstliche Intelligenz: Exploration in Reinforcement Learning, Monte Carlo Tree Search

Das Konzept ist also sehr generell einsetzbar und kann auf vielfältigste Situationen anwendbar.

9.3 Monte-Carlo-Integration¶

Die Monte-Carlo-Integration ist eine der wichtigsten und weitverbreitetsten Anwendungen von Monte-Carlo-Methoden. MC-Integration ist auch einer der natürlichsten Berührungspunkte mit dem Gebiet der MC-Methoden allgemein. Sie bietet einen leistungsstarken Ansatz zur numerischen Berechnung von Integralen, insbesondere in hohen Dimensionen oder für Funktionen mit komplexen Geometrien, bei denen klassische numerische Integrationsmethoden wie die Trapezregel oder die Gauß-Quadratur an ihre Grenzen stoßen.

9.3.1 Das berühmte aber untypische Beispiel: Berechnung von Pi¶

Die Berechnung der Kreiszahl $\pi$ mittels MC-Methode ist ein klassisches Beispiel, das oft zur Einführung in dieses Thema verwendet wird. Obwohl es ein anschauliches Beispiel für MC-Methoden ist, ist es wichtig zu verstehen, dass es nicht repräsentativ für typische Anwendungen der Monte-Carlo-Integration ist. Warum, das werden Sie im Folgenden unterscheiden lernen.

Die Grundidee für das einfache MC-Berechnen von $\pi$ ist, geometrisches Sampling einzusetzen, und zwar so:

Wir betrachten einen Einheitskreis, der in ein Quadrat mit der Seitenlänge 2 eingebettet ist.
Die Fläche des Kreises beträgt $A_{Kreis} = \pi \cdot r^2 = \pi$, da $r = 1$.
Die Fläche des Quadrats beträgt $A_{Quadrat} = 4$.
Das Verhältnis der Flächen ist also $\frac{A_{Kreis}}{A_{Quadrat}} = \frac{\pi}{4}$.

Der Monte-Carlo-Ansatz besteht nun darin, zufällige Punkte innerhalb des Quadrats zu erzeugen und zu zählen, wie viele davon innerhalb des Kreises liegen. Für eine große Anzahl von Punkten sollte der Anteil der Punkte im Kreis dem Flächenverhältnis $\frac{\pi}{4}$ entsprechen. Somit können wir $\pi$ approximieren als:

$$\pi \approx 4 \cdot \frac{\text{Anzahl der Punkte im Kreis}}{\text{Gesamtanzahl der Punkte}}$$

Sehen wir uns das gleich einmal an: Zunächst setzen wir das geometrische Sampling um, aber nur im Viertelkreis, der im ersten Quadranten liegt. Auch dort ist das Verhältnis des Viertelkreises zum Quadrat mit der Seitenlänge 1 wieder $\frac{\pi}{4}$.

In [12]:

import numpy as np
import matplotlib.pyplot as plt

def estimate_pi_monte_carlo(num_points=1000):
    """
    Estimates Pi using the Monte Carlo method by simulating points
    in a unit square and checking if they fall within a quarter circle.

    Args:
        num_points (int): The total number of random points to generate.

    Returns:
        float: The estimated value of Pi.
        numpy.ndarray: x-coordinates of points inside the quarter circle.
        numpy.ndarray: y-coordinates of points inside the quarter circle.
        numpy.ndarray: x-coordinates of points outside the quarter circle.
        numpy.ndarray: y-coordinates of points outside the quarter circle.
        int: Number of points inside the quarter circle.
    """
    # Generate random points (x, y) within the unit square [0,1] x [0,1]
    # Each point has x and y coordinates between 0 and 1.
    x_coords = np.random.uniform(0, 1, num_points)
    y_coords = np.random.uniform(0, 1, num_points)

    # Calculate the distance of each point from the origin (0,0)
    # A point is inside the quarter circle if x^2 + y^2 <= 1^2 (radius = 1)
    distance_squared = x_coords**2 + y_coords**2
    is_inside_circle = distance_squared <= 1.0

    # Separate points for plotting and counting
    points_inside_x = x_coords[is_inside_circle]
    points_inside_y = y_coords[is_inside_circle]
    points_outside_x = x_coords[~is_inside_circle]
    points_outside_y = y_coords[~is_inside_circle]

    # Count points inside the quarter circle
    num_inside_circle = np.sum(is_inside_circle)

    # Estimate Pi
    # The ratio (num_inside_circle / num_points) approximates (Area of quarter circle / Area of square)
    # Area of quarter circle = (pi * r^2) / 4. Here r=1. So, Area = pi / 4.
    # Area of unit square = 1 * 1 = 1.
    # So, (num_inside_circle / num_points) approx pi / 4.
    # Therefore, pi approx 4 * (num_inside_circle / num_points).
    pi_approximation = 4 * (num_inside_circle / num_points)

    return (pi_approximation,
            points_inside_x, points_inside_y,
            points_outside_x, points_outside_y,
            num_inside_circle)

def plot_pi_estimation(pi_estimate, num_total_points,
                       points_inside_x, points_inside_y,
                       points_outside_x, points_outside_y,
                       num_inside_circle):
    """
    Plots the visualization for the Monte Carlo Pi estimation.
    """
    num_outside_circle = num_total_points - num_inside_circle

    fig, ax = plt.subplots(figsize=(7, 7)) # Create a figure and an axes

    # Plot points inside the quarter circle (green)
    ax.scatter(points_inside_x, points_inside_y, color='green',
               label=f'Inside Circle ({num_inside_circle})', s=10, alpha=0.7)

    # Plot points outside the quarter circle but inside the square (red)
    ax.scatter(points_outside_x, points_outside_y, color='red',
               label=f'Outside Circle ({num_outside_circle})', s=10, alpha=0.7)

    # Draw the arc of the quarter circle (radius 1, from 0 to pi/2)
    theta = np.linspace(0, np.pi/2, 200) # Angles for the arc
    x_circle_arc = np.cos(theta)         # x-coordinates of the arc
    y_circle_arc = np.sin(theta)         # y-coordinates of the arc
    ax.plot(x_circle_arc, y_circle_arc, color='blue', linewidth=2, label='Quarter Circle (r=1)')

    # Set plot properties
    ax.set_xlim(0, 1)
    ax.set_ylim(0, 1)
    ax.set_aspect('equal', adjustable='box') # Crucial for correct visual representation
    ax.set_xlabel('X coordinate')
    ax.set_ylabel('Y coordinate')
    title_str = (
        f'Monte Carlo Estimation of $\pi$\n'
        f'{num_total_points} random points\n'
        f'Estimated $\pi \\approx {pi_estimate:.4f}$' # Using LaTeX for Pi
    )
    ax.set_title(title_str)
    ax.legend(loc='upper right')
    ax.grid(True, linestyle='--', alpha=0.5)

    plt.show()

# --- Main execution ---
if __name__ == '__main__':
    # Parameters
    number_of_points = 1000

    # 1. Perform Monte Carlo estimation
    (pi_value_estimate,
     px_in, py_in,
     px_out, py_out,
     n_inside) = estimate_pi_monte_carlo(num_points=number_of_points)

    # 2. Output the results
    print(f"--- Monte Carlo Pi Estimation ---")
    print(f"Total random points generated: {number_of_points}")
    print(f"Points inside the quarter circle: {n_inside}")
    print(f"Points outside the quarter circle (but in square): {number_of_points - n_inside}")
    print(f"Estimated value of Pi: {pi_value_estimate:.5f}")
    print(f"Value of math.pi (for comparison): {np.pi:.5f}")
    print(f"Absolute error: {abs(np.pi - pi_value_estimate):.5f}")


    # 3. Plot the visualization
    plot_pi_estimation(pi_value_estimate, number_of_points,
                       px_in, py_in, px_out, py_out, n_inside)

--- Monte Carlo Pi Estimation ---
Total random points generated: 1000
Points inside the quarter circle: 795
Points outside the quarter circle (but in square): 205
Estimated value of Pi: 3.18000
Value of math.pi (for comparison): 3.14159
Absolute error: 0.03841

Sehen wir uns noch kurz an, wie die Anzahlen der Samples sowie der Punkte in einem Sample den errechneten Mittelwert und dessen Standardabweichung beeinflussen.

In [20]:

import numpy as np
import matplotlib.pyplot as plt

# --- Part 1: Core Pi Estimation Function (simplified) ---
def get_pi_estimate_single_run(num_points):
    """
    Estimates Pi using the Monte Carlo method for a single run.
    This function does not produce any plots.

    Args:
        num_points (int): The total number of random points to generate for this run.

    Returns:
        float: The estimated value of Pi for this run.
    """
    # Ensure num_points is positive to avoid division by zero
    if num_points <= 0:
        return 0.0 # Or raise an error, or return np.nan

    # Generate random points (x, y) within the unit square [0,1] x [0,1]
    # Each point has x and y coordinates between 0 and 1.
    x_coords = np.random.uniform(0, 1, num_points)
    y_coords = np.random.uniform(0, 1, num_points)

    # Calculate the distance squared of each point from the origin (0,0)
    # A point is inside the quarter circle if x^2 + y^2 <= 1^2 (radius = 1)
    distance_squared = x_coords**2 + y_coords**2
    is_inside_circle = distance_squared <= 1.0

    # Count points inside the quarter circle
    num_inside_circle = np.sum(is_inside_circle)

    # Estimate Pi
    # The ratio (num_inside_circle / num_points) approximates (Area of quarter circle / Area of square)
    # Area of quarter circle = (pi * r^2) / 4. Here r=1. So, Area = pi / 4.
    # Area of unit square = 1 * 1 = 1.
    # So, (num_inside_circle / num_points) approx pi / 4.
    # Therefore, pi approx 4 * (num_inside_circle / num_points).
    pi_approximation = 4 * (num_inside_circle / num_points)
    return pi_approximation

# --- Part 2: Function to run multiple samples and get stats ---
def run_pi_simulation_series(num_samples, num_points_per_sample):
    """
    Runs a series of Pi estimation simulations and calculates statistics
    on the collected Pi estimates.

    Args:
        num_samples (int): The number of individual Pi estimation runs (samples).
        num_points_per_sample (int): The number of random points used in each sample.

    Returns:
        tuple: (mean_pi_estimate, std_dev_pi_estimate)
               The mean and standard deviation of the Pi estimates from all samples.
    """
    pi_estimates_for_series = []
    for _ in range(num_samples):
        estimate = get_pi_estimate_single_run(num_points_per_sample)
        pi_estimates_for_series.append(estimate)

    # Convert list to NumPy array for easier statistical calculations
    pi_estimates_array = np.array(pi_estimates_for_series)

    # Calculate the mean of the Pi estimates
    mean_pi = np.mean(pi_estimates_array)

    # Calculate the standard deviation of the Pi estimates
    # This represents the spread of the Pi estimates obtained from the samples.
    std_dev_pi = np.std(pi_estimates_array) # ddof=0 by default for np.std

    return mean_pi, std_dev_pi

# --- Main execution block ---
if __name__ == '__main__':
    # Define the different simulation configurations
    # Each dictionary contains a label for plotting, number of samples, and points per sample.
    configurations = [
        {"label": "100 samples\n100 pts/sample", "samples": 100, "points": 100},
        {"label": "1000 samples\n100 pts/sample", "samples": 1000, "points": 100},
        {"label": "100 samples\n1000 pts/sample", "samples": 100, "points": 1000},
        {"label": "1000 samples\n1000 pts/sample", "samples": 1000, "points": 1000},
        {"label": "10000 samples\n1000 pts/sample", "samples": 10000, "points": 1000},
        {"label": "10000 samples\n10000 pts/sample", "samples": 10000, "points": 10000},
        {"label": "1000 samples\n10000 pts/sample", "samples": 1000, "points": 10000},
        {"label": "100 samples\n100000 pts/sample", "samples": 100, "points": 100000},
    ]

    results_means = []      # To store the mean Pi estimate for each configuration
    results_std_devs = []   # To store the std dev of Pi estimates for each configuration
    config_labels_for_plot = [] # To store labels for the plot's x-axis

    print("--- Monte Carlo Pi Estimation: Series Results ---")
    # Loop through each configuration, run simulations, and store results
    for config in configurations:
        mean_pi, std_dev_pi = run_pi_simulation_series(config["samples"], config["points"])

        results_means.append(mean_pi)
        results_std_devs.append(std_dev_pi)
        config_labels_for_plot.append(config["label"])

        # Print results for the current configuration
        # Replacing newline in label for cleaner single-line console output
        print(f"\nConfiguration: {config['label'].replace(chr(10), ' ')}")
        print(f"  Number of Samples: {config['samples']}")
        print(f"  Points per Sample: {config['points']}")
        print(f"  Mean of Pi Estimates (Mean of Sample Means): {mean_pi:.5f}")
        print(f"  Std Dev of Pi Estimates (Sigma of Sample Means): {std_dev_pi:.5f}")

    # --- Part 3: Plotting the summary results ---
    plt.figure(figsize=(12, 7)) # Adjusted figure size for better label display
    x_positions = np.arange(len(config_labels_for_plot)) # X-coordinates for the bars/points

    # Create the error bar plot
    # fmt='o' plots points at the mean values
    # capsize adds caps to the error bars
    plt.errorbar(x_positions, results_means, yerr=results_std_devs,
                 fmt='o', color='dodgerblue', markersize=8,
                 capsize=5, capthick=1, elinewidth=1,
                 label='Mean Estimated $\pi$ (with Std Dev of Sample Means)')

    # Add a horizontal dashed line for the actual value of Pi
    plt.axhline(y=np.pi, color='red', linestyle='--', linewidth=1.5,
                label=f'Actual $\pi \\approx {np.pi:.5f}$')

    # Set plot properties
    plt.xticks(x_positions, config_labels_for_plot, rotation=0, ha='center') # Center labels
    plt.ylabel('Estimated Value of $\pi$')
    plt.xlabel('Simulation Configuration (Samples x Points per Sample)')
    plt.title('Monte Carlo $\pi$ Estimation: Impact of Sample Size and Points per Sample')
    plt.legend(loc='best')
    plt.grid(True, linestyle=':', alpha=0.6, axis='y') # Lighter grid on y-axis
    plt.tight_layout() # Adjust layout to make sure everything fits without overlapping

    plt.show()

--- Monte Carlo Pi Estimation: Series Results ---

Configuration: 100 samples 100 pts/sample
  Number of Samples: 100
  Points per Sample: 100
  Mean of Pi Estimates (Mean of Sample Means): 3.13240
  Std Dev of Pi Estimates (Sigma of Sample Means): 0.17127

Configuration: 1000 samples 100 pts/sample
  Number of Samples: 1000
  Points per Sample: 100
  Mean of Pi Estimates (Mean of Sample Means): 3.14164
  Std Dev of Pi Estimates (Sigma of Sample Means): 0.16449

Configuration: 100 samples 1000 pts/sample
  Number of Samples: 100
  Points per Sample: 1000
  Mean of Pi Estimates (Mean of Sample Means): 3.14196
  Std Dev of Pi Estimates (Sigma of Sample Means): 0.05382

Configuration: 1000 samples 1000 pts/sample
  Number of Samples: 1000
  Points per Sample: 1000
  Mean of Pi Estimates (Mean of Sample Means): 3.14055
  Std Dev of Pi Estimates (Sigma of Sample Means): 0.05316

Configuration: 10000 samples 1000 pts/sample
  Number of Samples: 10000
  Points per Sample: 1000
  Mean of Pi Estimates (Mean of Sample Means): 3.14261
  Std Dev of Pi Estimates (Sigma of Sample Means): 0.05142

Configuration: 10000 samples 10000 pts/sample
  Number of Samples: 10000
  Points per Sample: 10000
  Mean of Pi Estimates (Mean of Sample Means): 3.14159
  Std Dev of Pi Estimates (Sigma of Sample Means): 0.01633

Configuration: 1000 samples 10000 pts/sample
  Number of Samples: 1000
  Points per Sample: 10000
  Mean of Pi Estimates (Mean of Sample Means): 3.14119
  Std Dev of Pi Estimates (Sigma of Sample Means): 0.01656

Configuration: 100 samples 100000 pts/sample
  Number of Samples: 100
  Points per Sample: 100000
  Mean of Pi Estimates (Mean of Sample Means): 3.14131
  Std Dev of Pi Estimates (Sigma of Sample Means): 0.00508

Obwohl diese Methode konzeptionell einfach ist, ist sie keine effiziente Methode zur Berechnung von $\pi$, nicht einmal im Rahmen von MC-Methoden. Vielmehr illustriert sie perfekt das Prinzip einer einfachen MC-Simulation. Die MC-Integration is jedoch in Ihrer effizienten Form auf folgende Grundlage gestellt:

9.3.2 Integration als gewichtete Summierung von Funktionswerten¶

Die allgemeine Idee der Monte-Carlo-Integration lässt sich wie folgt darstellen: Wir möchten ein bestimmtes Integral berechnen

$$I = \int_a^b f(x) \, dx$$

Der klassische Monte-Carlo-Ansatz besteht aus den folgenden Schritten:

Ziehe $N$ zufällige Punkte $x_1, x_2, \ldots, x_N$ gleichverteilt aus dem Intervall $[a, b]$.
Berechne den Funktionswert $f(x_i)$ für jeden dieser Punkte.
Approximiere das Integral als gewichteten Durchschnitt dieser Funktionswerte:

$$I \approx \frac{b-a}{N} \sum_{i=1}^{N} f(x_i)$$

Die theoretische Grundlage für diese Approximation ist der Erwartungswert. Wenn $X$ eine auf $[a, b]$ gleichverteilte Zufallsvariable ist, dann gilt:

$$E\left[ (b-a) \cdot f(X) \right] = \int_a^b f(x) \, dx$$

Mit dem Gesetz der großen Zahlen konvergiert der empirische Mittelwert gegen den Erwartungswert und man darf so den Wert der Summe als Näherungswert des Integrals betrachten. Den zugehörigen Fehler kann man wieder mittels Means of Sample-Means bestimmen. Hier ein Beispiel für so eine Integration. Wir berechnen wieder näherungsweise die Zahl $\pi$ und zwar über den Erwartungswert der Funktion $f(x)=\sqrt{1-x^2}$. Für jeweils 100 Samples erhöhen wir die Samplegröße schrittweise um einen Faktor 10. Der Plot ganz unten zeigt die Abhängigkeit der Standardabweichung des Means of Sample-Means von der Samplegröße.

In [25]:

import numpy as np
import matplotlib.pyplot as plt

# --- Part 1: Core Pi Estimation Function using MC Integration ---
def estimate_pi_mc_integration_single_run(num_points_N):
    """
    Estimates Pi using Monte Carlo integration of sqrt(1-x^2) from 0 to 1.
    The integral of sqrt(1-x^2) dx from 0 to 1 is pi/4.

    Args:
        num_points_N (int): The number of random points (x_i values) to generate.

    Returns:
        float: The estimated value of Pi for this run.
    """
    if num_points_N <= 0:
        # Return NaN or raise error for invalid input
        return np.nan

    # Generate N random numbers uniformly distributed between 0 and 1
    # x_values are in [0, 1), so 1 - x_values**2 is in (0, 1]
    x_values = np.random.uniform(0, 1, num_points_N)

    # Calculate f(x_i) = sqrt(1 - x_i^2) for each x_i
    integrand_values = np.sqrt(1 - x_values**2)

    # The mean of these values approximates the integral of f(x) from 0 to 1
    mean_of_integrand = np.mean(integrand_values)

    # Estimate of pi/4 is mean_of_integrand
    # Estimate of pi is 4 * mean_of_integrand
    pi_estimate = 4 * mean_of_integrand
    return pi_estimate

# --- Part 2: Function to run multiple samples and get stats ---
def run_mc_integration_series(K_num_runs, N_points_per_run):
    """
    Runs a series of Pi estimations using MC integration and calculates statistics.

    Args:
        K_num_runs (int): The number of individual Pi estimation runs (e.g., 20).
                           This is K in the error analysis.
        N_points_per_run (int): The number of random points (N) used in each run.

    Returns:
        tuple: (mean_pi_estimate, std_dev_of_pi_estimates)
               The mean of the K Pi estimates, and the standard deviation of these K Pi estimates.
    """
    pi_estimates_from_runs = []
    for _ in range(K_num_runs):
        estimate = estimate_pi_mc_integration_single_run(N_points_per_run)
        pi_estimates_from_runs.append(estimate)

    pi_estimates_array = np.array(pi_estimates_from_runs)
    
    # Filter out NaN values that might result from N_points_per_run <= 0, if not handled earlier
    pi_estimates_array = pi_estimates_array[~np.isnan(pi_estimates_array)]
    if len(pi_estimates_array) == 0:
        return np.nan, np.nan

    mean_pi = np.mean(pi_estimates_array)
    # Std dev of the K individual Pi estimates (each derived from N points)
    std_dev_pi = np.std(pi_estimates_array) # ddof=0 by default

    return mean_pi, std_dev_pi

# --- Main execution block ---
if __name__ == '__main__':
    K_samples_for_stats = 100  # Number of samples (runs) to average for each N
    N_values = [100, 1000, 10000, 100000, 1000000, 10000000] # Points per Pi estimate

    exact_pi = np.pi
    
    # Store results for plotting
    mean_pi_estimates_for_each_N = []
    # std_dev_of_the_K_pi_estimates_for_each_N = [] # Standard deviation of the K estimates
    absolute_errors_of_mean = []

    print("--- Monte Carlo Integration for Pi: Error Convergence Analysis ---")
    for N_val in N_values:
        # For each N, get the mean of K Pi estimates and the std dev of those K estimates
        mean_pi_of_K_runs, std_dev_of_K_runs = run_mc_integration_series(K_samples_for_stats, N_val)

        if np.isnan(mean_pi_of_K_runs):
            print(f"\nN = {N_val:10,d} points per estimate: Skipped due to invalid input or all NaN results.")
            absolute_errors_of_mean.append(np.nan) # Placeholder for plotting
            mean_pi_estimates_for_each_N.append(np.nan)
            continue

        mean_pi_estimates_for_each_N.append(mean_pi_of_K_runs)
        # std_dev_of_the_K_pi_estimates_for_each_N.append(std_dev_of_K_runs)

        # Absolute error of the mean of K estimates
        error = np.abs(exact_pi - mean_pi_of_K_runs)
        absolute_errors_of_mean.append(error)

        print(f"\nN = {N_val:10,d} points per estimate:")
        print(f"  Number of samples (K) for stats: {K_samples_for_stats}")
        print(f"  Mean of {K_samples_for_stats} Pi Estimates: {mean_pi_of_K_runs:.8f}")
        print(f"  Std Dev of these {K_samples_for_stats} Pi Estimates: {std_dev_of_K_runs:.8f}")
        print(f"  Absolute Error (|Exact Pi - Mean of {K_samples_for_stats} Estimates|): {error:.3e}")

    # --- Part 4: Plotting the error convergence ---
    plt.figure(figsize=(10, 7))

    # Plot actual absolute error vs N
    plt.plot(N_values, absolute_errors_of_mean, marker='o', linestyle='-', color='dodgerblue',
             label=f'Actual Error: |$\pi_{{exact}}$ - Mean of {K_samples_for_stats} Estimates|')

    # Theoretical error scaling:
    # The standard deviation of a single Pi estimate from N points (sigma_P_N) is (4 * sigma_f) / sqrt(N)
    # where sigma_f = sqrt(Var(sqrt(1-x^2))) = sqrt( (2/3) - (pi/4)^2 ).
    sigma_f_val = np.sqrt((2/3) - (np.pi/4)**2) # Approx 0.2231
    # The error of the mean of K_samples_for_stats estimates is expected to be of the order of
    # Standard Error of Mean (SEM) = sigma_P_N / sqrt(K_samples_for_stats)
    # SEM = (4 * sigma_f_val) / (sqrt(N) * sqrt(K_samples_for_stats))
    # So, Error ~ C_theory / sqrt(N), where C_theory = (4 * sigma_f_val) / sqrt(K_samples_for_stats)
    
    C_theory = (4 * sigma_f_val) / np.sqrt(K_samples_for_stats) # Approx 0.1995 for K=20
    
    # Generate theoretical error line
    theoretical_error_line = [C_theory / np.sqrt(n_val) for n_val in N_values if n_val > 0]
    valid_N_values_for_theory = [n_val for n_val in N_values if n_val > 0]

    if theoretical_error_line: # Only plot if we have valid N values
        plt.plot(valid_N_values_for_theory, theoretical_error_line, marker='.', linestyle='--', color='red',
                 label=f'Theoretical Error Trend ($C/\\sqrt{{N}}$)\n$C = (4 \sigma_f) / \sqrt{{{K_samples_for_stats}}} \\approx {C_theory:.4f}$')

    plt.xscale('log')
    plt.yscale('log') # Vertical log scale as requested
    plt.xlabel('Number of Points per $\pi$ Estimate (N)')
    plt.ylabel('Absolute Error (log scale)')
    plt.title(f'Monte Carlo Integration for $\pi$: Error Convergence')
    plt.legend(loc='best')
    plt.grid(True, which="both", linestyle=':', alpha=0.7) # Grid for major and minor ticks
    plt.tight_layout()
    plt.show()

--- Monte Carlo Integration for Pi: Error Convergence Analysis ---

N =        100 points per estimate:
  Number of samples (K) for stats: 100
  Mean of 100 Pi Estimates: 3.13462908
  Std Dev of these 100 Pi Estimates: 0.08759975
  Absolute Error (|Exact Pi - Mean of 100 Estimates|): 6.964e-03

N =      1,000 points per estimate:
  Number of samples (K) for stats: 100
  Mean of 100 Pi Estimates: 3.13981985
  Std Dev of these 100 Pi Estimates: 0.02924496
  Absolute Error (|Exact Pi - Mean of 100 Estimates|): 1.773e-03

N =     10,000 points per estimate:
  Number of samples (K) for stats: 100
  Mean of 100 Pi Estimates: 3.14202810
  Std Dev of these 100 Pi Estimates: 0.00955622
  Absolute Error (|Exact Pi - Mean of 100 Estimates|): 4.354e-04

N =    100,000 points per estimate:
  Number of samples (K) for stats: 100
  Mean of 100 Pi Estimates: 3.14134207
  Std Dev of these 100 Pi Estimates: 0.00275560
  Absolute Error (|Exact Pi - Mean of 100 Estimates|): 2.506e-04

N =  1,000,000 points per estimate:
  Number of samples (K) for stats: 100
  Mean of 100 Pi Estimates: 3.14174607
  Std Dev of these 100 Pi Estimates: 0.00086131
  Absolute Error (|Exact Pi - Mean of 100 Estimates|): 1.534e-04

N = 10,000,000 points per estimate:
  Number of samples (K) for stats: 100
  Mean of 100 Pi Estimates: 3.14162938
  Std Dev of these 100 Pi Estimates: 0.00027357
  Absolute Error (|Exact Pi - Mean of 100 Estimates|): 3.673e-05

9.3.3 Importance Sampling in der Monte-Carlo-Integration¶

Die einfache Monte-Carlo-Integration (mit gleichverteilten Integrationspunkten) ist zwar schon recht brauchbar, noch besser ist allerdings das “Importance Sampling”. Bei dieser Technik werden die Samples nicht gleichmäßig über den Integrationsbereich verteilt, sondern gemäß einer Wahrscheinlichkeitsdichte, die idealerweise der Form der zu integrierenden Funktion ähnelt. Die Grundidee ist einfach, mehr Samples in jenen Bereichen zu platzieren, in denen $f(x)$ “wichtiger” ist (z.B. wo $|f(x)|$ groß ist oder sich stark ändert), und weniger Samples dort, wo $f(x)$ nahe Null bzw. nahezu konstant ist. Mathematisch formuliert den Integranden so um, dass er in zwei Funktionen zerlegt wird. Eine davon ($g$) dient dabei als Basis für eine (hoffentlich) bessere Verteilung, aus der gesampelt wird:

$$I = \int_a^b f(x) \, dx = \int_a^b \frac{f(x)}{g(x)} \cdot g(x) \, dx = E_g\left[ \frac{f(X)}{g(X)} \right]$$

$g(x)$ ist dabei also eine Wahrscheinlichkeitsdichte und $E_g$ bezeichnet den Erwartungswert bezüglich dieser Dichte. Mit diesem Importance Sampling approximieren wir das Integral daher als:

$$I \approx \frac{1}{N} \sum_{i=1}^{N} \frac{f(x_i)}{g(x_i)}$$

wobei die $x_i$ jetzt gemäß der Dichte $g(x)$ gezogen werden. Die Effizienz dieser Methode hängt stark von der Wahl einer geeigneten Funktion $g(x)$ ab, was in der Praxis eine Herausforderung darstellen kann, vor allem, wenn man die zu integrierende Funktion nicht in geschlossener Form kennt.

9.3.4 Höherdimensionale MC-Integration und Skalierung des Fehlers¶

Ein besonderer Vorteil der Monte-Carlo-Integration zeigt sich bei mehrdimensionalen Integralen:

$$I = \int_{D} f(\mathbf{x}) \, d\mathbf{x}$$

wobei $D$ ein mehrdimensionales Gebiet ist und $\mathbf{x} = (x_1, x_2, \ldots, x_d)$ ein $d$-dimensionaler Vektor. Klassische numerische Integrationsmethoden wie die uns bereits bekannte Trapezregel oder eine Gauß-Quadratur leiden in solchen Fällen besonders unter dem “Fluch der Dimensionalität”: Wenn wir beispielsweise $n$ Punkte pro Dimension verwenden, benötigen wir insgesamt $n^d$ Funktionsauswertungen in $d$ Dimensionen. Für ein dreidimensionales Integral mit nur 10 Punkten pro Dimension wären das bereits 1.000 Auswertungen. In 10 Dimensionen wären es 10 Milliarden! Ebenso wie die Anzahl der Integrationspunkte muss man hier auch die Fehlerrechnung der einzelnen Dimensionen in Kombination betrachten.

Bei der Monte-Carlo-Integration hingegen skaliert der Fehler mit $\frac{1}{\sqrt{N}}$ unabhängig von der Dimension des Problems. Dies macht die Monte-Carlo-Integration zu einer der wenigen praktikablen Methoden für hochdimensionale Integrale. Die Herausforderung liegt dann darin (eine Art abgeschwächte Form des Fluchs der Dimensionalität), das Sampling so reichhaltig oder gezielt zu steuern, dass genügend Punkte der Samples im Interessanten Bereich der Funktion liegen.

Die mehrdimensionale Monte-Carlo-Integration funktioniert analog zum eindimensionalen Fall:

Erzeuge $N$ zufällige Punkte $\mathbf{x}_1, \mathbf{x}_2, \ldots, \mathbf{x}_N$ gleichverteilt im Gebiet $D$.
Approximiere das Integral als:

$$I \approx \frac{V}{N} \sum_{i=1}^{N} f(\mathbf{x}_i)$$

wobei $V$ das Volumen von $D$ ist. Auch hier kann man mit Importance Sampling und weiteren fortgeschrittenen Methoden arbeiten, die die Treffsicherheit der Methode optimieren.

9.4 Übungsaufgabe: Abschätzung Fraktaler Dimension mit Monte-Carlo Methoden¶

Es klingt vielleicht etwas ungewöhnlich, aber in der Übungsaufgabe zu dieser Einheit möchte ich Ihnen die Möglichkeit zeigen, MC-Methoden zur Untersuchung fraktaler Strukturen einzusetzen. Konkret werden wir MC-Methoden anwenden, um eine faszinierende Eigenschaft geometrischer Objekte zu untersuchen: die fraktale Dimension. Dabei geht es im Prinzip darum, die Fraktale Struktur auf mehreren Skalen geometrisch zu untersuchen oder “abzutasten”. Wir werden das gleich im Detail angehen, doch zuvor ein paar Grundbegriffe zur Wiederholung bzw. Einführung.

9.4.1 Fraktale (Ultra-Crash-Course)¶

Fraktale sind geometrische Objekte, die besondere Eigenschaften aufweisen, darunter die Selbstähnlichkeit. Dies bedeutet, dass Teile des Objekts dem Ganzen ähnlich sind, unabhängig davon, auf welcher Skala man sie betrachtet. Einige bekannte Beispiele für Fraktale sind:

Die Koch-Kurve: Beginnend mit einer geraden Linie wird das mittlere Drittel durch zwei Seiten eines gleichseitigen Dreiecks ersetzt. Dieser Prozess wird dann rekursiv auf jede der resultierenden Linien angewandt.
Die Sierpinski-Dreiecke: Ausgehend von einem gleichseitigen Dreieck werden immer wieder die mittleren Dreiecke entfernt, wodurch eine selbstähnliche Struktur entsteht.
Die Mandelbrot-Menge: Ein komplexeres mathematisches Fraktal, das durch Iteration einer einfachen Gleichung in der komplexen Ebene entsteht.
Natürliche Fraktale: Viele Strukturen in der Natur wie Küstenlinien, Bäume, Blutgefäßsysteme oder Wolken weisen fraktale Eigenschaften auf. Solche Eigenschaften sind:

Die schon erwähnte Selbstähnlichkeit: Teile des Objekts ähneln dem Ganzen
Rekursive Definition: Viele Fraktale werden durch wiederholte Anwendung einfacher Regeln erzeugt
Detailreichtum auf allen Skalen: Bei Vergrößerung erscheinen immer neue Details
Nicht-ganzzahlige Dimension: Fraktale haben oft Dimensionen, die keine ganzen Zahlen sind

Die letzte Eigenschaft, die nicht-ganzzahlige oder “fraktale” Dimension, wird der Fokus unserer Übungsaufgabe sein.

9.4.2 Fraktale Dimension und wie man sie berechnet¶

Die fraktale Dimension ist ein Maß dafür, wie ein Objekt den Raum füllt, in dem es definiert ist. Sie verallgemeinert den intuitiven Begriff der Dimension (Linien sind eindimensional, Flächen zweidimensional usw.) auf Objekte mit komplexeren Strukturen. Stellen wir uns vor, wir haben ein Objekt mit der Dimension $D$. Wenn wir dieses Objekt um den Faktor $r$ in jede Richtung skalieren, wie verändert sich dann sein “Volumen” (oder allgemeiner: sein Maß)?

Für gewöhnliche Objekte gilt:

Eine Linie ($D=1$): Verdopplung der Länge → Verdopplung des Maßes
Ein Quadrat ($D=2$): Verdopplung der Seitenlänge → Vervierfachung des Maßes
Ein Würfel ($D=3$): Verdopplung der Kantenlänge → Verachtfachung des Maßes

Allgemein: Wenn wir ein Objekt mit Dimension $D$ um den Faktor $r$ skalieren, verändert sich sein Maß um den Faktor $r^D$. Bei Fraktalen gibt es mehrere Methoden, um ihre Dimension zu bestimmen. Wir benutzen hier eine Methode, die sich dann zur Berechnung mittels MC-Methode eignet.

In dieser Übung sollen Sie die fraktale Dimension eines digital generierten Sierpinski-Teppichs mithilfe der Masse-Radius-Methode (auch als “Masse-in-einer-Box”-Methode bekannt) abschätzen. Das Fraktal ist dabei als png-Bild gespeichert, in dem es schwarze (Teppich) und weiße (Löcher) Punkte gibt, siehe unten. Sie werden Monte-Carlo-Techniken zur Auswahl von Mittelpunkten auf dem Fraktal verwenden und die Skalierung der Masse mit der Größe der Beobachtungsbox analysieren. Damit ist folgendes gemeint:

Man wählt einen Punkt (Pixel) aus, der auf dem Fraktal liegt (schwarz). Dann sieht man sich eine Box (also ein Quadrat) an, in dessen Mitte der ausgewählte Punkt liegt. Um das einfach zu machen, nehmen wir Quadrate mit einer Seitenlänge von $2L+1$ an. $L$ kann dabei Werte von 1 bis zu einer Größe annehmen, die noch in das ganze Bild passt. Die Masse $M$ in der Box ist dann die Anzahl der Pixel, die zum Fraktal gehören (also alle schwarzen Pixel). Der Weg zur Fraktalen Dimension geht man, indem man diese Masse für verschiedene Werte von $L$ berechnet, denn $L$ entspricht einer einer Meßskala. Wenn man beim Plotten der Masse in Abhängigkeit von der Skala ein Potenzgesetz findet, dann hat man: $$M(L)\propto L^D$$

wobei $D$ die fraktale Dimension ist. Durch Auftragen von $\log(M(L))$ gegen $\log(L)$ kann $D$ als Steigung der resultierenden Geraden bestimmt werden.

9.4.3 Monte-Carlo-Berechnung der fraktalen Dimension¶

Die Monte-Carlo-Herangehensweise hilft uns nun dabei, mit unserem üblichen System der Berechnung des Means of Sample-Means und der zugehörigen Standardabweichung für verschiedene Skalen ($L$) den Wert von $M$ zu ermitteln. Sampeln Sie daher mit einer Samplegröße von 100 Punkten (oder weniger) über 10-20 Samples die Größe $M$. Analysieren Sie den Zusammenhang von $\log(M(L))$ und $\log(L)$ und suchen Sie nach einer Power-Law-Abhängigkeit.

9.4.4 Aufgabenstellung¶

Die konkreten Schritte sind:

Laden Sie das Bild (sierpinski_carpet_N8_6561x6561.png) und verwandeln Sie es in ein numpy-Array mit schwarzen und weißen Pixel
Implementieren Sie die Massen-Berechnung
Definieren Sie eine geeignete Folge von Skalen $L$
Implementieren Sie die MC-Simulation
Sammeln Sie die Daten über alle Skalen, plotten und analysieren Sie die Ergebnisse Viel Vergnügen!

9.4.5 Vorbereitung: Erzeugen eines Bildes des Sierpinski-Teppichs¶

In [42]:

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import pickle
import os # For checking file sizes

def generate_sierpinski_carpet(n_levels):
    """
    Generates a Sierpinski carpet as a NumPy array.
    0 represents the carpet (black), 1 represents holes (white).

    Args:
        n_levels (int): The number of recursive levels (N in 3^N x 3^N).

    Returns:
        numpy.ndarray: A 2D NumPy array representing the Sierpinski carpet.
    """
    if not isinstance(n_levels, int) or n_levels < 0:
        raise ValueError("n_levels (N) must be a non-negative integer.")

    image_side_length = 3**n_levels
    
    # Initialize the carpet: 0 for black (carpet material), 1 for white (holes)
    # Start with a fully black carpet.
    carpet_array = np.zeros((image_side_length, image_side_length), dtype=np.uint8)

    # Recursive helper function to "punch holes"
    def _create_holes_recursive(arr, x_start, y_start, current_side, current_level, max_level):
        # Base case: if we've reached the desired number of iterations, stop
        if current_level >= max_level:
            return

        # Size of the sub-squares (integer division)
        sub_square_side = current_side // 3

        # If sub_square_side is 0, it means current_side was < 3, so no more holes can be punched.
        if sub_square_side == 0:
            return

        # Calculate coordinates for the central hole
        hole_y_start_idx = y_start + sub_square_side
        hole_y_end_idx = y_start + 2 * sub_square_side
        hole_x_start_idx = x_start + sub_square_side
        hole_x_end_idx = x_start + 2 * sub_square_side

        # "Punch" the central hole by setting its pixels to 1 (white)
        arr[hole_y_start_idx:hole_y_end_idx, hole_x_start_idx:hole_x_end_idx] = 1

        # Recursively call for the 8 surrounding sub-squares
        next_level = current_level + 1
        for i in range(3):
            for j in range(3):
                # Skip the central square (which is now a hole)
                if i == 1 and j == 1:
                    continue
                
                new_x_start = x_start + i * sub_square_side
                new_y_start = y_start + j * sub_square_side
                _create_holes_recursive(arr, new_x_start, new_y_start, sub_square_side, next_level, max_level)
    
    # Initial call to the recursive function
    # Starts with level 0, up to n_levels (exclusive for current_level in recursive calls)
    _create_holes_recursive(carpet_array, 0, 0, image_side_length, 0, n_levels)
    
    return carpet_array

# --- Main execution ---
if __name__ == "__main__":
    N = 5  # Number of levels for the Sierpinski carpet (size will be 3^N x 3^N)
    # For N=7, size is 2187x2187 pixels.
    # For N=6, size is 729x729 pixels.
    # For N=5, size is 243x243 pixels.

    image_dimension = 3**N
    base_filename = f"sierpinski_carpet_N{N}_{image_dimension}x{image_dimension}"

    print(f"Generating Sierpinski carpet for N={N} (size: {image_dimension}x{image_dimension})...")
    try:
        sierpinski_array = generate_sierpinski_carpet(N)
        print("Sierpinski carpet array generated successfully.")

        # Option 1: Save as a 1-bit PNG file using Pillow
        png_filepath = base_filename + ".png"
        try:
            pil_image = Image.fromarray(255*sierpinski_array, mode='L')
            pil_image.save(png_filepath, optimize=False) # optimize=True can reduce file size
        except ImportError:
            print("Pillow library (PIL) not found. Cannot save as PNG.")
            print("Please install it using: pip install Pillow")
        except Exception as e:
            print(f"An error occurred while saving PNG: {e}")

    except ValueError as ve:
        print(f"Error in parameter: {ve}")
    except Exception as general_e:
        print(f"An unexpected error occurred: {general_e}")

    print("Beispiel-Plot für N=5:")
    plt.matshow(sierpinski_array, cmap='gray')

Generating Sierpinski carpet for N=5 (size: 243x243)...
Sierpinski carpet array generated successfully.
Beispiel-Plot für N=5:

Und nun eine Musterlösung der Übungsaufgabe:

In [36]:

import numpy as np
from PIL import Image
import matplotlib.pyplot as plt
import random
import time
from scipy.stats import linregress # For fitting the line

# --- 1. Load Image and Prepare Data ---
def load_and_prepare_image(image_path):
    """
    Loads a PNG image, converts it to a binary NumPy array,
    and extracts coordinates of fractal pixels.
    Assumes input image has 0 for black (fractal) and 255 for white (background).
    Output binary_image has 1 for fractal, 0 for background.
    """
    try:
        print(f"Loading image from: {image_path}")
        img_pil = Image.open(image_path).convert('L') # Ensure grayscale
        img_array_loaded = np.array(img_pil)
        
        # Convert to binary: 1 for fractal (original black), 0 for background
        # Assuming black (carpet) pixels are 0 and white (holes) are 255 in the input image.
        binary_image = (img_array_loaded == 0).astype(np.uint8) 
        
        fractal_pixel_coords = np.argwhere(binary_image == 1) # Get (row, col) or (y, x)
        
        if fractal_pixel_coords.size == 0:
            raise ValueError("No fractal pixels (value 1 after conversion) found. Check image loading and thresholding.")
            
        print(f"Image loaded successfully: {binary_image.shape[0]}x{binary_image.shape[1]} pixels.")
        print(f"Found {len(fractal_pixel_coords)} fractal pixels.")
        return binary_image, fractal_pixel_coords
    except FileNotFoundError:
        print(f"Error: Image file not found at '{image_path}'. Please ensure the path is correct.")
        return None, None
    except Exception as e:
        print(f"Error loading or processing image: {e}")
        return None, None

# --- 2. Implement Mass Measurement Function ---
def measure_mass_in_square(binary_image_array, center_y, center_x, half_side_n):
    """
    Measures the mass (number of fractal pixels, i.e., sum of 1s) 
    in a square of side length (2*half_side_n + 1) centered at (center_y, center_x).
    Handles image boundaries by summing only within valid image coordinates.
    """
    img_height, img_width = binary_image_array.shape
    
    # Define the bounds of the square neighborhood
    y_min = max(0, center_y - half_side_n)
    y_max = min(img_height, center_y + half_side_n + 1) # Slice end is exclusive
    x_min = max(0, center_x - half_side_n)
    x_max = min(img_width, center_x + half_side_n + 1) # Slice end is exclusive
    
    # Extract the neighborhood and sum the fractal pixels (where value is 1)
    neighborhood = binary_image_array[y_min:y_max, x_min:x_max]
    mass = np.sum(neighborhood)
    return mass

# --- Main Analysis Function ---
def run_mass_radius_analysis(image_path, list_of_n_values, 
                             num_centers_per_exp, num_experiments):
    """
    Performs the mass-radius analysis by sampling points from the fractal.
    Returns lists of L values, mean masses, and std devs of mean masses.
    """
    binary_image, all_fractal_coords = load_and_prepare_image(image_path)
    if binary_image is None or all_fractal_coords.size == 0:
        print("Failed to load or process image data. Aborting analysis.")
        return [], [], []

    img_height, img_width = binary_image.shape
    
    results_L_values = []
    results_mean_of_means_mass = []
    results_std_dev_of_means_mass = []

    total_fractal_pixels = len(all_fractal_coords)

    for n_val in list_of_n_values:
        current_L_value = 2 * n_val + 1
        print(f"\nProcessing scale L = {current_L_value} (n = {n_val})...")
        
        # For this method, any fractal pixel can be a center.
        # The measure_mass_in_square function handles boundaries.
        # We don't need to filter centers unless L is very large relative to image size
        # and we want to avoid too many truncated boxes, but averaging helps.

        if total_fractal_pixels == 0:
            print("  No fractal pixels to sample centers from. Skipping scale.")
            continue
        
        experiment_mean_masses_for_this_L = [] # Store the mean mass from each experiment

        for exp_idx in range(num_experiments):
            batch_masses_for_current_experiment = []
            
            # Sample 'num_centers_per_exp' indices from all_fractal_coords
            # Using np.random.choice for potentially large arrays.
            # With replacement is fine and simpler if num_centers_per_exp can be > total_fractal_pixels (unlikely here).
            # If sampling without replacement, ensure num_centers_per_exp <= total_fractal_pixels.
            
            num_to_sample = min(num_centers_per_exp, total_fractal_pixels)
            if num_to_sample == 0 : continue # Should not happen if total_fractal_pixels > 0

            # replace=True allows sampling more than available if needed, but usually we want unique centers if possible.
            # Let's stick to sampling 'num_to_sample' without replacement if possible, or with if needed.
            use_replacement = num_centers_per_exp > total_fractal_pixels
            
            sampled_indices = np.random.choice(total_fractal_pixels, 
                                               size=num_centers_per_exp, 
                                               replace=use_replacement)
            
            centers_for_this_batch = all_fractal_coords[sampled_indices]

            for center_y, center_x in centers_for_this_batch:
                mass = measure_mass_in_square(binary_image, center_y, center_x, n_val)
                batch_masses_for_current_experiment.append(mass)
            
            if batch_masses_for_current_experiment:
                mean_mass_this_experiment = np.mean(batch_masses_for_current_experiment)
                experiment_mean_masses_for_this_L.append(mean_mass_this_experiment)
        
        if not experiment_mean_masses_for_this_L:
            print(f"  No mass data collected for L={current_L_value}. Possible issue with sampling or small N. Skipping.")
            continue

        # Calculate the mean of these experiment means, and their standard deviation
        final_mean_M_L = np.mean(experiment_mean_masses_for_this_L)
        final_std_dev_M_L = np.std(experiment_mean_masses_for_this_L) # Std dev of the means
        
        results_L_values.append(current_L_value)
        results_mean_of_means_mass.append(final_mean_M_L)
        results_std_dev_of_means_mass.append(final_std_dev_M_L)
        
        print(f"  L={current_L_value}: Mean of ({num_experiments}) Mean Masses = {final_mean_M_L:.2f}, "
              f"StdDev of these Means = {final_std_dev_M_L:.3f}")

    return results_L_values, results_mean_of_means_mass, results_std_dev_of_means_mass

# --- 6. Visualize Results and Fit for Power Law ---
def visualize_and_fit_results(L_values, mean_mass_values, std_dev_of_means):
    if not L_values or not mean_mass_values:
        print("No data available for visualization.")
        return

    # Filter out non-positive values before taking log, if any (e.g. if mass was 0)
    valid_indices = [i for i, m in enumerate(mean_mass_values) if m > 0]
    if not valid_indices:
        print("No positive mean mass values to plot on log scale.")
        return
        
    L_values_log = np.log([L_values[i] for i in valid_indices])
    mean_mass_log = np.log([mean_mass_values[i] for i in valid_indices])
    # Std dev of means can be used for error bars, but interpretation on log plot needs care.
    # For now, we'll plot points and fit.

    plt.figure(figsize=(10, 7))
    plt.plot(L_values_log, mean_mass_log, 'o', markersize=8, alpha=0.7, label='Log(Mean Mass) vs Log(L)')
    
    # Attempt to fit a line to the log-log data to find the slope (Fractal Dimension)
    # Students should be encouraged to inspect the plot and select an appropriate range for fitting.
    # Here, we'll try to fit a central portion or all if few points.
    if len(L_values_log) >= 2: # Need at least 2 points for a line
        # Heuristic for fitting range (e.g., middle 50% of points if enough points)
        num_pts_log = len(L_values_log)
        fit_start_idx = num_pts_log // 4
        fit_end_idx = (3 * num_pts_log // 4) 
        if fit_end_idx <= fit_start_idx : # if too few points, use all available for fit.
             fit_start_idx = 0
             fit_end_idx = num_pts_log
        if fit_end_idx - fit_start_idx < 2 and num_pts_log >=2: # ensure at least 2 points
            fit_start_idx = 0
            fit_end_idx = num_pts_log


        if fit_end_idx - fit_start_idx >= 2:
            try:
                slope, intercept, r_value, p_value, std_err = linregress(
                    L_values_log[fit_start_idx:fit_end_idx], 
                    mean_mass_log[fit_start_idx:fit_end_idx]
                )
                print(f"\n--- Linear Regression Fit (Log-Log Scale) ---")
                print(f"Fit Range (log_L indices): {fit_start_idx} to {fit_end_idx-1}")
                print(f"  Estimated Fractal Dimension (Slope D): {slope:.4f}")
                print(f"  Intercept: {intercept:.4f}")
                print(f"  R-squared: {r_value**2:.4f}")
                print(f"  Standard error of the slope: {std_err:.4f}")
                
                # Plot the fitted line
                L_fit_plot = np.array(L_values_log) # Use all L values for plotting the line extent
                mass_fit_plot = slope * L_fit_plot + intercept
                plt.plot(L_fit_plot, mass_fit_plot, 'r--', linewidth=2,
                         label=f'Fit: D = {slope:.3f} (R²={r_value**2:.3f})')
            except Exception as e:
                print(f"Could not perform linear regression: {e}")
        else:
            print("Not enough data points in selected range for a meaningful linear fit.")
    else:
        print("Not enough data points for linear regression.")

    plt.xlabel('Log(L) (L = side length of square)')
    plt.ylabel('Log(Mean Mass)')
    plt.title(f'Mass-Radius Method (Squares) - Fractal Dimension Estimation')
    plt.legend()
    plt.grid(True, which="both", linestyle=':', alpha=0.7)
    plt.show()

# --- Main Execution ---
if __name__ == '__main__':
    # IMPORTANT: Students should replace this with the actual path to their generated image
    # For N=8 (6561x6561), use: "sierpinski_carpet_N8_6561x6561_grayscale.png"
    # For N=7 (2187x2187), use: "sierpinski_carpet_N7_2187x2187_grayscale.png"
    # Ensure this file exists in the same directory as the script, or provide a full path.
    IMAGE_FILENAME = "sierpinski_carpet_N8_6561x6561.png" 
    
    # Define scales 'n' (half_side_n for square of side 2n+1).
    # L = 2n+1. Example: n=1 -> L=3; n=2 -> L=5; n=4 -> L=9, etc.
    # These values should be chosen based on image size. Max L should be < image_size/2.
    # For 2187x2187 (N=7), max n could be ~500 (L~1001).
    # For 6561x6561 (N=8), max n could be ~1500 (L~3001).
    # Using a geometric-like progression for n:
    n_values_to_test = [1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233] # Fibonacci-like for L spread
    # Max n=233 => L = 467. This should be fine for N=7 and N=8 images.
    # Filter n_values if L gets too large for smaller images if necessary, but this range is likely okay.

    # Monte Carlo parameters
    num_centers_to_sample_per_experiment = 100 # Number of random centers to average mass over
    num_experiments = 20                       # Number of times to repeat the above to get stats on the mean mass

    print("Starting Mass-Radius Analysis for Fractal Dimension...")
    start_time = time.time()
    
    L_results, mean_mass_results, std_dev_results = run_mass_radius_analysis(
        IMAGE_FILENAME, 
        n_values_to_test, 
        num_centers_to_sample_per_experiment, 
        num_experiments
    )
    
    end_time = time.time()
    total_time = end_time - start_time
    print(f"\n--- Analysis Complete ---")
    print(f"Total execution time: {total_time:.2f} seconds ({total_time/60:.2f} minutes).")

    if L_results and mean_mass_results:
        visualize_and_fit_results(L_results, mean_mass_results, std_dev_results)
    else:
        print("Analysis did not yield results to visualize. Please check for errors above.")

Starting Mass-Radius Analysis for Fractal Dimension...
Loading image from: sierpinski_carpet_N8_6561x6561.png
Image loaded successfully: 6561x6561 pixels.
Found 16777216 fractal pixels.

Processing scale L = 3 (n = 1)...
  L=3: Mean of (20) Mean Masses = 7.20, StdDev of these Means = 0.118

Processing scale L = 5 (n = 2)...
  L=5: Mean of (20) Mean Masses = 18.93, StdDev of these Means = 0.258

Processing scale L = 7 (n = 3)...
  L=7: Mean of (20) Mean Masses = 36.01, StdDev of these Means = 0.493

Processing scale L = 11 (n = 5)...
  L=11: Mean of (20) Mean Masses = 83.07, StdDev of these Means = 1.478

Processing scale L = 17 (n = 8)...
  L=17: Mean of (20) Mean Masses = 190.71, StdDev of these Means = 2.521

Processing scale L = 27 (n = 13)...
  L=27: Mean of (20) Mean Masses = 454.82, StdDev of these Means = 7.009

Processing scale L = 43 (n = 21)...
  L=43: Mean of (20) Mean Masses = 1108.88, StdDev of these Means = 19.697

Processing scale L = 69 (n = 34)...
  L=69: Mean of (20) Mean Masses = 2681.40, StdDev of these Means = 35.261

Processing scale L = 111 (n = 55)...
  L=111: Mean of (20) Mean Masses = 6606.84, StdDev of these Means = 75.998

Processing scale L = 179 (n = 89)...
  L=179: Mean of (20) Mean Masses = 16199.92, StdDev of these Means = 211.542

Processing scale L = 289 (n = 144)...
  L=289: Mean of (20) Mean Masses = 39526.37, StdDev of these Means = 636.025

Processing scale L = 467 (n = 233)...
  L=467: Mean of (20) Mean Masses = 96514.25, StdDev of these Means = 1557.088

--- Analysis Complete ---
Total execution time: 220.30 seconds (3.67 minutes).

--- Linear Regression Fit (Log-Log Scale) ---
Fit Range (log_L indices): 3 to 8
  Estimated Fractal Dimension (Slope D): 1.8921
  Intercept: -0.1135
  R-squared: 1.0000
  Standard error of the slope: 0.0028

In [ ]:

FMCA-25 08: Schwärme und Emergenz

Inhalt des Skriptums seit dem Sommersemester 2025

Hier finden Sie die Kapitel aus den Vergangenen Jahren (legacy):

Die Jupyter-Notebooks zur Legacy-Variante der Lehrveranstaltung finden Sie im zugehörigen GitHub-Repository.

8: Schwärme und Emergenz¶

Nicht nur in der Natur lassen sich oft Schwärme beobachten, die scheinbar mühelos gemeinsame Bewegungen ausführen, einen Staat organisieren oder komplexe Probleme lösen (wie z.B. Futter zu finden und in ein Nest zu transportieren). Auch in anderen Bereichen bis hin zur Optimierung kann man bewusst Schwarm-Algorithmen einsetzen um Probleme zu lösen oder Systeme von Individuen zu steuern. In dieser Einheit geht es darum, wie so etwas funktioniert und welche Regeln und Phänomene dabei eine Rolle spielen.

Nach dem Studium dieser Einheit sollten Sie zumindest folgende drei der wichtigsten Punkte hier verstehen:¶

Was man unter einem Schwarm versteht und nach welchen Regeln er funktionieren kann.
Welche Beispiele es für Schwarm-Verhalten gibt, und welche interessanten Dinge wir aus ihnen lernen können.
Was Emergenz bedeutet und wodurch sie zustande kommt.

8.1. Grundbausteine emergenten Verhaltens und der Schwarm-Intelligenz¶

Man hört immer wieder von Schwarm-Intelligenz und etwas weniger oft von emergentem Verhalten. Bevor wir uns konkret mit den möglichen Ausformungen solcher Prinzipien befassen können, müssen wir zunächst verstehen, welche Mechanismen dabei zusammenwirken.

8.1.1 Grundbegriffe¶

Ein Schwarm bezeichnet eine Gruppe von Individuen, die durch lokale Interaktionen kollektives Verhalten zeigen. Im Gegensatz zu hierarchisch organisierten Gruppen existiert in einem Schwarm keine zentrale Kontrollinstanz. Der Begriff “Kollektiv” wird oft synonym verwendet, betont aber stärker den Aspekt der gemeinsamen Eigenschaft oder Handlung aller Individuen.

Die Individuen oder Agenten sind die grundlegenden Einheiten eines Schwarms. Sie können biologische Organismen (Ameisen, Vögel) oder virtuelle Entitäten (Partikel in einem Optimierungsalgorithmus, simulierte Roboter) sein. Entscheidend ist, dass jeder Agent über folgende Eigenschaften verfügt:

Lokale Wahrnehmung seiner Umgebung
Begrenzte Informationsverarbeitung und Entscheidungsfähigkeit
Fähigkeit, mit anderen Agenten zu interagieren oder zu kommunizieren
Autonomie bei der Ausführung einfacher Verhaltensregeln

Die Umgebung ist der Raum, in dem sich die Agenten bewegen und interagieren. Sie kann physisch (der dreidimensionale Raum für Vogelschwärme) oder abstrakt sein (der Lösungsraum eines Optimierungsproblems). Die Umgebung beeinflusst das Verhalten der Agenten und kann durch diese modifiziert werden – ein Prozess, der insbesondere für die Stigmergie (indirekte Kommunikation über Umgebungsveränderungen) zentral ist.

Nachbarschaft bezeichnet den begrenzten Bereich um einen Agenten, innerhalb dessen er andere Agenten wahrnimmt und mit ihnen interagiert. Die Definition der Nachbarschaft kann räumlich (alle Agenten innerhalb eines bestimmten Radius) oder topologisch (die $n$ nächsten Agenten, unabhängig von ihrer Entfernung) sein. Die Beschränkung auf lokale Nachbarschaften ist ein Schlüsselelement für die Skalierbarkeit von Schwarm-Systemen.

Emergenz beschreibt das Auftreten von Eigenschaften oder Verhaltensweisen auf Systemebene, die nicht direkt in den Regeln der einzelnen Agenten kodiert sind. Ein emergentes Phänomen lässt sich nicht durch einfache Summierung der Eigenschaften einzelner Systemkomponenten erklären, sondern entsteht aus deren komplexen Interaktionen. Beispiele sind Musterbildung, kollektive Entscheidungsfindung oder koordinierte Bewegung.

Selbstorganisation bezeichnet die Fähigkeit eines Systems, ohne externe Steuerung oder zentralen Plan Ordnung oder Struktur zu entwickeln. Sie basiert auf lokalen Interaktionen zwischen den Systemkomponenten und Rückkopplungsmechanismen. Zum Beispiel führt Selbstorganisation in Schwärmen zu adaptivem Verhalten, das dynamisch auf Umgebungsveränderungen reagieren kann.

Soviel zu den Grundbegriffen. Damit können wir uns jetzt zunächst die Mechanismen und dann diverse Phänomene ansehen, die Schwarmverhalten bestimmen und hervorbringen können.

8.1.2 Lokale Interaktionen und einfache Regeln¶

Ein Vogelschwarm, der in perfekter Synchronisation Richtungswechsel vollführt. Eine Ameisenkolonie, die ohne zentrale Koordination effiziente Wege zu Nahrungsquellen findet. Termiten, die komplexe Bauten mit ausgeklügelten Belüftungssystemen errichten. All diese beeindruckenden kollektiven Verhaltensweisen basieren auf einem überraschend einfachen Prinzip: Lokale Interaktionen zwischen gleichartigen Individuen, die simplen Regeln folgen.

Im Gegensatz etwa zu zentralisierten Systemen, in denen eine übergeordnete Instanz alle Aktivitäten koordiniert, nehmen Individuen in Schwärmen nur ihre unmittelbare Umgebung wahr. Eine Ameise “weiß” nichts über die Gesamtstruktur der Kolonie oder die globale Verteilung von Nahrungsquellen. Ein Vogel im Schwarm sieht nur bzw. achtet nur auf seine direkten Nachbarn. Diese beschränkte Wahrnehmung hat einen entscheidenden Vorteil: Sie reduziert die Komplexität der Entscheidungsfindung drastisch und ermöglicht schnelle, robuste Reaktionen auf lokale Veränderungen.

Die Entscheidungsregeln in solchen Systemen sind typischerweise sehr einfach. Als Beispiel kommen etwa folgende drei Regeln in Frage:

Separation: Halte einen Mindestabstand zu deinen Nachbarn
Angleichung: Bewege dich in die gleiche Richtung wie deine Nachbarn
Zusammenhalt: Bewege dich in Richtung des Zentrums deiner lokalen Nachbarschaft

Diese Regeln sind leicht zu verstehen und auch computertechnisch einfach umzusetzen. Dennoch erzeugen sie in ihrer Kombination verblüffend realistische Schwärme, die auf Hindernisse reagieren, sich aufteilen und wieder zusammenfinden können – ohne dass dieses komplexe Verhalten explizit programmiert wurde.

Sehen wir uns das gleich einmal in einem Beispiel an. Die Code-Snippets kommen diesmal von Gemini 2.5 pro.

In [2]:

import os
os.environ['MKL_DISABLE_FAST_MM'] = '1'
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from IPython.display import HTML # For displaying the animation in Jupyter
import matplotlib as mpl

# Set the animation embed limit to 50 MB (or your desired size in MB)
mpl.rcParams['animation.embed_limit'] = 200  # The value is in Megabytes

# Parameters for the simulation
NUM_BOIDS = 150
WIDTH = 600  # Width of the simulation area
HEIGHT = 400 # Height of the simulation area
MAX_SPEED = 5.0
MIN_SPEED = 2.0
PERCEPTION_RADIUS = 75.0 # How far a boid can see
AVOIDANCE_RADIUS = 15.0  # Radius to avoid other boids

# Weights for the three rules
COHESION_FACTOR = 0.05
ALIGNMENT_FACTOR = 0.5
SEPARATION_FACTOR = 0.15
TURN_FACTOR = 0.2 # How quickly boids can turn

# Boundaries for screen wrapping
MARGIN = 50

class Boid:
    def __init__(self, x, y):
        self.position = np.array([float(x), float(y)])
        angle = np.random.uniform(0, 2 * np.pi)
        self.velocity = np.array([np.cos(angle), np.sin(angle)]) * MAX_SPEED
        self.acceleration = np.zeros(2, dtype=float)

    def update(self):
        # Apply acceleration
        self.velocity += self.acceleration
        
        # Limit speed
        speed = np.linalg.norm(self.velocity)
        if speed > MAX_SPEED:
            self.velocity = (self.velocity / speed) * MAX_SPEED
        elif speed < MIN_SPEED:
             self.velocity = (self.velocity / speed) * MIN_SPEED
            
        self.position += self.velocity
        self.acceleration = np.zeros(2, dtype=float) # Reset acceleration

    def apply_force(self, force):
        self.acceleration += force

    def screen_wrap(self):
        if self.position[0] > WIDTH + MARGIN:
            self.position[0] = -MARGIN
        elif self.position[0] < -MARGIN:
            self.position[0] = WIDTH + MARGIN
        if self.position[1] > HEIGHT + MARGIN:
            self.position[1] = -MARGIN
        elif self.position[1] < -MARGIN:
            self.position[1] = HEIGHT + MARGIN

    def steer(self, target_direction):
        desired = target_direction - self.position
        desired_norm = np.linalg.norm(desired)
        
        if desired_norm > 0:
            desired = (desired / desired_norm) * MAX_SPEED
        
        steer = desired - self.velocity
        steer_norm = np.linalg.norm(steer)
        
        if steer_norm > TURN_FACTOR: # Limit the turning force
            steer = (steer / steer_norm) * TURN_FACTOR
            
        return steer

    def cohesion(self, boids):
        center_of_mass = np.zeros(2, dtype=float)
        count = 0
        for other in boids:
            if other is not self:
                distance = np.linalg.norm(self.position - other.position)
                if 0 < distance < PERCEPTION_RADIUS:
                    center_of_mass += other.position
                    count += 1
        if count > 0:
            center_of_mass /= count
            return self.steer(center_of_mass) * COHESION_FACTOR
        return np.zeros(2, dtype=float)

    def alignment(self, boids):
        avg_velocity = np.zeros(2, dtype=float)
        count = 0
        for other in boids:
            if other is not self:
                distance = np.linalg.norm(self.position - other.position)
                if 0 < distance < PERCEPTION_RADIUS:
                    avg_velocity += other.velocity
                    count += 1
        if count > 0:
            avg_velocity /= count
            # Steer towards the average velocity
            desired = avg_velocity
            desired_norm = np.linalg.norm(desired)
            if desired_norm > 0:
                desired = (desired / desired_norm) * MAX_SPEED
            
            steer = desired - self.velocity
            steer_norm = np.linalg.norm(steer)
            if steer_norm > TURN_FACTOR:
                steer = (steer / steer_norm) * TURN_FACTOR
            return steer * ALIGNMENT_FACTOR
        return np.zeros(2, dtype=float)

    def separation(self, boids):
        steering_force = np.zeros(2, dtype=float)
        count = 0
        for other in boids:
            if other is not self:
                distance = np.linalg.norm(self.position - other.position)
                if 0 < distance < AVOIDANCE_RADIUS: # Use a smaller radius for separation
                    diff = self.position - other.position
                    steering_force += diff / (distance * distance) # Force inversely proportional to square of distance
                    count += 1
        if count > 0:
            steering_force /= count # Average the force
            # Steer away
            desired = steering_force
            desired_norm = np.linalg.norm(desired)
            if desired_norm > 0:
                desired = (desired / desired_norm) * MAX_SPEED
            
            steer = desired - self.velocity
            steer_norm = np.linalg.norm(steer)
            if steer_norm > TURN_FACTOR:
                steer = (steer / steer_norm) * TURN_FACTOR
            return steer * SEPARATION_FACTOR
        return np.zeros(2, dtype=float)

    def apply_rules(self, boids):
        cohesion_force = self.cohesion(boids)
        alignment_force = self.alignment(boids)
        separation_force = self.separation(boids)
        
        self.apply_force(cohesion_force)
        self.apply_force(alignment_force)
        self.apply_force(separation_force)


# Initialize boids
boids = [Boid(np.random.uniform(0, WIDTH), np.random.uniform(0, HEIGHT)) for _ in range(NUM_BOIDS)]

# Matplotlib setup
fig, ax = plt.subplots(figsize=(10, 7.5)) # Adjusted for better aspect ratio
ax.set_xlim(0, WIDTH)
ax.set_ylim(0, HEIGHT)
ax.set_xticks([]) # Remove x-axis ticks
ax.set_yticks([]) # Remove y-axis ticks
ax.set_facecolor('lightgrey') # Background color

# Using quivers to represent boids (arrows showing direction)
# We need to store the quiver objects to update them
quivers = []
for boid in boids:
    # Initial quiver plot for each boid
    # Scale the velocity for better arrow representation
    # The head_width, head_length, etc., might need tweaking based on MAX_SPEED
    q = ax.quiver(boid.position[0], boid.position[1], 
                  boid.velocity[0], boid.velocity[1], 
                  color='blue', scale=50, headwidth=4, headlength=6) # Adjust scale and head
    quivers.append(q)

def update_frame(frame_number):
    # Update positions and velocities of boids
    for boid in boids:
        boid.apply_rules(boids)
        boid.update()
        boid.screen_wrap()

    # Update the quiver plots
    for i, boid in enumerate(boids):
        quivers[i].set_offsets(boid.position)
        # Normalize velocity for direction if MAX_SPEED is large, or scale it down
        # This ensures arrows don't become excessively long
        vel_norm = np.linalg.norm(boid.velocity)
        if vel_norm > 0:
            uv = boid.velocity / vel_norm 
        else:
            uv = np.zeros(2) # In case velocity is zero
        quivers[i].set_UVC(uv[0], uv[1])
        
    return quivers

# Create animation
# interval is the delay between frames in milliseconds.
# Adjust blit=True for potentially smoother animation if it works well on your system.
# blit=False is often more robust.
ani = FuncAnimation(fig, update_frame, frames=400, interval=50, blit=False)

# Display the animation in Jupyter Notebook
plt.close(fig) # Prevent static plot from displaying


# ani.save('boid_simulation.mp4', writer='ffmpeg', fps=30)
HTML(ani.to_jshtml()) # or use ani.to_html5_video()

8.1.3 Rückkopplungsmechanismen¶

Rückkopplungsmechanismen sind ein zentraler Baustein selbstorganisierender Systeme. Sie beschreiben, wie die Aktionen der Individuen ihre Umgebung verändern und wie diese Veränderungen wiederum das Verhalten der Individuen beeinflussen. Es gibt zwei Haupttypen: positive und negative Rückkopplung.

Positive Rückkopplung verstärkt Veränderungen und kann zu explosionsartigen Entwicklungen führen. Sie wirkt wie ein Schneeball, der beim Rollen immer größer wird. Ein klassisches Beispiel ist die Pheromonablagerung bei Ameisen: Wenn eine Ameise eine ergiebige Nahrungsquelle findet, hinterlässt sie auf dem Rückweg zum Nest eine Pheromonspur. Andere Ameisen folgen dieser Spur, finden ebenfalls Nahrung und verstärken die Pheromonspur auf ihrem Rückweg. Je mehr Ameisen den Pfad nutzen, desto attraktiver wird er für weitere Ameisen – ein sich selbst verstärkender Prozess.

Negative Rückkopplung hingegen wirkt dämpfend und stabilisierend. Sie verhindert, dass positive Rückkopplungen außer Kontrolle geraten. Im Ameisenbeispiel sorgt die Pheromonverdunstung für negative Rückkopplung: Pheromone verflüchtigen sich mit der Zeit, sodass weniger frequentierte Pfade verschwinden. Wird eine Nahrungsquelle erschöpft, legen weniger Ameisen Pheromonspuren an, und der Pfad “verschwindet” allmählich, was die Kolonie dazu bringt, neue Quellen zu erkunden. Diese Balance zwischen Verstärkung und Dämpfung ist charakteristisch für adaptive Schwarm-Systeme.

Die richtige Balance zwischen positiver und negativer Rückkopplung ist entscheidend für funktionsfähige Schwarm-Systeme. Zu viel positive Rückkopplung führt zu vorzeitiger Konvergenz und mangelnder Anpassungsfähigkeit; zu viel negative Rückkopplung verhindert die Bildung stabiler Strukturen. In natürlichen Systemen hat die Evolution diese Balance optimiert; in künstlichen Schwarm-Algorithmen ist die Einstellung dieser Balance eine der Hauptherausforderungen.

8.1.4 Emergenz von Mustern und Strukturen¶

Emergenz bedeutet, dass ein System Eigenschaften aufweist, die seine einzelnen Komponenten nicht besitzen und die nicht offensichtlich aus den Eigenschaften dieser Komponenten ableitbar sind. Kurz gesagt: “Das Ganze ist mehr als die Summe seiner Teile”. In Schwarm-Systemen bedeutet dies, dass aus den Interaktionen vieler einfacher Individuen komplexe Muster, Strukturen oder Verhaltensweisen entstehen, die nicht explizit im “Programm” der einzelnen Agenten kodiert sind.

Der Übergang von mikroskopischen Regeln zu makroskopischem Verhalten ist nicht immer intuitiv vorhersehbar. Kleine Änderungen in den lokalen Regeln können zu drastisch unterschiedlichem globalen Verhalten führen. Dies erklärt, warum das Design von Schwarm-Algorithmen oft experimentell erfolgt: Man passt die lokalen Regeln an und beobachtet, welche Muster auf globaler Ebene entstehen. Diese Nicht-Linearität ist gleichzeitig Herausforderung und Stärke von Schwarm-Systemen. Sie macht sie schwer zu analysieren, aber auch außerordentlich anpassungsfähig und vielseitig.

8.1.5 Von individueller zu kollektiver Intelligenz¶

Individuelle Agenten in einem Schwarm sind typischerweise begrenzt in ihren Fähigkeiten: Sie verfügen über limitierte Wahrnehmung, begrenzten Speicher und eingeschränkte Kommunikationsfähigkeiten. Eine einzelne Ameise kann keine komplexen Berechnungen durchführen, und ein einzelner Vogel hat keine Übersicht über optimale Migrationsrouten. Dennoch lösen Ameisenkolonien und Vogelschwärme effektiv komplexe Optimierungsprobleme. Wie ist das möglich?

Die Antwort liegt in der kollektiven Informationsverarbeitung. Information wird nicht zentralisiert, sondern verteilt über alle Agenten verarbeitet und aggregiert. In einer Bienenkolonie beispielsweise erkunden Kundschafterbienen verschiedene potenzielle Nistplätze und bewerten deren Qualität. Zurück im Schwarm führen sie einen “Schwänzeltanz” auf, dessen Intensität von der Qualität des gefundenen Platzes abhängt. Andere Bienen beobachten verschiedene Tänze und entscheiden probabilistisch, welchem Kundschafter sie folgen. Durch diesen Mechanismus “stimmt” der Schwarm effektiv für den besten Nistplatz, ohne dass eine einzelne Biene den gesamten Entscheidungsprozess überblickt.

Funktionsfähige kollektive Intelligenz basiert also auf mehreren Schlüsselprinzipien:

Dezentralisierung: Keine zentrale Kontrolle oder Single Point of Failure
Diversität: Unterschiedliche Perspektiven und Reaktionen
Unabhängigkeit: Agenten treffen eigenständige Entscheidungen basierend auf lokalen Informationen
Aggregation: Mechanismen zur Kombination individueller Beiträge

Diese Prinzipien finden sich nicht nur in biologischen Schwärmen, sondern auch in anderen kollektiv intelligenten Systemen wie Märkten, demokratischen Abstimmungen oder Online-Plattformen wie Wikipedia. Sie ermöglichen es, die Weisheit und die Problemlösungsfähigkeit von Gruppen zu nutzen, die weit über die Fähigkeiten einzelner Mitglieder hinausgehen.

8.2. Bioinspirierte Schwarm-Algorithmen¶

Die Natur bietet ein reichhaltiges Reservoir an Inspiration für Schwarm-Algorithmen:

Ameisenkolonien und ihre Pheromonkommunikation inspirieren Optimierungsalgorithmen für Routing- und Scheduling-Probleme
Bienenschwärme und ihre Futtersuche-/Nistplatzwahlstrategien liefern Modelle für multimodale Optimierung und Exploration-Exploitation-Balance
Vogel- und Fischschwärme demonstrieren effiziente Bewegungskoordination, die z.B. in Roboterschwärmen angewendet wird
Glühwürmchen und ihre Synchronisationsmechanismen inspirieren Algorithmen für Netzwerksynchronisation

Im Foglenden sehen wir uns ein paar konkrete Beispiele und Visualisierungen an.

8.2.1 Ameisenkolonie-Optimierung (ACO)¶

Die Ameisenkolonie-Optimierung ist einer der bekanntesten schwarmbasierten Algorithmen, inspiriert vom Futtersuchverhalten von Ameisen. Ameisen hinterlassen auf ihrem Weg Pheromone, chemische Substanzen, die von anderen Ameisen wahrgenommen werden können. Je mehr Ameisen einen Pfad nutzen, desto stärker wird die Pheromonspur, was wiederum mehr Ameisen anzieht. Kürzere Pfade werden häufiger traversiert, wodurch sich dort mehr Pheromone ansammeln, was zur Konvergenz auf optimale Routen führt.

Im ACO-Algorithmus repräsentieren künstliche Ameisen Lösungskandidaten, die durch den Suchraum navigieren. Die Wahrscheinlichkeit, dass eine Ameise einen bestimmten Pfad wählt, hängt von der Pheromonkonzentration und einer heuristischen Information (z.B. Distanz) ab. Nach jeder Iteration werden die Pheromonwerte aktualisiert: Erfolgreiche Pfade erhalten mehr Pheromone, während alle Pfade einer Verdunstung unterliegen, um die Erkundung neuer Lösungen zu fördern.

ACO eignet sich besonders für kombinatorische Optimierungsprobleme wie das Traveling Salesman Problem, Routenplanung oder Scheduling. An dieser Stelle sehen wir uns aber einfach einmal eine konkrete Simulation mit Visualisierung an.

In [3]:

# Import necessary libraries
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from IPython.display import HTML  # For displaying animation in Jupyter
import random
import math
import time # To track performance if needed
import matplotlib as mpl

# Set the animation embed limit to 50 MB (or your desired size in MB)
mpl.rcParams['animation.embed_limit'] = 600  # The value is in Megabytes

# --- Constants (mostly same as pygame version) ---
WIDTH, HEIGHT = 400, 300 # Logical world dimensions
PHEROMONE_RESOLUTION_FACTOR = 5 # Pheromones calculated on a coarser grid (HIGHER value = COARSER grid = FASTER)
P_WIDTH, P_HEIGHT = WIDTH // PHEROMONE_RESOLUTION_FACTOR, HEIGHT // PHEROMONE_RESOLUTION_FACTOR

N_ANTS = 150
ANT_SPEED = 1.0
ANT_ROTATION_SPEED = 0.1  # Radians per step
SENSOR_DISTANCE = 15     # How far ahead ants "smell"
SENSOR_ANGLE = math.pi / 4 # Angle offset for side sensors (radians)

# Pheromones
EVAPORATION_RATE = 0.99 # Percentage remaining after 1 step
PHEROMONE_DROP_RATE = 2.0
MAX_PHEROMONE = 100.0 # Cap pheromone intensity

# States (using integers for easy indexing/coloring)
SEARCHING = 0
RETURNING = 1

# Colors for matplotlib plotting (Ants)
ANT_COLORS = ['red', 'blue'] # red for searching, blue for returning

# --- Helper Functions (mostly same) ---
def normalize_angle(angle):
    while angle > math.pi: angle -= 2 * math.pi
    while angle <= -math.pi: angle += 2 * math.pi
    return angle

def world_to_pheromone_grid(pos):
    x, y = pos
    px = int(x / PHEROMONE_RESOLUTION_FACTOR)
    py = int(y / PHEROMONE_RESOLUTION_FACTOR)
    # Clamp values to be within grid bounds
    px = max(0, min(P_WIDTH - 1, px))
    py = max(0, min(P_HEIGHT - 1, py))
    return px, py

def is_within_bounds(pos, w=WIDTH, h=HEIGHT):
    x, y = pos
    return 0 <= x < w and 0 <= y < h

# --- Ant Class (logic mostly same, removed drawing) ---
class Ant:
    def __init__(self, nest_pos):
        self.pos = np.array(nest_pos, dtype=float)
        self.angle = random.uniform(0, 2 * math.pi)
        self.state = SEARCHING
        self.speed = ANT_SPEED
        self.nest_pos = np.array(nest_pos, dtype=float)
        self.color = ANT_COLORS[self.state]

    def sense_pheromones(self, pheromone_grid):
        sensor_main_pos = self.pos + SENSOR_DISTANCE * np.array([math.cos(self.angle), math.sin(self.angle)])
        sensor_left_pos = self.pos + SENSOR_DISTANCE * np.array([math.cos(self.angle - SENSOR_ANGLE), math.sin(self.angle - SENSOR_ANGLE)])
        sensor_right_pos = self.pos + SENSOR_DISTANCE * np.array([math.cos(self.angle + SENSOR_ANGLE), math.sin(self.angle + SENSOR_ANGLE)])

        # Read pheromone levels only if sensors are within bounds
        p_main, p_left, p_right = 0, 0, 0
        if is_within_bounds(sensor_main_pos):
            px, py = world_to_pheromone_grid(sensor_main_pos)
            p_main = pheromone_grid[px, py]
        if is_within_bounds(sensor_left_pos):
            px, py = world_to_pheromone_grid(sensor_left_pos)
            p_left = pheromone_grid[px, py]
        if is_within_bounds(sensor_right_pos):
            px, py = world_to_pheromone_grid(sensor_right_pos)
            p_right = pheromone_grid[px, py]

        return p_main, p_left, p_right

    def steer(self, p_main, p_left, p_right):
        if p_main > p_left and p_main > p_right:
            pass # Go straight
        elif p_left > p_right:
            self.angle -= ANT_ROTATION_SPEED
        elif p_right > p_left:
            self.angle += ANT_ROTATION_SPEED
        else:
             self.angle += random.uniform(-ANT_ROTATION_SPEED * 0.5, ANT_ROTATION_SPEED * 0.5)
        self.angle = normalize_angle(self.angle)

    def move(self):
        self.pos += self.speed * np.array([math.cos(self.angle), math.sin(self.angle)])
        # Boundary bouncing
        if not (0 < self.pos[0] < WIDTH):
            self.angle = math.pi - self.angle
            self.pos[0] = np.clip(self.pos[0], 1, WIDTH - 1)
        if not (0 < self.pos[1] < HEIGHT):
            self.angle = -self.angle
            self.pos[1] = np.clip(self.pos[1], 1, HEIGHT - 1)
        self.angle = normalize_angle(self.angle)

    def update(self, pheromone_food, pheromone_home, food_sources):
        original_state = self.state # Remember state before potential change

        if self.state == SEARCHING:
            p_main, p_left, p_right = self.sense_pheromones(pheromone_food) # Sense food trail
            self.steer(p_main, p_left, p_right)
            # Check for food
            for food_pos, food_radius in food_sources:
                if np.linalg.norm(self.pos - food_pos) < food_radius:
                    self.state = RETURNING
                    self.angle = normalize_angle(self.angle + math.pi) # Turn around
                    break # Found food, stop checking others

        elif self.state == RETURNING:
             # Drop 'food' pheromones BEFORE sensing 'home' trail
             px, py = world_to_pheromone_grid(self.pos)
             pheromone_food[px, py] = min(MAX_PHEROMONE, pheromone_food[px, py] + PHEROMONE_DROP_RATE)

             p_main, p_left, p_right = self.sense_pheromones(pheromone_home) # Sense home trail
             self.steer(p_main, p_left, p_right)
             # Check for nest
             if np.linalg.norm(self.pos - self.nest_pos) < 15: # Nest radius
                 self.state = SEARCHING
                 self.angle = normalize_angle(self.angle + math.pi) # Turn around

        # Only move if the state didn't *just* change (prevents moving away immediately after finding food/nest)
        if self.state == original_state:
             self.move()
        else:
             # Update color immediately if state changed
             self.color = ANT_COLORS[self.state]

        # After moving (or state change), ants returning home deposit home pheromone at new location
        if self.state == SEARCHING and original_state == RETURNING: # Just arrived at nest
             px, py = world_to_pheromone_grid(self.pos)
             pheromone_home[px, py] = min(MAX_PHEROMONE, pheromone_home[px, py] + PHEROMONE_DROP_RATE * 2) # Stronger drop at nest?

# --- Simulation Setup ---
# Environment elements
nest_pos = (WIDTH // 2, HEIGHT // 2)
food_sources = [
    (np.array([WIDTH * 0.8, HEIGHT * 0.2]), 20),
    (np.array([WIDTH * 0.2, HEIGHT * 0.8]), 20),
]

# Initialize ants
ants = [Ant(nest_pos) for _ in range(N_ANTS)]

# Pheromone grids
pheromone_food = np.zeros((P_WIDTH, P_HEIGHT), dtype=float)
pheromone_home = np.zeros((P_WIDTH, P_HEIGHT), dtype=float)

# --- Matplotlib Visualization Setup ---
fig, ax = plt.subplots(figsize=(10, 7.5)) # Adjust figsize as needed
ax.set_xlim(0, WIDTH)
ax.set_ylim(0, HEIGHT)
ax.set_aspect('equal')
ax.set_facecolor('black') # Set background color
plt.xticks([])
plt.yticks([])
plt.title("Ant Foraging Simulation (Matplotlib)")

# Create plot elements to update
# Pheromones: Use imshow with separate colormaps and alpha blending
# Normalize pheromone values for color mapping (0 to 1)
norm_ph = plt.Normalize(0, MAX_PHEROMONE * 0.5) # Adjust max value for better visibility if needed
im_food = ax.imshow(pheromone_food.T, cmap='Greens', alpha=0.6, origin='lower',
                     extent=[0, WIDTH, 0, HEIGHT], interpolation='bilinear', norm=norm_ph)
im_home = ax.imshow(pheromone_home.T, cmap='Blues', alpha=0.6, origin='lower',
                     extent=[0, WIDTH, 0, HEIGHT], interpolation='bilinear', norm=norm_ph)


# Ants: Use scatter plot. Store the scatter object to update its offsets and colors.
ant_positions = np.array([ant.pos for ant in ants])
ant_colors_array = [ant.color for ant in ants]
scatter_ants = ax.scatter(ant_positions[:, 0], ant_positions[:, 1], s=10, c=ant_colors_array) # s is marker size

# Static elements (Nest and Food)
ax.scatter(nest_pos[0], nest_pos[1], s=150, c='saddlebrown', marker='o', label='Nest') # Use s for size
for food_pos, food_radius in food_sources:
    ax.scatter(food_pos[0], food_pos[1], s=food_radius*15, c='lime', marker='o', label='Food') # Scale radius for size

# --- Animation Update Function ---
def update(frame):
    global pheromone_food, pheromone_home, ants

    # 1. Update Pheromones (Evaporation)
    pheromone_food *= EVAPORATION_RATE
    pheromone_home *= EVAPORATION_RATE
    # Clip minimum value (optional, prevents floating point issues)
    pheromone_food[pheromone_food < 0.01] = 0
    pheromone_home[pheromone_home < 0.01] = 0

    # 2. Update Ants
    new_positions = np.zeros((N_ANTS, 2))
    new_colors = [None] * N_ANTS
    for i, ant in enumerate(ants):
        ant.update(pheromone_food, pheromone_home, food_sources)
        new_positions[i] = ant.pos
        new_colors[i] = ant.color # Update color based on state

    # 3. Update Plot Elements
    # Pheromones (set data for imshow objects) - Transpose needed as imshow expects (row, col) -> (y, x)
    im_food.set_data(pheromone_food.T)
    im_home.set_data(pheromone_home.T)

    # Ants (update scatter plot offsets and colors)
    scatter_ants.set_offsets(new_positions)
    scatter_ants.set_facecolors(new_colors) # Use set_facecolors for individual colors

    # Update title with frame number (optional)
    ax.set_title(f"Ant Foraging Simulation (Frame: {frame})")

    # Return list of modified plot elements
    return [im_food, im_home, scatter_ants]

# --- Create and Display Animation ---
# Note: interval is the delay between frames in milliseconds.
# Setting blit=True generally improves performance but can sometimes cause issues. Try False if it glitches.
# frames = number of frames to generate. Can be set high or left None for continuous (until stopped)
ani = animation.FuncAnimation(fig, update, frames=1500, interval=30, blit=True)

# Close the initial static plot display
plt.close(fig)

# Display the animation in Jupyter using HTML
# This generates Javascript/HTML to embed the animation
print("Generating animation... (this may take a moment)")
start_time = time.time()
html_output = HTML(ani.to_jshtml())
end_time = time.time()
print(f"Animation generated in {end_time - start_time:.2f} seconds.")

# ani.save('ant_simulation.mp4', writer='ffmpeg', fps=30)
html_output # Display the animation

Generating animation... (this may take a moment)

8.2.2 Bienenschwarm-Algorithmus (ABC)¶

Der Bienenschwarm-Algorithmus (Artificial Bee Colony, ABC) ist eine stochastische Optimierungsmethode, die an das Futtersuchverhalten von Honigbienen angelehnt ist. Im Bienenstock gibt es drei Typen von Bienen: Sammelbienen (employed bees), die bekannte Nahrungsquellen und deren Umgebung erkunden, Beobachterbienen (onlooker bees), die basierend auf Informationen der Sammelbienen bekannte Nahrungsquellen auswählen und deren Umgebung erkunden wie Sammelbienen, und Kundschafterbienen (scout bees), die völlig zufällig nach neuen Nahrungsquellen suchen.

Jede Nahrungsquelle entspricht dabei einem Satz von Parametern im Suchraum, also z.B. Koordinaten. Durch eine vorgegebene Fitness-Funktion wird jeder Nahrungsquelle ein Wert (Qualität) zugeordnet. Zu jeder Zeit sind immer eine bestimmte Anzahl von Nahrungsquellen bekannt, das entspricht etwa der Population, die wir von den Genetischen Algorithmen kennen.

Der Algorithmus selbst arbeitet in Zyklen:

Sammelbienen erkunden die Nachbarschaft ihrer zugewiesenen Nahrungsquellen und teilen die Qualitätsinformation mit den Beobachterbienen.
Beobachterbienen wählen probabilistisch Nahrungsquellen basierend auf deren Qualität aus (bessere Quellen haben höhere Auswahlwahrscheinlichkeit).
Wenn in der unmittelbaren Umgebung einer Nahrungsquelle nach mehreren Versuchen keine Verbesserung gefunden werden kann, wird sie aufgegeben und die entsprechende Sammelbiene wird zur Kundschafterbiene, die dann völlig zufällig eine neue Quelle sucht.

ABC balanciert effektiv zwischen Exploitation (durch Sammler- und Beobachterbienen) und Exploration (durch Kundschafterbienen). Der Algorithmus benötigt wenige Kontrollparameter und zeigt gute Leistung bei verschiedenen Optimierungsproblemen. Die Nahrungsquellen-Aufgabemechanismus verhindert, dass der Algorithmus in schlechten lokalen Optima stecken bleibt, während die probabilistische Auswahl der Beobachterbienen für Diversität in der Suche sorgt.

Insgesamt hat dieser Algorithmus zwar hauptsächlich das Setup einer zentral gesteuerten stochastischen Optimierung, man kann die Optimierungsschritte allerdings auch tatsächlich dezentralisieren und von unabhängigen Agenten ausführen lassen.

8.2.3 Glühwürmchen-Algorithmus¶

Der Glühwürmchen-Algorithmus (Firefly Algorithm) basiert auf dem Paarungsverhalten von Glühwürmchen, die durch ihr Leuchten Partner anziehen. Die Grundannahmen sind: Alle Glühwürmchen sind unisex und können sich gegenseitig anziehen, die Attraktivität ist proportional zur Helligkeit und nimmt mit der Distanz ab, und die Helligkeit wird durch die Zielfunktion (Fitness in einem Optimierungsproblem) bestimmt. Glühwürmchen bewegen sich also schrittweise zu helleren (besseren) Glühwürmchen in ihrer Umgebung hin.

Die Iteration läuft wie folgt ab:

nach jedem Iterationsschritt über alle Glühwürmchen wird die Helligkeit aller Glühwürmchen neu berechnet
jedes Glühwürmchen bestimmt innerhalb eines Interationsschritts der Reihe nach alle jene, die heller sind als es selbst
für jedes hellere Glühwürmchen verändert das Glühwürmchen dann seine Position in dessen Richtung, gewichtet mit einer Funktion der Entfernung, und ergänzt durch einen kleinen zusätzlichen Schritt in zufälliger Richtung
wenn jedes Glühwürmchen der Reihe nach auf diese Weise jeweils seinen eigenen kleinen Pfad zurückgelegt hat, ist ein Iterationsschritt beendet

Der Algorithmus eignet sich besonders für multimodale Optimierungsprobleme, da mehrere Glühwürmchen-Gruppen sich um verschiedene lokale Optima bilden können. Die automatische Unterteilung des Schwarms basierend auf lokaler Attraktivität ermöglicht die gleichzeitige Erforschung mehrerer vielversprechender Regionen. Hier sehen wir uns wieder eine Visualisierung an. Wir erkunden dabei eine neue, ebenfalls nicht ganz einfach zu optimierende Funktion (Schwefel), ähnlich zu jener Funktion, die wir bereits kennen (Rastrigin).

In [4]:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from IPython.display import HTML
import warnings

# Suppress Matplotlib animation warning if it occurs
warnings.filterwarnings("ignore", category=UserWarning, module="matplotlib.animation")

# --- Fitness Functions (for minimization) ---

def rastrigin_2d(x, y):
    """Rastrigin function in 2D."""
    return 20 + (x**2 - 10 * np.cos(2 * np.pi * x)) + \
           (y**2 - 10 * np.cos(2 * np.pi * y))

def schwefel_2d(x, y):
    """Schwefel function in 2D."""
    # Global minimum is at x=y=420.9687, f(x,y)=0
    # To make it a minimization problem with min near 0 for typical FA brightness:
    # We can use the standard form: 418.9829 * 2 - (x * sin(sqrt|x|) + y * sin(sqrt|y|))
    # Or a shifted/scaled one if needed for brightness calculation,
    # but for now, let's use the standard.
    term1 = x * np.sin(np.sqrt(np.abs(x)))
    term2 = y * np.sin(np.sqrt(np.abs(y)))
    return 418.9829 * 2 - (term1 + term2)

# --- Function Configuration ---
# Choose which function to use: 'rastrigin' or 'schwefel'
SELECTED_FUNCTION = 'schwefel' #@param ['rastrigin', 'schwefel']

if SELECTED_FUNCTION == 'rastrigin':
    fitness_function = rastrigin_2d
    DOMAIN_MIN = -5.12
    DOMAIN_MAX = 5.12
    GLOBAL_MIN_POS = np.array([0.0, 0.0])
    GLOBAL_MIN_VAL = 0.0
elif SELECTED_FUNCTION == 'schwefel':
    fitness_function = schwefel_2d
    DOMAIN_MIN = -500.0
    DOMAIN_MAX = 500.0
    GLOBAL_MIN_POS = np.array([420.9687, 420.9687])
    GLOBAL_MIN_VAL = 0.0 # Schwefel is 0 at its global min
else:
    raise ValueError("Invalid function selected")

# For scaling the random walk
DOMAIN_WIDTH = DOMAIN_MAX - DOMAIN_MIN

# Firefly Algorithm Parameters
N_FIREFLIES = 50       # Number of fireflies
MAX_GENERATIONS = 100  # Maximum number of generations
ALPHA = 0.01            # Randomness factor (for random walk part)
BETA0 = 0.01            # Attractiveness at r=0
GAMMA = 0.5            # Light absorption coefficient
                       # For Rastrigin with domain [-5.12, 5.12], r^2 can be up to (10.24*sqrt(2))^2 approx 200.
                       # If gamma=0.5, exp(-100) is tiny.
                       # If gamma=0.01, exp(-2) approx 0.13.
                       # Let's adjust gamma based on domain, or make it smaller.
                       # For a domain width of ~10, r_max_sq is ~200.
                       # For a domain width of ~1000 (Schwefel), r_max_sq is ~2,000,000
                       # We need gamma * r^2 to be in a reasonable range.
                       # Let's make gamma inversely proportional to characteristic squared length scale
CHARACTERISTIC_LENGTH_SQUARED = (DOMAIN_WIDTH)**2 / 10 # Heuristic
GAMMA = 1.0 / CHARACTERISTIC_LENGTH_SQUARED if CHARACTERISTIC_LENGTH_SQUARED > 0 else 0.1
ALPHA_DELTA = 0.97 # Optional: factor to reduce alpha over generations

# Initialize fireflies
# Each firefly is [x, y]
firefly_positions = np.random.uniform(DOMAIN_MIN, DOMAIN_MAX, (N_FIREFLIES, 2))
firefly_brightness = np.zeros(N_FIREFLIES)
firefly_fitness = np.zeros(N_FIREFLIES)

# Best solution found so far
global_best_pos = None
global_best_fitness = float('inf')

def calculate_brightness(fitness_values):
    # Assuming minimization, fitness >= 0. Higher brightness = better (lower fitness)
    # Add a small epsilon to avoid division by zero if fitness is 0
    return 1.0 / (1.0 + fitness_values + 1e-6)

# Initial fitness and brightness calculation
for i in range(N_FIREFLIES):
    x, y = firefly_positions[i]
    f_val = fitness_function(x, y)
    firefly_fitness[i] = f_val
    if f_val < global_best_fitness:
        global_best_fitness = f_val
        global_best_pos = firefly_positions[i].copy()

firefly_brightness = calculate_brightness(firefly_fitness)

print(f"Using function: {SELECTED_FUNCTION}")
print(f"Domain: [{DOMAIN_MIN}, {DOMAIN_MAX}]")
print(f"Gamma: {GAMMA:.4e}")
print(f"Initial best fitness: {global_best_fitness:.4f} at {global_best_pos}")

def update_fireflies_and_get_best(positions, brightness, current_fitness,
                                  current_global_best_pos, current_global_best_fitness):
    n = positions.shape[0]
    num_dims = positions.shape[1]
    new_positions = np.copy(positions) # Work on a copy for this generation's new positions

    # Store current brightness for comparisons within this generation
    # This is I(t) based on positions(t)
    current_brightness_for_comparison = np.copy(brightness)

    for i in range(n):
        # This firefly's position will be updated based on attractions
        # It starts from its position at time t
        x_i_candidate = np.copy(positions[i])
        
        # Flag to check if firefly 'i' was attracted and moved by any 'j'
        # This helps decide if it needs a standalone random walk (if it's a global best type)
        attracted_and_moved = False

        for j in range(n):
            if i == j:
                continue

            # Compare based on brightness at the start of the generation
            if current_brightness_for_comparison[j] > current_brightness_for_comparison[i]:
                attracted_and_moved = True
                
                # Calculate distance: r_ij
                # Distance is between x_i_candidate (which evolves within this i-loop)
                # and positions[j] (which is fixed at t for this generation)
                r_sq = np.sum((x_i_candidate - positions[j])**2)
                
                beta = BETA0 * np.exp(-GAMMA * r_sq)
                
                # Random vector for this specific interaction
                # Scale factor ensures random step is proportional to domain width
                random_vec = ALPHA * (np.random.rand(num_dims) - 0.5) * DOMAIN_WIDTH
                
                # Update x_i_candidate based on attraction to this j AND its own random jitter for THIS interaction
                x_i_candidate += beta * (positions[j] - x_i_candidate) + random_vec
                
                # Apply boundary conditions immediately after each micro-move
                x_i_candidate = np.clip(x_i_candidate, DOMAIN_MIN, DOMAIN_MAX)
        
        # If firefly 'i' was not attracted to any brighter firefly (e.g., it's the current global best or in a "dark" area alone)
        # it performs a simple random walk.
        if not attracted_and_moved:
            random_vec_standalone = ALPHA * (np.random.rand(num_dims) - 0.5) * DOMAIN_WIDTH
            x_i_candidate += random_vec_standalone
            x_i_candidate = np.clip(x_i_candidate, DOMAIN_MIN, DOMAIN_MAX)
            
        new_positions[i] = x_i_candidate

    # Now, evaluate fitness for all new positions and update brightness
    new_fitness = np.zeros(n)
    updated_global_best_pos = current_global_best_pos.copy() if current_global_best_pos is not None else None
    updated_global_best_fitness = current_global_best_fitness

    for i in range(n):
        f_val = fitness_function(new_positions[i, 0], new_positions[i, 1])
        new_fitness[i] = f_val
        if f_val < updated_global_best_fitness:
            updated_global_best_fitness = f_val
            updated_global_best_pos = new_positions[i].copy()
            
    new_brightness = calculate_brightness(new_fitness)
    
    return new_positions, new_brightness, new_fitness, updated_global_best_pos, updated_global_best_fitness

fig, ax = plt.subplots(figsize=(8, 6))
ax.set_xlim(DOMAIN_MIN, DOMAIN_MAX)
ax.set_ylim(DOMAIN_MIN, DOMAIN_MAX)

# Plot contour of the fitness function
x_grid = np.linspace(DOMAIN_MIN, DOMAIN_MAX, 100)
y_grid = np.linspace(DOMAIN_MIN, DOMAIN_MAX, 100)
X_mesh, Y_mesh = np.meshgrid(x_grid, y_grid)
Z_mesh = fitness_function(X_mesh, Y_mesh)
contour = ax.contourf(X_mesh, Y_mesh, Z_mesh, levels=50, cmap='viridis') # Or 'plasma', 'magma'
fig.colorbar(contour, ax=ax, label='Fitness Value')

# Plot global minimum if known
if GLOBAL_MIN_POS is not None:
    ax.plot(GLOBAL_MIN_POS[0], GLOBAL_MIN_POS[1], 'X', color='red', markersize=10, label=f'Global Min ({GLOBAL_MIN_VAL:.2f})')
ax.legend(loc='upper right')

# Initial scatter plot for fireflies
# We can use brightness to modulate color or size if desired, but simple points for now
# firefly_colors = firefly_brightness / np.max(firefly_brightness + 1e-6) # Normalize for color
scatter = ax.scatter(firefly_positions[:, 0], firefly_positions[:, 1], 
                     color='orange', edgecolor='black', s=50, zorder=3, label='Fireflies') # s=size

title = ax.set_title(f"Generation: 0, Best Fitness: {global_best_fitness:.4f}")

# Animation function
def animate(generation):
    global firefly_positions, firefly_brightness, firefly_fitness, global_best_pos, global_best_fitness
    
    firefly_positions, firefly_brightness, firefly_fitness, \
    global_best_pos, global_best_fitness = update_fireflies_and_get_best(
                                                firefly_positions, 
                                                firefly_brightness, # Pass current brightness for comparison
                                                firefly_fitness,    # Pass current fitness (for info, not direct use in update logic)
                                                global_best_pos, 
                                                global_best_fitness
                                            )
    
    scatter.set_offsets(firefly_positions)
    # Optionally update firefly colors/sizes based on new brightness
    # norm_brightness = firefly_brightness / (np.max(firefly_brightness) + 1e-6)
    # scatter.set_array(norm_brightness) # If using color to represent brightness
    
    title.set_text(f"Generation: {generation + 1}, Best Fitness: {global_best_fitness:.4f}")
    
    if (generation + 1) % 10 == 0 or generation == MAX_GENERATIONS -1 : # Print progress
        print(f"Gen: {generation + 1}/{MAX_GENERATIONS}, Best Fit: {global_best_fitness:.4f}, Pos: {global_best_pos}")
        
    return scatter, title,

# Create and display animation
# blit=False because title is also an artist we are returning and it might cause issues with blit=True sometimes
ani = FuncAnimation(fig, animate, frames=MAX_GENERATIONS, interval=150, blit=False, repeat=False)

plt.close(fig) # Prevent static plot from showing up before the animation
HTML(ani.to_jshtml())
# To save as mp4 (ensure ffmpeg is installed):
# ani.save('firefly_algorithm.mp4', writer='ffmpeg', fps=15)
# print("Animation saved as firefly_algorithm.mp4")

Using function: schwefel
Domain: [-500.0, 500.0]
Gamma: 1.0000e-05
Initial best fitness: 284.3820 at [220.08912333 404.38937103]
Gen: 10/100, Best Fit: 229.5933, Pos: [ 391.09001972 -308.70720605]
Gen: 20/100, Best Fit: 184.8533, Pos: [ 425.18732216 -325.30239492]
Gen: 30/100, Best Fit: 156.0981, Pos: [ 415.7345098 -319.0452039]
Gen: 40/100, Best Fit: 126.5209, Pos: [ 415.52602919 -308.38898899]
Gen: 50/100, Best Fit: 121.5788, Pos: [ 419.42406253 -307.25790453]
Gen: 60/100, Best Fit: 121.5788, Pos: [ 419.42406253 -307.25790453]
Gen: 70/100, Best Fit: 121.5788, Pos: [ 419.42406253 -307.25790453]
Gen: 80/100, Best Fit: 121.5788, Pos: [ 419.42406253 -307.25790453]
Gen: 90/100, Best Fit: 121.5788, Pos: [ 419.42406253 -307.25790453]
Gen: 100/100, Best Fit: 121.5788, Pos: [ 419.42406253 -307.25790453]

8.3. Selbstorganisation und kollektive Entscheidungsfindung¶

Nachdem wir nun verschiedene bioinspirierte Schwarm-Algorithmen kennengelernt haben, möchte ich Ihnen noch die Mechanismen der Selbstorganisation und kollektiven Entscheidungsfindung näher bringen. Diese Mechanismen sind wesentliche Aspekte von Schwarm-Algorithmen und machen deutlicher, warum und wie dezentrale Systeme ohne globale Koordination effektive Lösungen finden können.

8.3.1 Prinzipien der Selbstorganisation in biologischen Systemen¶

Selbstorganisation bezeichnet die spontane Entstehung von Ordnung und Struktur in einem System ohne externe Steuerung oder zentralen Plan. Dieser Prozess ist in der Natur allgegenwärtig – von der Bildung von Schneeflocken bis zur Entstehung komplexer Ökosysteme. In biologischen Schwärmen manifestiert sich Selbstorganisation in der Eigenschaft, komplexe kollektive Verhaltensweisen zu generieren, ohne dass diese explizit “programmiert” bzw. “vorgesehen” sind.

Die Selbstorganisation in biologischen Systemen basiert auf einigen Mechanismen und zeigt typische Phänomene. Zu den Mechanismen zählen die positive und negative Rückkopplung, die uns bereits oben begegnet sind. Diese beiden ermöglichen, dass ein System in einen geordneteren Zustand geht und diesen stabilisiert. Dazu kommt, dass solche Rückkoppelung oft zu einer Verstärkung von zufälligen Fluktuationen führen, woraus wieder Muster und neue Strukturen entstehen können, z.B. die Pheromon-Pfade im Ameisen-Beispiel oben.

Außerdem ist es wichtig, nochmals festzuhalten, dass die Wechselwirkungen zwischen Individuen/Agenten lokal sind, d.h., es genügt völlig, wenn jeder Agent nur mit seinen Nachbarn bzw. überhaupt nur mit seiner Umgebung interagiert. Dadurch steigt auch die Robustheit gegenüber Ausfällen oder Veränderungen einzelner Agenten sowie die Skalierbarkeit zu schier riesigen Schwärmen ohne dass es deshalb in einer zentralen Leitungsstelle eine Überlastung gäbe.

Die Stärke selbstorganisierender Systeme liegt also in ihrer Robustheit, Flexibilität und Skalierbarkeit. Sie können sich an veränderte Umgebungsbedingungen anpassen, bleiben funktionsfähig trotz des Ausfalls einzelner Komponenten und können mit zunehmender Größe sogar effektiver werden. Diese Eigenschaften machen biologische Selbstorganisation zu einem attraktiven Vorbild für technische Systeme, von Telekommunikationsnetzwerken bis hin zu Roboterschwärmen.

8.3.2 Emergente Koordination ohne zentrale Kontrolle¶

Ein faszinierendes Phänomen selbstorganisierender Systeme ist die emergente Koordination: Ohne zentrale Steuerung oder explizite Kommunikation über globale Ziele entwickeln Schwärme synchronisierte, koordinierte Verhaltensweisen. Diese Koordination manifestiert sich auf verschiedenen Ebenen, von einfacher Bewegungssynchronisation bis hin zu komplexer Arbeitsteilung. Dabei hängt das Auftreten solcher emergenter Phänomene oft von der “Dichte” der Agenten im System ab. Man spricht daher im Zusammenhang mit dem Auftreten emergenter Phänomene auch von Phasenübergängen in komplexen Systemen.

In künstlichen Systemen findet emergente Koordination vielfältige Anwendungen. Roboterschwärme nutzen lokale Koordinationsregeln für Formation Control oder kollaborative Objektmanipulation. Drahtlose Sensornetzwerke verwenden dezentrale Protokolle zur Selbstorganisation in effiziente Netzwerktopologien. Autonome Fahrzeuge könnten zukünftig schwarm-ähnliche Koordination für problemlosen Verkehrsfluss ohne zentrale Ampelsteuerung nutzen.

Die Herausforderung beim Design solcher Systeme liegt darin, lokale Regeln zu finden, die zuverlässig das gewünschte globale Verhalten erzeugen – ein oft nicht-triviales inverses Problem, das Expertenwissen und viele Test-Simulationen erfordert.

8.3.3 Stigmergie: Kommunikation durch Umgebungsmodifikation¶

Stigmergie ist eine besondere Form der indirekten Kommunikation in Schwärmen, bei der Individuen nicht direkt miteinander kommunizieren, sondern durch Modifikation ihrer Umgebung. Wir haben das im Ameisen-Beispiel oben bereits gesehen: Ein Agent hinterlässt (Pheromon-)Spuren in der Umgebung, die das Verhalten anderer Agenten beeinflussen. Noch konkreter hinterlässt eine Ameise, die eine Nahrungsquelle findet, auf ihrem Rückweg zum Nest eine chemische Spur. Andere Ameisen nehmen diese Spur wahr und folgen ihr mit höherer Wahrscheinlichkeit. Wenn auch sie Nahrung finden, verstärken sie die Spur auf ihrem Rückweg. Dieses indirekte Kommunikationssystem ermöglicht es Ameisenkolonien, effiziente Wege zu Nahrungsquellen zu etablieren, ohne dass einzelne Ameisen den gesamten Weg kennen oder direkt miteinander kommunizieren müssen.

Stigmergie hat mehrere bemerkenswerte Eigenschaften:

Entkopplung von Sender und Empfänger: Die kommunizierenden Individuen müssen nicht gleichzeitig am selben Ort sein oder einander direkt wahrnehmen.
Persistenz: Die Umgebungsmodifikationen bleiben bestehen und wirken über den Moment der Erzeugung hinaus, fungieren also als externes “Gedächtnis” des Schwarms (bis die Pheromonspur wieder “verdunstet”).
Selbstverstärkung: Erfolgreiche Lösungen werden durch positive Rückkopplung verstärkt.
Skalierbarkeit: Der Kommunikationsaufwand wächst nicht mit der Anzahl der Individuen, da die Kommunikation über die Umgebung erfolgt. Ebenso brauchen die Agenten selbst keinen Speicher für die Spuren (oder im Allgemeinen die in der Umgebung gespeicherten Informationen).

In der Natur finden sich zahlreiche weitere Beispiele für Stigmergie:

Termiten bauen komplexe Nester, indem sie Bodenmaterial mit Pheromonen markieren, was andere Termiten dazu anregt, dort weiteres Material abzulegen
Bienen nutzen die Wachsstrukturen im Bienenstock als Stimulus für weitere Bauaktivitäten
Spinnen nutzen ihre eigenen Netze als externe Informationsspeicher, die ihnen signalisieren, wo sich Beute verfangen hat

In der Informatik hat das Konzept der Stigmergie breite Anwendung gefunden. Die Ameisenkolonie-Optimierung ist ein direktes Beispiel, bei dem virtuelle Pheromone zur Pfadoptimierung genutzt werden. Darüber hinaus finden sich stigmergische Prinzipien in:

Verteilten Robotersystemen, bei denen Roboter RFID-Tags oder andere Marker in der Umgebung platzieren
Empfehlungssystemen, bei denen die Nutzeraktivität die “digitale Umgebung” für andere Nutzer verändert
Kollaborativen Filtersystemen, die auf dem aggregierten Verhalten vieler Nutzer basieren
Versionskontrollsystemen wie Git, bei denen Entwickler Spuren ihrer Arbeit hinterlassen, die andere Entwickler beeinflussen

Die Stärke der Stigmergie liegt in ihrer Fähigkeit, Komplexität zu bewältigen, ohne komplexe Kommunikation oder Kognition (oder überhaupt Systemspeicher) zu erfordern – ein Prinzip, das sowohl in natürlichen als auch in künstlichen Schwärmen zentrale Bedeutung hat.

8.3.4 Quorum-Sensing und Konsensbildung¶

Kollektive Entscheidungsfindung ist eine der beeindruckendsten Fähigkeiten von Schwärmen. Ohne zentrale Autorität müssen Gruppen zwischen Alternativen wählen, Kompromisse finden und zu einem Konsens gelangen. Quorum-Sensing ist ein biologischer Mechanismus, der solche kollektiven Entscheidungen ermöglicht.

Ursprünglich bei Bakterien entdeckt, beschreibt Quorum-Sensing die Fähigkeit von Organismen, ihre eigene Populationsdichte wahrzunehmen und ihr Verhalten entsprechend anzupassen. Bakterien sekretieren Signalmoleküle, deren Konzentration mit der Populationsdichte steigt. Überschreitet die Konzentration einen Schwellenwert, aktivieren die Bakterien bestimmte Gene, die kollektives Verhalten koordinieren wie z.B. die Bildung eines Biofilms.

Soziale Insekten nutzen ähnliche Prinzipien für komplexere Entscheidungsprozesse. Ein klassisches Beispiel ist die Nistplatzwahl bei Honigbienen. Wenn ein Bienenschwarm eine neue Behausung suchen muss, erkunden Kundschafterbienen verschiedene potenzielle Nistplätze. Zurück im Schwarm werben sie durch Tänze für ihre Entdeckungen, wobei die Intensität des Tanzes proportional zur Qualität des gefundenen Ortes ist. Andere Kundschafter untersuchen diese Orte und beginnen ebenfalls zu werben, wenn sie überzeugt sind. Sobald für einen bestimmten Ort ein Quorum (kritische Masse an Befürwortern) erreicht ist, ändert sich das Verhalten der werbenden Bienen: Sie produzieren ein Signal, das den gesamten Schwarm zum Aufbruch veranlasst.

8.4 Anwendungen der Schwarm-Algorithmen und Schwarm-Optimierung¶

Nach all den Grundlagen und Beispielen für Schwarm-Intelligenz und selbstorganisierende Systeme möchte ich Ihnen noch ein paar weitere Gedanken und Anwendungen zeigen. Wie Sie bereits gesehen haben, taugen Schwärme nicht nur zur Simulation von komplexen Systemen in der Natur, sondern können auch zur Optimierung eingesetzt werden. Bisher haben wir die biologischen Systeme als Basis für Simulation und Visualisierung verwendet. Nun möchte ich aber einen Schritt in Richtung Abstraktion machen.

8.4.1 Partikelschwarm-Optimierung (PSO)¶

Die Partikelschwarm-Optimierung (PSO) ist einer der bekanntesten und am häufigsten eingesetzten Schwarm-Optimierungs-Algorithmen. Inspiriert vom Schwarmverhalten von Vögeln und Fischen, modelliert PSO eine Population von Lösungskandidaten (Partikel) als Punkte mit Koordinaten und Geschwindigkeiten im n-dimensionalen Suchraum, die sich kollektiv bewegen, um optimale Regionen bzw. Lösungen zu finden.

Grundprinzip und Algorithmus¶

Im PSO-Algorithmus hat jedes Partikel eine Position und eine Geschwindigkeit. Die Position repräsentiert eine potenzielle Lösung des Optimierungsproblems, während die Geschwindigkeit bestimmt, wie sich das Partikel im Suchraum bewegt. Entscheidend ist, dass jedes Partikel drei Informationsquellen für seine Bewegung nutzt:

Trägheit: Die aktuelle Geschwindigkeit des Partikels
Kognitive Komponente: Die beste Position, die das Partikel selbst bisher gefunden hat (persönliches Optimum)
Soziale Komponente: Die beste Position, die von irgendjemandem im Schwarm gefunden wurde (globales Optimum)

Die Geschwindigkeitsaktualisierung erfolgt nach der Formel:

$$v_i(t+1) = w \cdot v_i(t) + c_1 \cdot r_1 \cdot (pbest_i – x_i(t)) + c_2 \cdot r_2 \cdot (gbest – x_i(t))$$

Dabei ist:

$v_i(t)$ die aktuelle Geschwindigkeit des Partikels $i$
$w$ das Trägheitsgewicht (typischerweise zwischen 0.4 und 0.9)
$c_1$ und $c_2$ die Lernfaktoren (typischerweise um 2.0)
$r_1$ und $r_2$ Zufallszahlen zwischen 0 und 1
$pbest_i$ die beste Position, die Partikel $i$ bisher gefunden hat
$gbest$ die beste Position im gesamten Schwarm
$x_i(t)$ die aktuelle Position des Partikels $i$

Die Position wird dann aktualisiert durch:

$$x_i(t+1) = x_i(t) + v_i(t+1)$$

Nach jeder Positionsaktualisierung wird die Zielfunktion an dieser neuen Position ausgewertet. Ist der Wert besser als das bisherige persönliche Optimum, wird $pbest_i$ aktualisiert. Ist er besser als das globale Optimum, wird $gbest$ aktualisiert.

Varianten und Erweiterungen¶

Die Grundversion von PSO wurde vielfältig erweitert und angepasst:

Lokale Nachbarschaften: Statt des globalen Optimums wird nur das beste Ergebnis in einer lokalen Nachbarschaft berücksichtigt, was die Diversität erhöht und vorzeitige Konvergenz vermeidet.
Adaptive Parameter: Das Trägheitsgewicht $w$ wird dynamisch angepasst, etwa durch lineare Abnahme über die Iterationen oder basierend auf der Schwarmperformance.
Eingeschränkte Geschwindigkeit: Maximalgrenzen für die Geschwindigkeit verhindern zu große Sprünge im Suchraum.
Multi-Schwarm PSO: Mehrere Teil-Schwärme erkunden parallel verschiedene Regionen des Suchraums und tauschen periodisch Informationen aus.
Hybride Ansätze: Kombination von PSO mit anderen Metaheuristiken wie genetischen Algorithmen oder lokalen Suchmethoden.

Sehen wir uns das einmal konkret an, wieder für die Rastrigin Funktion:

In [5]:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from IPython.display import HTML
import warnings

# Suppress Matplotlib animation warning if it occurs
warnings.filterwarnings("ignore", category=UserWarning, module="matplotlib.animation")

# --- Fitness Functions (for minimization) ---

def rastrigin_2d(x, y):
    """Rastrigin function in 2D."""
    return 20 + (x**2 - 10 * np.cos(2 * np.pi * x)) + \
           (y**2 - 10 * np.cos(2 * np.pi * y))

def schwefel_2d(x, y):
    """Schwefel function in 2D."""
    term1 = x * np.sin(np.sqrt(np.abs(x)))
    term2 = y * np.sin(np.sqrt(np.abs(y)))
    return 418.9829 * 2 - (term1 + term2)

# --- Function Configuration ---
# Choose which function to use: 'rastrigin' or 'schwefel'
SELECTED_FUNCTION = 'rastrigin' #@param ['rastrigin', 'schwefel']

if SELECTED_FUNCTION == 'rastrigin':
    fitness_function = rastrigin_2d
    DOMAIN_MIN = -5.12
    DOMAIN_MAX = 5.12
    GLOBAL_MIN_POS_THEORETICAL = np.array([0.0, 0.0])
    GLOBAL_MIN_VAL_THEORETICAL = 0.0
elif SELECTED_FUNCTION == 'schwefel':
    fitness_function = schwefel_2d
    DOMAIN_MIN = -500.0
    DOMAIN_MAX = 500.0
    GLOBAL_MIN_POS_THEORETICAL = np.array([420.9687, 420.9687])
    GLOBAL_MIN_VAL_THEORETICAL = 0.0
else:
    raise ValueError("Invalid function selected")

DOMAIN_WIDTH = DOMAIN_MAX - DOMAIN_MIN
NUM_DIMS = 2 # Working in 2D

# PSO Parameters
N_PARTICLES = 30
MAX_ITERATIONS = 100

# Inertia weight: linearly decreasing from W_MAX to W_MIN
W_MAX = 0.5
W_MIN = 0.1

C1 = 0.5  # Cognitive coefficient (pbest influence)
C2 = 0.5  # Social coefficient (gbest influence)

# Velocity clamping (max velocity as a fraction of domain width per dimension)
V_MAX_FACTOR = 0.01 # Max velocity is 5% of domain width
V_MAX = V_MAX_FACTOR * DOMAIN_WIDTH
V_MIN = -V_MAX

# Initial velocity range (fraction of domain width)
V_INIT_RANGE_FACTOR = 0.05
V_INIT_MAX = V_INIT_RANGE_FACTOR * DOMAIN_WIDTH
V_INIT_MIN = -V_INIT_MAX

# Initialize particles
particle_positions = np.random.uniform(DOMAIN_MIN, DOMAIN_MAX, (N_PARTICLES, NUM_DIMS))
particle_velocities = np.random.uniform(V_INIT_MIN, V_INIT_MAX, (N_PARTICLES, NUM_DIMS))

# Personal best positions and fitness
particle_pbest_positions = np.copy(particle_positions)
particle_pbest_fitness = np.full(N_PARTICLES, float('inf'))

# Global best position and fitness
gbest_position = None
gbest_fitness = float('inf')

# Initial fitness calculation and pbest/gbest update
for i in range(N_PARTICLES):
    current_fitness = fitness_function(particle_positions[i, 0], particle_positions[i, 1])
    particle_pbest_fitness[i] = current_fitness
    # pbest_positions are already set to initial positions

    if current_fitness < gbest_fitness:
        gbest_fitness = current_fitness
        gbest_position = particle_positions[i].copy()

print(f"Using function: {SELECTED_FUNCTION}")
print(f"Domain: [{DOMAIN_MIN}, {DOMAIN_MAX}]")
print(f"Initial global best fitness: {gbest_fitness:.4f} at {gbest_position}")

def update_pso_and_get_best(iteration, positions, velocities,
                             pbest_pos, pbest_fit,
                             gbest_pos, gbest_fit):
    
    n_particles = positions.shape[0]
    num_dims = positions.shape[1]

    # Linearly decreasing inertia weight
    w = W_MAX - (W_MAX - W_MIN) * (iteration / MAX_ITERATIONS)

    # Update pbest and gbest based on current positions
    current_gbest_pos_iter = gbest_pos.copy() if gbest_pos is not None else None
    current_gbest_fit_iter = gbest_fit
    
    new_pbest_pos = np.copy(pbest_pos)
    new_pbest_fit = np.copy(pbest_fit)

    for i in range(n_particles):
        current_fitness = fitness_function(positions[i, 0], positions[i, 1])
        
        if current_fitness < new_pbest_fit[i]:
            new_pbest_fit[i] = current_fitness
            new_pbest_pos[i] = positions[i].copy()
            
            if current_fitness < current_gbest_fit_iter:
                current_gbest_fit_iter = current_fitness
                current_gbest_pos_iter = positions[i].copy()
                
    # Update velocities and positions
    new_velocities = np.zeros_like(velocities)
    new_positions = np.zeros_like(positions)

    for i in range(n_particles):
        r1 = np.random.rand(num_dims) # Random numbers for cognitive component
        r2 = np.random.rand(num_dims) # Random numbers for social component
        
        cognitive_velocity = C1 * r1 * (new_pbest_pos[i] - positions[i])
        social_velocity = C2 * r2 * (current_gbest_pos_iter - positions[i])
        
        new_velocities[i] = w * velocities[i] + cognitive_velocity + social_velocity
        
        # Apply velocity clamping
        new_velocities[i] = np.clip(new_velocities[i], V_MIN, V_MAX)
        
        # Update position
        new_positions[i] = positions[i] + new_velocities[i]
        
        # Apply boundary conditions (clamping)
        new_positions[i] = np.clip(new_positions[i], DOMAIN_MIN, DOMAIN_MAX)
        
    return new_positions, new_velocities, new_pbest_pos, new_pbest_fit, current_gbest_pos_iter, current_gbest_fit_iter


# --- Ensure a clean slate for Matplotlib ---
plt.close('all') 

# --- Setup the new figure and axes ---
fig, ax = plt.subplots(figsize=(8, 6))
ax.set_xlim(DOMAIN_MIN, DOMAIN_MAX)
ax.set_ylim(DOMAIN_MIN, DOMAIN_MAX)

# Plot contour of the fitness function
x_grid = np.linspace(DOMAIN_MIN, DOMAIN_MAX, 100)
y_grid = np.linspace(DOMAIN_MIN, DOMAIN_MAX, 100)
X_mesh, Y_mesh = np.meshgrid(x_grid, y_grid)
Z_mesh = fitness_function(X_mesh, Y_mesh)

contour = ax.contourf(X_mesh, Y_mesh, Z_mesh, levels=50, cmap='viridis')
fig.colorbar(contour, ax=ax, label='Fitness Value')

# Plot theoretical global minimum if known
if GLOBAL_MIN_POS_THEORETICAL is not None:
    ax.plot(GLOBAL_MIN_POS_THEORETICAL[0], GLOBAL_MIN_POS_THEORETICAL[1], 'X', color='red', 
            markersize=10, label=f'Global Min ({GLOBAL_MIN_VAL_THEORETICAL:.2f})')

# Initial scatter plot for particles
scatter = ax.scatter(particle_positions[:, 0], particle_positions[:, 1], 
                     color='orange', edgecolor='black', s=30, zorder=3, label='Particles')

ax.legend(loc='upper right')
title_artist = ax.set_title(f"Iteration: 0, Best Fitness: {gbest_fitness:.4f}")

# Animation function
def animate(iteration):
    global particle_positions, particle_velocities, \
           particle_pbest_positions, particle_pbest_fitness, \
           gbest_position, gbest_fitness
    
    # Update particle states using PSO logic
    particle_positions, particle_velocities, \
    particle_pbest_positions, particle_pbest_fitness, \
    gbest_position, gbest_fitness = update_pso_and_get_best(
                                        iteration,
                                        particle_positions, 
                                        particle_velocities,
                                        particle_pbest_positions,
                                        particle_pbest_fitness,
                                        gbest_position, 
                                        gbest_fitness
                                    )
    
    scatter.set_offsets(particle_positions) # Update particle positions on the plot
    title_artist.set_text(f"Iteration: {iteration + 1}, Best Fitness: {gbest_fitness:.4f}")
    
    if (iteration + 1) % 10 == 0 or iteration == MAX_ITERATIONS - 1:
        print(f"Iter: {iteration + 1}/{MAX_ITERATIONS}, Best Fit: {gbest_fitness:.4f}, Pos: {gbest_position}")
        
    return scatter, title_artist,

# Ensure initial state for title before animation starts
if gbest_position is not None:
    title_artist.set_text(f"Iteration: 0, Best Fitness: {gbest_fitness:.4f} at ({gbest_position[0]:.2f}, {gbest_position[1]:.2f})")
else:
    title_artist.set_text(f"Iteration: 0, Best Fitness: {gbest_fitness:.4f}")

# Create and display animation
ani = FuncAnimation(fig, animate, frames=MAX_ITERATIONS, interval=150, blit=False, repeat=False)

animation_html = HTML(ani.to_jshtml())
plt.close(fig) 
animation_html
# To save as mp4 (ensure ffmpeg is installed):
# ani.save('pso_algorithm.mp4', writer='ffmpeg', fps=15)
# print("Animation saved as pso_algorithm.mp4")

Using function: rastrigin
Domain: [-5.12, 5.12]
Initial global best fitness: 1.3614 at [-0.98262003  0.04128456]
Iter: 10/100, Best Fit: 0.9990, Pos: [-0.99198636  0.00336854]
Iter: 20/100, Best Fit: 0.9989, Pos: [-0.99186596  0.00319872]
Iter: 30/100, Best Fit: 0.9989, Pos: [-0.99185077  0.00318149]
Iter: 40/100, Best Fit: 0.2639, Pos: [-0.03212817  0.01736696]
Iter: 50/100, Best Fit: 0.1165, Pos: [-0.024209    0.00142669]
Iter: 60/100, Best Fit: 0.0241, Pos: [0.00830773 0.00723772]
Iter: 70/100, Best Fit: 0.0033, Pos: [-0.00142538  0.00383087]
Iter: 80/100, Best Fit: 0.0033, Pos: [-0.00142535  0.00383087]
Iter: 90/100, Best Fit: 0.0033, Pos: [-0.00142535  0.00383087]
Iter: 100/100, Best Fit: 0.0033, Pos: [-0.00142535  0.00383087]

8.4.2 Konkrete Optimierungsprobleme¶

Schwarm-Algorithmen haben sich bei der Lösung verschiedener klassischer und praktischer Optimierungsprobleme bewährt. Hier sei zunächst das Problem des Handlungsreisenden (TSP) erwähnt, das wir schon kennen. Hier hat sich die Ameisenkolonie-Optimierung bewährt: Virtuelle Ameisen konstruieren Touren durch probabilistische Entscheidungen, die von Pheromonspuren und heuristischen Informationen (typischerweise Distanzen) beeinflusst werden. Nach jeder Iteration werden die Pheromonspuren aktualisiert, wobei kürzere Touren mehr Pheromone erhalten.

Eine weiter Anwendung sind Scheduling-Probleme. Diese treten in der Fertigungsplanung, Projektplanung und Ressourcenallokation auf. Sie umfassen die zeitliche Planung von Aufgaben unter Berücksichtigung von Ressourcenbeschränkungen, Prioritäten und Abhängigkeiten. Hier kann man z.B. Bienenschwarm-Optimierung gut einsetzen.

Und dann sollen noch Routing-Probleme in Netzwerken erwähnt werden. Diese betreffen die Bestimmung optimaler Pfade für Daten in Kommunikationsnetzwerken oder für Fahrzeuge in Transportnetzwerken. Auch hier hilft der Ameisen-Kolonie-Algorithmus. Die Stärke dieses Ansatzes liegt dabei in seiner Anpassungsfähigkeit: Das Routing passt sich kontinuierlich an veränderte Netzwerkbedingungen an, verteilt den Verkehr auf multiple Pfade und reagiert robust auf Ausfälle.

Die Anwendung ähnlicher Prinzipien auf Verkehrsrouting führt zu adaptiven Navigationssystemen, die nicht nur statische kürzeste Wege berechnen, sondern Echtzeit-Verkehrsbedingungen berücksichtigen und die kollektive “Intelligenz” vieler Fahrzeuge nutzen, um Staus zu vermeiden und den Gesamtverkehrsfluss zu optimieren.

8.4.3 Anwendungen in der Robotik: Schwarmrobotik, kollektive Exploration, Formationskontrolle¶

Die Übertragung von Schwarmkonzepten in die Robotik hat ein neues Forschungs- und Anwendungsfeld eröffnet: Schwarmrobotik oder Multi-Roboter-Systeme. Im Gegensatz zu komplexen Einzelrobotern setzt die Schwarmrobotik auf eine Vielzahl einfacherer, kostengünstigerer Roboter, die durch kollektives Verhalten komplexe Aufgaben lösen.

Schwarmrobotik basiert auf denselben Grundprinzipien wie biologische Schwärme und hat auch die gleichen Vorteile. Ein Hauptanwendungsgebiet für Roboterschwärme ist die Exploration und Kartierung unbekannter oder gefährlicher Umgebungen – von Katastrophengebieten bis zu extraterrestrischen Oberflächen.

Die Formationskontrolle bezeichnet dabei die Koordination der Bewegung eines Roboterschwarms, um spezifische geometrische Muster zu bilden und aufrechtzuerhalten. Anwendungen reichen von der Überwachung großer Gebiete über koordinierte Objektmanipulation bis hin zu energieeffizienter Fortbewegung.

Reale Implementierungen von Schwarmrobotik müssen zahlreiche praktische Herausforderungen bewältigen:

Hardware-Limitationen: Batterielaufzeit, Sensoren, Rechenleistung, physische Interaktionen
Kommunikation: Zuverlässigkeit, Bandbreite, Latenz, Reichweite
Lokalisierung: Präzision in GPS-losen Umgebungen, relative Positionierung
Heterogenität: Integration verschiedener Robotertypen mit unterschiedlichen Fähigkeiten

Hier zeigt sich schließlich, was in einer Softwarelösung eher nicht auffällt, nämlich wie konkrete Vorteile und Nachteile des Agenten-basierten Ansatzes von Schwarm-Robotik reale Potentiale bzw. Grenzen des Systems aufzeigen.

8.4.4 Grenzen und Herausforderungen bei realen Anwendungen¶

Trotz der beeindruckenden Fortschritte und vielversprechenden Anwendungen stoßen Schwarm-Algorithmen und -systeme in der Praxis auf verschiedene Herausforderungen und Grenzen, die ihre breite Anwendung bisher einschränken.

Parametrisierung und Konfiguration¶

Eine fundamentale Herausforderung bei Schwarm-Algorithmen ist die Parameterwahl. Leistung und Verhalten hängen oft kritisch von der richtigen Einstellung mehrerer Parameter ab, beispielsweise:

Schwarmgröße
Lernraten und Gewichtungsfaktoren (z.B. in PSO)
Verdunstungsraten (in ACO)
Kommunikationsradius in Roboterschwärmen

Die optimale Konfiguration ist typischerweise problemspezifisch und erfordert oft empirisches Tuning oder Meta-Optimierung. Dies steht im Widerspruch zur ursprünglichen biologischen Inspiration, da natürliche Schwärme keine externe “Parameteroptimierung” benötigen (bzw. diese bereits durch die Evolution über lange Zeiträume passiert ist).

Skalierbarkeit und Rechenaufwand¶

Obwohl Schwarm-Algorithmen theoretisch hochskalierbar sind, stoßen praktische Implementierungen auf Grenzen:

Rechenaufwand: Jede Iteration erfordert die Auswertung der Zielfunktion für jedes Individuum
Speicherbedarf: In großen Problemen (z.B. TSP mit tausenden Städten) können Pheromonmatrizen oder Nachbarschaftsinformationen erheblichen Speicher benötigen
Konvergenzgeschwindigkeit: Bei komplexen Problemen kann die Konvergenz langsam sein und viele Iterationen erfordern

In der Robotik kommen weitere Herausforderungen hinzu:

Kommunikationsoverhead: Die Bandbreite begrenzt die Menge an austauschbaren Informationen
Energieverbrauch: Kommunikation und Berechnung verbrauchen wertvolle Batteriereserven
Physische Skalierbarkeit: Mehr Roboter bedeuten mehr potenzielle Kollisionen und “Verkehrsstaus”

Vorhersagbarkeit und Zuverlässigkeit¶

Eine inhärente Eigenschaft emergenter Systeme ist ihre begrenzte Vorhersagbarkeit. Dies stellt eine Herausforderung für Anwendungen dar, die hohe Zuverlässigkeit erfordern:

Stochastische Natur: Schwarm-Algorithmen nutzen Zufallselemente, was zu variablen Ergebnissen führt
Keine Optimalitätsgarantien: Schwarm-Algorithmen können erst einmal nicht garantieren, dass das globale Optimum gefunden wird
Emergentes Verhalten kann je nach Systemparameterwerten vorhanden sein oder nicht: Kleine Änderungen in den Regeln oder Bedingungen können zu qualitativ anderen globalen Verhaltensweisen führen

Diese Eigenschaften machen formale Verifikation und Validierung schwierig – ein kritischer Aspekt für sicherheitsrelevante Anwendungen wie autonome Fahrzeuge oder medizinische Robotik.

Ansätze zur Verbesserung umfassen:

Hybride Systeme, die Schwarm-Algorithmen mit klassischen, determinstischen Methoden kombinieren
Statistische Garantien durch multiple Läufe oder Ensemble-Ansätze
Formale Methoden zur Verifikation bestimmter Schwarm-Eigenschaften

Insgesamt ist dieses Gebiet jedoch eines der interessantesten, vielversprechendsten und zukunftsweisenden Bereiche, die wir in unseren Einheiten gesehen haben und sehen werden.

8.5 Übungsaufgabe: Conway’s Game of Life¶

Dieses berühmte Beispiel für Zelluläre Automaten wird uns heute die Basis für die Übungsaufgabe liefern. Hier geht es vielleicht nicht so sehr um Schwärme, sondern eher um das Phänomen der Emergenz. Wenn Sie dieses System noch nicht kennen, dann lassen Sie es sich vom LLM Ihrer Wahl kurz erklären. Einfach gesagt geht es darum, auf einer Art Bildschirm die Pixel nach bestimmten Regeln, die nur über die jeweiligen Nachbarn bestimmt werden, bei jedem Schritt in einer Iteration der Anzeige entweder aus- oder einzuschalten bzw. gleich zu lassen, wie sie sind.

Dadurch kann man viele sehr langweilige Konfigurationen erzeugen, aber auch einige faszinierende Dinge erleben, z.B. emergente Muster, die sich stabil über den Bildschirm bewegen.

8.5.1 Konkrete Schritte:¶

Implementieren Sie mit Hilfe Ihres LLMs den Bildschirm und die Regeln für Conway’s Game of Life. Begrenzen Sie die Anzeige des Bildschirms auf eine vernünftige Größe von Pixeln
Erstellen Sie verschiedene Anfangskonfigurationen und sehen Sie sich an, was damit passiert
Erstellen Sie eine Anfangsposition mit einem “Gleiter” und beobachten Sie dessen Bewegung
Experimentieren Sie nach Herzenslust!

Viel Vergnügen!

In [ ]:

FMCA-25 07: Gradient Descent, Stochastische Optimierung, Simulated Annealing, Genetische Algorithmen

Inhalt des Skriptums seit dem Sommersemester 2025

Hier finden Sie die Kapitel aus den Vergangenen Jahren (legacy):

Die Jupyter-Notebooks zur Legacy-Variante der Lehrveranstaltung finden Sie im zugehörigen GitHub-Repository.

7: Optimierung: Gradient Descent, Stochastische Optimierung, Simulated Annealing, Genetische Algorithmen¶

Die Optimierung ist ein zentrales mathematisches Konzept, bei dem es darum geht, die beste Lösung aus einer Menge von möglichen Lösungen zu finden. In diesem Notebook gebe ich Ihnen zunächst eine kurze generelle Einführung und zeige Ihnen dann einige wichtige und interessante Varianten.

Nach dem Studium dieser Einheit sollten Sie zumindest folgende drei der wichtigsten Punkte hier verstehen:¶

Was Optimierung ist und was sie leistet.
Wie man sich ein Optimierungsproblem schwer, aber auch sehr leicht machen kann.
Welche verschiedenen Möglichkeiten der Optimierung es gibt und was diese besonders gut können.

7.1 Einführung in die Optimierung¶

Bei der Optimierung geht es darum, ein konkretes Problem zu lösen bei dem etwas optimal werden soll bzw. bei dem man die optimale Lösung des Problems finden will. Optimierung ist dabei sehr facettenreich, sowohl was die Probleme, als auch was die Lösungsmethoden betrifft.

7.1.1 Grundlegende Konzepte: Zielfunktionen, Constraints, lokale vs. globale Optima¶

Vorab müssen wir uns mit einigen grundlegenden Begriffen vertraut machen. Zunächst nennt man eine Problemstellung, bei der etwas möglichst gut, groß oder klein werden soll, ein Optimierungsproblem. Meist ist es recht einfach, irgendeine Lösung des Problems zu finden, aber man weiß dabei nicht, ob es die beste ist oder nicht oder gar besonders schlecht.

Eine Zielfunktion (auch Kostenfunktion oder Fitnessfunktion genannt) quantifiziert, wie “gut” eine Lösung ist. Wir suchen entweder ihr Minimum oder Maximum, je nachdem, ob es sich um ein Minimierungsproblem oder ein Maximierungsproblem handelt. An dieser Stelle gleich eine wichtige Information: Man kann ein Minimierungsproblem direkt in ein Maximierungsproblem überführen (und umgekehrt), indem man die Zielfunktion mit $-1$ multipliziert. Daher werden wir im Folgenden immer nur einen Fall betrachten und im Hinterkopf behalten, dass damit beide Situationen behandelbar sind.

Constraints (Nebenbedingungen) schränken den Lösungsraum ein und definieren so, welche Lösungen zulässig sind. Grundsätzlich kann es bei Optimierungsproblemen verschiedene Einschränkungen geben:

Die erlaubten Wertebereiche der Input-Variablen können eingeschränkt sein
Die Wertebereiche der Zielfunktion können eingeschränkt sein
Die Werte der Input-Variablen können durch eine sogenannte Nebenbedingung zusammenhängen
Der “Anspruch” der Optimierung kann eingeschränkt sein auf entweder lokale oder globale Optima, die man finden möchte.

Bei der Unterscheidung zwischen lokalen und globalen Optima geht es um die Frage, ob ein Optimum nur in seiner unmittelbaren Umgebung das Beste ist (lokal) oder tatsächlich die beste Lösung im gesamten Suchraum darstellt (global).

Zum Abschluss dieser Übersicht über die wichtigsten Begriffe noch ein paar Hinweise: Durch die Definition einer geeigneten Zielfunktion kann nahezu jedes Problem als Optimierungsproblem formuliert werden. Die Herausforderung besteht dann darin, eine Methode zu finden, die effizient zum globalen Optimum führt, ohne in lokalen Optima “stecken zu bleiben”. Eine visuelle Darstellung von Zielfunktionen als Landschaften mit Tälern (Minima) und Bergen (Maxima) hilft grundsätzlich dabei, ein Gefühl für das jeweilige Problem zu bekommen und die Herausforderungen der Optimierung zu verstehen. In komplexen, hochdimensionalen Räumen kann diese Landschaft allerdings extrem unübersichtlich werden.

7.1.2 Klassifizierung von Optimierungsproblemen (linear, konvex, nicht-konvex)¶

Optimierungsprobleme lassen sich in bestimmte Klassen einteilen:

Lineare Optimierungsprobleme zeichnen sich durch lineare Zielfunktionen und lineare Constraints aus. Sie sind besonders gut handhabbar, da die optimale Lösung immer an den Rändern des zulässigen Bereichs liegt. Der Simplex-Algorithmus und Interior-Point-Methoden lösen solche Probleme effizient und garantiert optimal. Hier gleich ein Beispiel. Die Code-Snippets in diesem Notebook stammen in bewährter Manier von Claude 3.7 Sonnet. Der folgende Code definiert und löst das lineare Optimierungsproblem mit der Zielfunktion $f(x, y) = 3x + 2y$, die zu maximieren ist, unter den Nebenbedingungen $2x + y \le 20$, $x + 2y \le 20$ und $x, y \gt 0$.

In [13]:

import os
os.environ['MKL_DISABLE_FAST_MM'] = '1'
# Rest des Codes...import numpy as np
import matplotlib.pyplot as plt
from scipy.optimize import linprog

# Definiere das Beispiel eines linearen Optimierungsproblems
# Maximiere: f(x, y) = 3x + 2y
# unter den Nebenbedingungen:
#   2x + y ≤ 20
#   x + 2y ≤ 20
#   x, y ≥ 0

# Für linprog müssen wir das Problem umformulieren:
# Minimiere: -3x - 2y
# unter den Nebenbedingungen:
#   2x + y ≤ 20
#   x + 2y ≤ 20
#   x, y ≥ 0

# Koeffizienten der Zielfunktion (negativ für Maximierung)
c = [-3, -2]

# Koeffizienten der Ungleichungsnebenbedingungen
A = [[2, 1],  # 2x + y ≤ 20
     [1, 2]]  # x + 2y ≤ 20

# Rechte Seite der Ungleichungsnebenbedingungen
b = [20, 20]

# Löse das lineare Optimierungsproblem
res = linprog(c, A_ub=A, b_ub=b, bounds=(0, None))

# Ausgabe der Ergebnisse
print(f"Optimale Lösung gefunden: {res.success}")
print(f"Optimaler Punkt: x = {res.x[0]:.2f}, y = {res.x[1]:.2f}")
print(f"Optimaler Zielfunktionswert: {-res.fun:.2f}")  # Negativ, da wir maximieren

# Visualisierung
x = np.linspace(0, 25, 1000)

# Nebenbedingungen als Funktionen von x
y1 = 20 - 2*x  # 2x + y = 20 => y = 20 - 2x
y2 = (20 - x)/2  # x + 2y = 20 => y = (20 - x)/2

# Zielfunktionswerte für verschiedene Ebenen
z_levels = [0, 20, 40, 60]
z_lines = [(z - 3*x)/2 for z in z_levels]  # 3x + 2y = z => y = (z - 3x)/2

# Plot erstellen
plt.figure(figsize=(10, 6))

# Zeichne den zulässigen Bereich
plt.fill_between(x, 0, np.minimum(y1, y2), where=(x >= 0) & (y1 >= 0) & (y2 >= 0), 
                 alpha=0.2, color='skyblue', label='Zulässiger Bereich')

# Zeichne die Nebenbedingungen
plt.plot(x, y1, 'r-', label='2x + y = 20')
plt.plot(x, y2, 'g-', label='x + 2y = 20')
plt.axhline(y=0, color='k', linestyle='-', alpha=0.3, label='y = 0')
plt.axvline(x=0, color='k', linestyle='-', alpha=0.3, label='x = 0')

# Zeichne die Zielfunktionsebenen
for i, z_line in enumerate(z_lines):
    plt.plot(x, z_line, 'b--', alpha=0.5, label=f'3x + 2y = versch.' if i==0 else None)

# Markiere den optimalen Punkt
plt.plot(res.x[0], res.x[1], 'ro', markersize=10, label=f'Optimum ({res.x[0]:.1f}, {res.x[1]:.1f})')

# Beschrifte den Plot
plt.xlim(0, 22)
plt.ylim(0, 15)
plt.xlabel('x')
plt.ylabel('y')
plt.title('Lineares Optimierungsproblem: Maximiere 3x + 2y')
plt.grid(True, alpha=0.3)
plt.legend(loc='upper right')

plt.tight_layout()
plt.show()

Optimale Lösung gefunden: True
Optimaler Punkt: x = 6.67, y = 6.67
Optimaler Zielfunktionswert: 33.33

In diesem Plot sehen wir folgende Elemente:

Den zulässigen Bereich (hellblau)
Die Grenzen der Nebenbedingungen als rote und grüne Linien
Mehrere Höhenlinien der Zielfunktion als gestrichelte blaue Linien
Den optimalen Punkt als rotes Scheibchen

Der optimale Punkt liegt an der Schnittstelle der beiden Nebenbedingungen, was für lineare Optimierungsprobleme typisch ist (optimale Lösungen befinden sich immer an den “Ecken” des zulässigen Bereichs). Der Programmoutput vor dem Plot zeigt sowohl die Koordinaten des optimalen Punktes als auch den maximalen Wert der Zielfunktion.

Konvexe Optimierungsprobleme erweitern das Konzept der linearen Optimierung. Hier ist die Zielfunktion konvex (d.h. jede Verbindungslinie zwischen zwei Punkten auf dem Funktionsgraphen liegt zur Gänze oberhalb oder auf dem Graphen) und der zulässige Bereich bildet eine konvexe Menge (die gerade Verbindung zwischen zwei Punkten der Menge liegt zur Gänze innerhalb der Menge). Entscheidend ist, dass für konvexe Probleme jedes lokale Optimum auch global optimal ist, was die Suche erheblich vereinfacht.

Hier wieder gleich ein Beispiel. Zur Lösung solcher Probleme verwendet man Gradient Descent, den wir uns weiter unten genauer ansehen werden (hier wird eine Variante davon verwendet). Visuell sehen solche Probleme im Prinzip immer aus wie eine Art “Schüssel”.

In [4]:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D
from scipy.optimize import minimize

# Definiere eine konvexe Funktion: f(x,y) = x^2 + 2y^2 + 2*x*y + 2x + 4y + 3
def konvexe_funktion(X):
    x, y = X
    return x**2 + 2*y**2 + 2*x*y + 2*x + 4*y + 3

# Gradient der Funktion (für effizientere Optimierung)
def gradient(X):
    x, y = X
    return np.array([2*x + 2*y + 2, 4*y + 2*x + 4])

# Erstelle Gitterpunkte für die Visualisierung
x = np.linspace(-5, 3, 100)
y = np.linspace(-4, 2, 100)
X, Y = np.meshgrid(x, y)
Z = np.zeros_like(X)

# Berechne die Funktionswerte für alle Gitterpunkte
for i in range(len(x)):
    for j in range(len(y)):
        Z[j, i] = konvexe_funktion([X[j, i], Y[j, i]])

# Führe die Optimierung durch - finde das Minimum der Funktion
startpunkt = np.array([0.0, 0.0])  # Startpunkt für die Optimierung
ergebnis = minimize(konvexe_funktion, startpunkt, method='BFGS', jac=gradient)

# Ausgabe der Optimierungsergebnisse
print("Optimierung erfolgreich:", ergebnis.success)
print("Anzahl der Funktionsaufrufe:", ergebnis.nfev)
print("Minimum gefunden bei x =", ergebnis.x[0], ", y =", ergebnis.x[1])
print("Funktionswert am Minimum:", ergebnis.fun)

# Zeige mathematisch, dass diese Funktion tatsächlich konvex ist
print("\nNachweis der Konvexität:")
print("Die Hesse-Matrix dieser Funktion ist:")
print("H = [[2, 2], [2, 4]]")
print("Eigenwerte der Hesse-Matrix:", np.linalg.eigvals(np.array([[2, 2], [2, 4]])))
print("Da alle Eigenwerte positiv sind, ist die Funktion streng konvex.")

# Zeichne die Funktion und das Minimum als 3D-Plot
fig = plt.figure(figsize=(12, 5))

# 3D-Oberflächenplot
ax1 = fig.add_subplot(1, 2, 1, projection='3d')
surf = ax1.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8, linewidth=0, antialiased=True)
ax1.scatter(ergebnis.x[0], ergebnis.x[1], ergebnis.fun, color='red', s=50, label='Minimum')

ax1.set_xlabel('x')
ax1.set_ylabel('y')
ax1.set_zlabel('f(x,y)')
ax1.set_title('Konvexe Funktion: f(x,y) = x² + 2y² + 2xy + 2x + 4y + 3')
fig.colorbar(surf, ax=ax1, shrink=0.5, aspect=5)

# Konturplot mit Optimierungspfad
ax2 = fig.add_subplot(1, 2, 2)
contour = ax2.contour(X, Y, Z, 20, cmap='viridis')
ax2.scatter(ergebnis.x[0], ergebnis.x[1], color='red', s=50, label='Minimum')

# Zeige zwei Punkte und ihre Verbindungslinie, um die Konvexitätseigenschaft zu demonstrieren
punkt1 = np.array([-3, -2])
punkt2 = np.array([2, 1])
linie_x = np.linspace(punkt1[0], punkt2[0], 100)
linie_y = np.linspace(punkt1[1], punkt2[1], 100)
linie_z = np.zeros_like(linie_x)

# Berechne Funktionswerte entlang der Linie
for i in range(len(linie_x)):
    linie_z[i] = konvexe_funktion([linie_x[i], linie_y[i]])

# Zeichne die Punkte und die Linie im 3D-Plot
ax1.scatter(punkt1[0], punkt1[1], konvexe_funktion(punkt1), color='blue', s=50)
ax1.scatter(punkt2[0], punkt2[1], konvexe_funktion(punkt2), color='blue', s=50)
ax1.plot(linie_x, linie_y, linie_z, 'b-', linewidth=2)

# Zeichne die Punkte auch im Konturplot
ax2.scatter(punkt1[0], punkt1[1], color='blue', s=50)
ax2.scatter(punkt2[0], punkt2[1], color='blue', s=50)
ax2.plot(linie_x, linie_y, 'b-', linewidth=2, label='Verbindungslinie')

ax2.set_xlabel('x')
ax2.set_ylabel('y')
ax2.set_title('Höhenlinien und Minimum')
ax2.legend()
ax2.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Demonstration der Konvexitätseigenschaft
# Berechne einige Punkte auf der Verbindungslinie und vergleiche mit der tatsächlichen Funktion
print("\nDemonstration der Konvexitätseigenschaft:")
print("Für zwei Punkte auf dem Funktionsgraphen:")
print(f"Punkt 1: ({punkt1[0]}, {punkt1[1]}) mit f(Punkt1) = {konvexe_funktion(punkt1):.2f}")
print(f"Punkt 2: ({punkt2[0]}, {punkt2[1]}) mit f(Punkt2) = {konvexe_funktion(punkt2):.2f}")

# Wähle einen Punkt auf der Verbindungslinie (z.B. bei t=0.4)
t = 0.4
punkt_mitte = t * punkt1 + (1-t) * punkt2
f_mitte = konvexe_funktion(punkt_mitte)
f_linie = t * konvexe_funktion(punkt1) + (1-t) * konvexe_funktion(punkt2)

print("\nFür t =", t, "gilt:")
print(f"Punkt auf der Verbindungsstrecke: ({punkt_mitte[0]:.2f}, {punkt_mitte[1]:.2f})")
print(f"Tatsächlicher Funktionswert: f(Punkt) = {f_mitte:.2f}")
print(f"Wert auf der Verbindungslinie: {f_linie:.2f}")
print(f"Konvexitätsbedingung: f(Punkt) ≤ Wert auf Verbindungslinie: {f_mitte:.2f} ≤ {f_linie:.2f}")
print(f"Die Konvexitätsbedingung ist {'erfüllt' if f_mitte <= f_linie else 'nicht erfüllt'}")

Optimierung erfolgreich: True
Anzahl der Funktionsaufrufe: 7
Minimum gefunden bei x = 1.228951805089533e-07 , y = -1.0000000682610473
Funktionswert am Minimum: 1.0000000000000075

Nachweis der Konvexität:
Die Hesse-Matrix dieser Funktion ist:
H = [[2, 2], [2, 4]]
Eigenwerte der Hesse-Matrix: [0.76393202 5.23606798]
Da alle Eigenwerte positiv sind, ist die Funktion streng konvex.

Demonstration der Konvexitätseigenschaft:
Für zwei Punkte auf dem Funktionsgraphen:
Punkt 1: (-3, -2) mit f(Punkt1) = 18.00
Punkt 2: (2, 1) mit f(Punkt2) = 21.00

Für t = 0.4 gilt:
Punkt auf der Verbindungsstrecke: (-0.00, -0.20)
Tatsächlicher Funktionswert: f(Punkt) = 2.28
Wert auf der Verbindungslinie: 19.80
Konvexitätsbedingung: f(Punkt) ≤ Wert auf Verbindungslinie: 2.28 ≤ 19.80
Die Konvexitätsbedingung ist erfüllt

Hier sieht man gut den Punkt für die optimale Lösung am tiefsten Punkt der “Schüssel”. Aufgrund des Zusammenhangs von globalen und lokalen Optima bei konvexen Optimierungsproblemen muss man höchstens auf die Aufgabenstellung achten. Wäre im obigen Beispiel nämlich das Maximum und nicht das Minimum gefragt, und wäre der Parameterraum auf den in der Graphik sichtbaren Bereich eingeschränkt, so müsste man das Optimum am Rand des erlaubten Bereichs suchen!

Nicht-konvexe Probleme stellen die größte Herausforderung dar. Ihre Zielfunktionen haben multiple lokale Optima, die nicht notwendigerweise global sind (denn nur eines kann global sein). Deterministische Verfahren wie Gradient Descent bleiben hier gern in lokalen Optima hängen. Oft weiß man auch gar nicht, ob man überhaupt ein globales Optimum gefunden hat oder finden kann. Für diese Problemklasse werden oft stochastische Methoden wie Simulated Annealing oder genetische Algorithmen eingesetzt, die durch kontrollierte Zufallselemente lokale Optima überwinden können. Wir werden uns diese beiden Algorithmen daher weiter unten ebenfalls ansehen. Die meisten echten und bereits auch nur ein Bisschen komplexeren Probleme fallen in diese Kategorie.

7.1.3 Der Gradient und seine Bedeutung für die Optimierung¶

Der Gradient einer Funktion ist ein Vektor, der in Richtung des steilsten Anstiegs zeigt. Seine Bedeutung für die Optimierung ist fundamental: Er gibt uns für jeden Punkt im Suchraum die Richtung an, in der wir uns bewegen sollten, um die Zielfunktion am schnellsten zu minimieren (durch Bewegung entgegen dem Gradienten) oder zu maximieren (durch Bewegung in Richtung des Gradienten). In differenzierbaren Funktionen ist der Gradient am Optimum gleich Null – ein wichtiges Kriterium zur Identifikation potenzieller Optima.

Die Verbindung zwischen Gradient und Konvexität bestimmt maßgeblich die Wahl des Optimierungsalgorithmus. Bei konvexen Problemen reicht es, dem Gradienten zu folgen, um das globale Optimum zu finden. Bei nicht-konvexen Problemen hingegen kann der Gradient wie gesagt in die Irre führen, weil er ganz einfach zum nächsten (oder zum ersten, das im Pfad des Gradienten vorkommt) lokalen statt dem globalen Optimum navigiert. An dieser Problematik können auch zusätzliche Techniken wie Momentum, adaptive Lernraten oder sogar völlig andere Ansätze ohne Gradienteninformation benötigt.

7.2 Der Gradient-Descent-Algorithmus¶

Gradient Descent ist der Einsteiger-Algorithmus in der numerischen Optimierung von Problemen. Das Prinzip ist einfach, aber der Teufel steckt oft im Detail, wie wir zum Teil bereits besprochen haben. Hier kommen noch ein paar Details dazu.

7.2.1 Grundprinzip: Iterative Annäherung an das Minimum¶

Gradient Descent ist ein Optimierungsverfahren, das schrittweise dem negativen Gradienten der Zielfunktion folgt, um ein Minimum zu finden. Der Algorithmus startet an einem zufälligen Punkt und bewegt sich iterativ in Richtung des steilsten Abstiegs, welcher durch den negativen Gradienten angegeben wird. Die mathematische Update-Regel lautet: $\theta_{i+1} = \theta_{i} – \eta \nabla f(\theta_{i})$, wobei $\eta$ die Lernrate ist und $\nabla f$ den Gradienten der Zielfunktion $f$ darstellt.

Der Algorithmus funktioniert, weil der negative Gradient lokal die Richtung der schnellsten Abnahme der Zielfunktion angibt. Bei jedem Schritt bewegt sich der Algorithmus ein Stück in diese Richtung, berechnet an der neuen Position erneut den Gradienten und passt die Richtung entsprechend an. Dieser Prozess wird wiederholt, bis ein Abbruchkriterium erfüllt ist – typischerweise wenn der Gradient nahezu verschwindet (wir sind am Minimum) oder eine maximale Anzahl von Iterationen erreicht wurde.

Die Konvergenz von Gradient Descent hängt stark von der Landschaft der Zielfunktion ab. Bei konvexen Funktionen ist die Sache relativ geradlinig. Bei nicht-konvexen Funktionen kann der Algorithmus in lokalen Minima stecken bleiben. Die Visualisierung des Verfahrens als “Abstieg in einer Gebirgslandschaft” vermittelt ein intuitive Verständnis: Der Algorithmus folgt stets dem steilsten Pfad ins Tal, kann aber in einer lokalen Senke stecken bleiben, wenn er keinen Weg sieht, um über einen Hügel oder einen Pass zu einem tieferen Tal zu gelangen.

7.2.2 Wahl der Lernrate und ihr Einfluss auf die Konvergenz¶

Die Lernrate $\eta$ bestimmt die Schrittweite bei jedem Update-Schritt des Gradient-Descent-Verfahrens. Sie ist ein kritischer Hyperparameter mit enormem Einfluss auf die Konvergenzgeschwindigkeit und -garantie. Eine zu große Lernrate kann zu Oszillationen oder sogar Divergenz führen, da der Algorithmus über das Minimum hinausschießt. Eine zu kleine Lernrate hingegen führt zu unnötig langsamer Konvergenz und erhöht die Gefahr, in flachen Plateaus der Zielfunktion stecken zu bleiben.

Die optimale Lernrate hängt von den Eigenschaften der Zielfunktion ab, insbesondere von ihrer Krümmung. Bei stark unterschiedlichen Krümmungen in verschiedenen Richtungen entsteht folgendes Problem: Der Algorithmus oszilliert quer zu schmalen Tälern, während er sich nur langsam entlang des Tals bewegt. Adaptive Lernratenverfahren wie AdaGrad, RMSprop oder Adam wurden entwickelt, um diese Problematik zu adressieren, indem sie die Lernrate dynamisch für jede Dimension separat anpassen.

In der Praxis werden Lernraten oft durch empirische Suche optimiert, beginnend mit einer groben Schätzung (z.B. 0.1, 0.01, 0.001) und anschließender Verfeinerung. Alternativ können Lernraten-Schedules verwendet werden, bei denen die Lernrate im Laufe der Optimierung systematisch reduziert wird. Dies ermöglicht zu Beginn große Schritte für schnellen Fortschritt und später kleinere Schritte für eine präzise Annäherung an das Optimum.

Hier noch eine kurze Veranschaulichung dieser Problematik anhand der konvexen Funktion von oben. Hier finden Sie somit auch eine einfache explizite Implementierung von Gradient Descent. Wir demonstrieren den Effekt, indem wir drei Werte für die Lernrate einsetzen.

In [5]:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.animation import FuncAnimation
from mpl_toolkits.mplot3d import Axes3D

# Definiere die konvexe Funktion: f(x,y) = x^2 + 2y^2 + 2*x*y + 2x + 4y + 3
def konvexe_funktion(x, y):
    return x**2 + 2*y**2 + 2*x*y + 2*x + 4*y + 3

# Gradient der Funktion
def gradient(x, y):
    df_dx = 2*x + 2*y + 2
    df_dy = 4*y + 2*x + 4
    return np.array([df_dx, df_dy])

# Implementierung des Gradient Descent Algorithmus
def gradient_descent(start_punkt, lernrate, max_iterationen, toleranz=1e-6):
    # Startpunkt
    punkt = np.array(start_punkt, dtype=float)
    
    # Liste zur Speicherung der Punktfolge für die Visualisierung
    punkte_historie = [punkt.copy()]
    funktionswerte = [konvexe_funktion(punkt[0], punkt[1])]
    
    # Iteratives Update
    for i in range(max_iterationen):
        # Berechne den Gradienten am aktuellen Punkt
        grad = gradient(punkt[0], punkt[1])
        
        # Berechne die Norm des Gradienten (für Abbruchkriterium)
        grad_norm = np.linalg.norm(grad)
        
        # Abbruchkriterium: Wenn der Gradient nahe Null ist, haben wir ein Minimum gefunden
        if grad_norm < toleranz:
            print(f"Konvergenz nach {i+1} Iterationen!")
            break
            
        # Update-Regel: Bewegung in Richtung des negativen Gradienten
        punkt = punkt - lernrate * grad
        
        # Speichere für die Visualisierung
        punkte_historie.append(punkt.copy())
        funktionswerte.append(konvexe_funktion(punkt[0], punkt[1]))
    
    # Wenn die maximale Anzahl an Iterationen erreicht wurde
    else:
        print(f"Maximale Anzahl von {max_iterationen} Iterationen erreicht ohne Konvergenz.")
    
    return np.array(punkte_historie), np.array(funktionswerte)

# Optimales analytisches Minimum berechnen
# Für f(x,y) = x^2 + 2y^2 + 2*x*y + 2x + 4y + 3
# Löse das lineare Gleichungssystem:
# df/dx = 2x + 2y + 2 = 0
# df/dy = 4y + 2x + 4 = 0

# Aus der ersten Gleichung: x = -y - 1
# In die zweite einsetzen: 4y + 2(-y - 1) + 4 = 0
# 4y - 2y - 2 + 4 = 0
# 2y + 2 = 0
# y = -1

# Dann x = -y - 1 = -(-1) - 1 = 0
optimum = np.array([0, -1])
optimum_wert = konvexe_funktion(optimum[0], optimum[1])
print(f"Analytisches Optimum bei x = {optimum[0]}, y = {optimum[1]}")
print(f"Optimaler Funktionswert: {optimum_wert}")

# Gitterpunkte für die Visualisierung erstellen
x = np.linspace(-5, 5, 100)
y = np.linspace(-5, 5, 100)
X, Y = np.meshgrid(x, y)
Z = konvexe_funktion(X, Y)

# Startpunkt für alle drei Versuche
startpunkt = np.array([4.0, 3.0])

# Drei verschiedene Lernraten ausprobieren
# 1. Zu groß (führt zu Divergenz oder Oszillation)
lernrate_zu_gross = 0.9
# 2. Zu klein (zu langsame Konvergenz)
lernrate_zu_klein = 0.01
# 3. Optimal (schnelle Konvergenz)
lernrate_optimal = 0.1

# Anzahl der maximalen Iterationen
max_iter = 50

# Durchführung der Optimierung mit drei verschiedenen Lernraten
punkte_zu_gross, werte_zu_gross = gradient_descent(startpunkt, lernrate_zu_gross, max_iter)
punkte_zu_klein, werte_zu_klein = gradient_descent(startpunkt, lernrate_zu_klein, max_iter)
punkte_optimal, werte_optimal = gradient_descent(startpunkt, lernrate_optimal, max_iter)

# Erstelle Plots für die Visualisierung
fig, axs = plt.subplots(2, 2, figsize=(16, 12))

# 3D-Plot der Funktion (oben links)
ax_3d = fig.add_subplot(2, 2, 1, projection='3d')
surf = ax_3d.plot_surface(X, Y, Z, cmap='viridis', alpha=0.7, linewidth=0)
ax_3d.set_xlabel('x')
ax_3d.set_ylabel('y')
ax_3d.set_zlabel('f(x,y)')
ax_3d.set_title('Konvexe Funktion und optimale Gradient-Descent-Trajektorie')

# Optimale Trajektorie im 3D-Plot
ax_3d.plot(punkte_optimal[:, 0], punkte_optimal[:, 1], werte_optimal, 'r.-', linewidth=2, markersize=8)
ax_3d.plot([optimum[0]], [optimum[1]], [optimum_wert], 'mo', markersize=10, label='Globales Minimum')

# Contour-Plot mit zu großer Lernrate (oben rechts)
axs[0, 1].contour(X, Y, Z, levels=50, cmap='viridis')
axs[0, 1].set_title(f'Lernrate zu groß (η = {lernrate_zu_gross})')
axs[0, 1].plot(punkte_zu_gross[:, 0], punkte_zu_gross[:, 1], 'r.-', linewidth=2, markersize=8)
axs[0, 1].plot(optimum[0], optimum[1], 'mo', markersize=10)
axs[0, 1].set_xlabel('x')
axs[0, 1].set_ylabel('y')
axs[0, 1].grid(True)

# Contour-Plot mit zu kleiner Lernrate (unten links)
axs[1, 0].contour(X, Y, Z, levels=50, cmap='viridis')
axs[1, 0].set_title(f'Lernrate zu klein (η = {lernrate_zu_klein})')
axs[1, 0].plot(punkte_zu_klein[:, 0], punkte_zu_klein[:, 1], 'r.-', linewidth=2, markersize=8)
axs[1, 0].plot(optimum[0], optimum[1], 'mo', markersize=10)
axs[1, 0].set_xlabel('x')
axs[1, 0].set_ylabel('y')
axs[1, 0].grid(True)

# Contour-Plot mit optimaler Lernrate (unten rechts)
axs[1, 1].contour(X, Y, Z, levels=50, cmap='viridis')
axs[1, 1].set_title(f'Lernrate optimal (η = {lernrate_optimal})')
axs[1, 1].plot(punkte_optimal[:, 0], punkte_optimal[:, 1], 'r.-', linewidth=2, markersize=8)
axs[1, 1].plot(optimum[0], optimum[1], 'mo', markersize=10)
axs[1, 1].set_xlabel('x')
axs[1, 1].set_ylabel('y')
axs[1, 1].grid(True)

# Legende für das gesamte Figure
fig.legend(['Gradient Descent Pfad', 'Globales Minimum'], loc='upper center', bbox_to_anchor=(0.5, 0.05), ncol=2)

plt.tight_layout()

# Plot der Konvergenz (Funktionswert über Iterationen)
plt.figure(figsize=(10, 6))
plt.plot(werte_zu_gross, 'r-', linewidth=2, label=f'Zu große Lernrate (η = {lernrate_zu_gross})')
plt.plot(werte_zu_klein, 'g-', linewidth=2, label=f'Zu kleine Lernrate (η = {lernrate_zu_klein})')
plt.plot(werte_optimal, 'b-', linewidth=2, label=f'Optimale Lernrate (η = {lernrate_optimal})')
plt.axhline(y=optimum_wert, color='m', linestyle='--', label='Optimaler Wert')
plt.xlabel('Iteration')
plt.ylabel('Funktionswert')
plt.title('Konvergenzverhalten bei verschiedenen Lernraten')
plt.grid(True)
plt.legend()
plt.yscale('log')  # Logarithmische Skala für bessere Sichtbarkeit

plt.tight_layout()
plt.show()

Analytisches Optimum bei x = 0, y = -1
Optimaler Funktionswert: 1
Maximale Anzahl von 50 Iterationen erreicht ohne Konvergenz.
Maximale Anzahl von 50 Iterationen erreicht ohne Konvergenz.
Maximale Anzahl von 50 Iterationen erreicht ohne Konvergenz.

In den oberen Subplots sieht man hier das Konvergenzverhalten für zu große, zu kleine und gut geeignete Lernrate. Danach sehen Sie im Plot, wie sich die Werte der Zielfunktion über die Interationsschritte verändern.

7.2.3 Anwendungsbereiche von Gradient Descent, Vorteile und Nachteile¶

Gradient Descent findet breite Anwendung in Bereichen, wo differenzierbare Zielfunktionen optimiert werden müssen. Besonders prominent ist der Einsatz beim Training von Machine-Learning-Modellen, von der linearen und logistischen Regression bis hin zu komplexen neuronalen Netzen. Auch in der Signalverarbeitung, Steuerungstechnik und vielen Simulationsmodellen ist Gradient Descent ein Standardwerkzeug.

Die Vorteile von Gradient Descent liegen in seiner konzeptionellen Einfachheit, mathematischen Fundiertheit und effizienten Implementierbarkeit. Für konvexe Probleme bietet es garantierte Konvergenz zum globalen Optimum. Moderne Varianten wie stochastischer Gradient Descent (SGD) ermöglichen die Skalierung auf sehr große Datensätze, indem sie Gradienten auf Teilmengen (Mini-Batches) der Daten berechnen. Erweiterungen wie Momentum, Nesterov-Beschleunigung und andere adaptive Lernratenverfahren verbessern die Konvergenzgeschwindigkeit und Robustheit erheblich.

Typische Nachteile sind die bereits erwähnte und offensichtliche Anfälligkeit für lokale Minima in nicht-konvexen Landschaften, die Notwendigkeit differenzierbarer Zielfunktionen (bzw. numerischer Approximationen für den Gradienten bei Daten auf einem Grid) und die Schwierigkeit der Hyperparameter-Wahl. Die Leistung hängt stark von der Initialisierung ab, und schlecht konditionierte Probleme können zu sehr langsamer Konvergenz führen. Zudem ist Gradient Descent nicht direkt auf diskrete oder kombinatorische Probleme anwendbar. Für diese Fälle sind alternative Verfahren wie stochastische Suche, Simulated Annealing oder genetische Algorithmen oft besser geeignet.

7.3 Stochastische Optimierung¶

Stochastische Optimierung ist eine Alternative zu deterministischen Methoden wie Gradient Descent. Sie überwindet jene Probleme, die wir bereits kennen gelernt haben, auch wenn dabei etwas Unsicherheit ins Spiel kommt. Trotzdem hat man ausreichend Kontrollmöglichkeiten und kann mit stochastischen Methoden teilweise (zumindest näherungsweise) Probleme lösen, die auf direktem oder traditionellem Weg de facto unlösbar wären.

7.3.1 (Pseudo-)Zufallszahlen¶

Alle stochastischen Methoden arbeiten auf der Grundlage von Zufallszahlen. Da es (vielleicht etwas überraschenderweise) schwierig ist, echte Zufallszahlen zu erzeugen, begnügt man sich mit sogenannten Pseudozufallszahlen. Pseudozufallszahlen sind deterministisch generierte Zahlenwerte, die statistische Tests auf Zufälligkeit bestehen, obwohl sie vollständig vorhersagbar sind, wenn man den Generierungsalgorithmus und dessen Anfangszustand (Seed) kennt.

In der wissenschaftlichen Programmierung ist die Kontrolle des Zufallsgenerator-Seeds entscheidend für die Reproduzierbarkeit von Ergebnissen. In Python wird dies typischerweise mit np.random.seed() umgesetzt. Die Qualität von Pseudozufallszahlengeneratoren wird anhand verschiedener statistischer Eigenschaften beurteilt, darunter Periodenlänge, korrekte Verteilung (z.B. Gleichverteilung) und Unabhängigkeit aufeinanderfolgender Werte.

Für die stochastische Optimierung werden im Allgemeinen verschiedene Verteilungen benötigt, z.B. Gleichverteilungen oder Normalverteilungen. Sehen wir uns das hier gleich einmal konkret an:

In [15]:

import numpy as np
import matplotlib.pyplot as plt

# Für Reproduzierbarkeit einen Seed setzen
np.random.seed(42)

# Anzahl der zu generierenden Punkte
n_samples = 2000

# 1. Generiere gleichverteilte Zufallszahlen im Intervall [0,1] x [0,1]
uniform_samples = np.random.uniform(0, 1, size=(n_samples, 2))

# 2. Generiere normalverteilte Zufallszahlen mit Mittelwert 0 und Standardabweichung 1
gaussian_samples = np.random.normal(0, 1, size=(n_samples, 2))

# Erstelle eine Figur mit zwei Subplots
fig, axes = plt.subplots(1, 2, figsize=(14, 6))

# --- PLOT 1: Gleichverteilung ---
axes[0].scatter(
    uniform_samples[:, 0], 
    uniform_samples[:, 1],
    s=10,  # Punktgröße
    alpha=0.6,  # Transparenz
    c='teal'  # Farbe
)

# Beschriftung des ersten Plots
axes[0].set_title('Gleichverteilung im Einheitsquadrat [0,1] × [0,1]')
axes[0].set_xlabel('X ~ U(0,1)')
axes[0].set_ylabel('Y ~ U(0,1)')
axes[0].grid(True, alpha=0.3)
axes[0].set_xlim(-0.05, 1.05)
axes[0].set_ylim(-0.05, 1.05)

# --- PLOT 2: Normalverteilung ---
axes[1].scatter(
    gaussian_samples[:, 0], 
    gaussian_samples[:, 1],
    s=10,
    alpha=0.6,
    c='navy'
)

# Beschriftung des zweiten Plots
axes[1].set_title('Normalverteilung mit Mittelwert 0 und Standardabweichung 1')
axes[1].set_xlabel('X ~ N(0,1)')
axes[1].set_ylabel('Y ~ N(0,1)')
axes[1].grid(True, alpha=0.3)
axes[1].set_xlim(-4, 4)
axes[1].set_ylim(-4, 4)

# Konzentrische Kreise für die Wahrscheinlichkeitsmasse (1, 2 und 3 Standardabweichungen)
circles = [1, 2, 3]
for r in circles:
    circle = plt.Circle((0, 0), r, fill=False, color='red', linestyle='--', alpha=0.7)
    axes[1].add_patch(circle)

plt.tight_layout()
plt.show()

7.3.2 Zufallsgesteuerte Suche im Lösungsraum¶

Die zufallsgesteuerte Suche bildet das Grundprinzip stochastischer Optimierungsverfahren. Im einfachsten Fall, der reinen Zufallssuche (Pure Random Search), werden Lösungskandidaten völlig zufällig im Suchraum generiert und evaluiert. Diese naive Strategie ist ineffizient, aber robust und kann als Baseline dienen. Fortgeschrittenere Methoden wie die iterative Zufallssuche beschränken die Exploration zunehmend auf vielversprechende Regionen, indem sie Informationen aus vorherigen Evaluationen nutzen.

Die Balance zwischen Exploration (Erkundung neuer Bereiche des Suchraums) und Exploitation (Ausnutzung bereits gefundener vielversprechender Regionen) ist ein zentrales Konzept in der stochastischen Optimierung. Zu starke Exploration verschwendet Rechenressourcen, während zu starke Exploitation zur Konvergenz in suboptimalen lokalen Optima führen kann (vergleichbar mit dem bekannten Problem beim Gradient Descent). Hier kann man auch stochastische mit konventionellen Suchalgorithmen kombinieren:

Multistart-Methoden kombinieren deterministische lokale Suche mit stochastischer globaler Exploration. Sie initialisieren mehrere lokale Suchalgorithmen (z.B. Gradient Descent) von verschiedenen zufälligen Startpunkten aus und wählen die beste gefundene Lösung. Diese Hybridmethode nutzt die Effizienz deterministischer Verfahren zur lokalen Optimierung, während sie durch die zufällige Komponente eine breitere Abdeckung des Suchraums erreicht. Im Kontext neuronaler Netze entspricht dies dem Training mit verschiedenen zufälligen Initialisierungen.

7.3.3 Akzeptanzkriterien für neue Lösungen, Konvergenzverhalten und theoretische Garantien¶

Akzeptanzkriterien bestimmen, wann eine neu generierte Lösung die aktuelle Lösung ersetzt. Das einfachste Kriterium akzeptiert nur Verbesserungen (Greedy-Strategie), was jedoch über kurz oder lang in erster Linie zu lokalen Optima führt. Fortgeschrittene stochastische Methoden verwenden probabilistische Akzeptanzkriterien, die auch Verschlechterungen mit bestimmten Wahrscheinlichkeiten zulassen. Diese Wahrscheinlichkeit kann von der Größe der Verschlechterung, der verstrichenen Zeit oder anderen Faktoren abhängen. Simulated Annealing beispielsweise (siehe unten) nutzt eine temperaturabhängige Boltzmann-Verteilung für die Akzeptanzwahrscheinlichkeit.

Das Konvergenzverhalten stochastischer Algorithmen unterscheidet sich fundamental von deterministischen Verfahren. Während deterministische Algorithmen oft monoton konvergieren, zeigen stochastische Verfahren typischerweise nicht-monotones Verhalten mit gelegentlichen Verschlechterungen. Die Konvergenzanalyse erfolgt daher meist probabilistisch: Man betrachtet die Wahrscheinlichkeit, mit der der Algorithmus eine Lösung innerhalb eines bestimmten Abstands vom Optimum findet, als Funktion der Iterationsanzahl oder Rechenzeit.

Hier ein Beispiel für die Funktion, die wir bereits von weiter oben kennen:

In [18]:

import numpy as np
import matplotlib.pyplot as plt

# Wir verwenden die gleiche konvexe Funktion wie zuvor:
# f(x,y) = x^2 + 2y^2 + 2*x*y + 2x + 4y + 3
def konvexe_funktion(x, y):
    return x**2 + 2*y**2 + 2*x*y + 2*x + 4*y + 3

# Einfache stochastische Optimierung: Random Search
def random_search(max_iterationen, suchbereich):
    # Analytisches Optimum (zum Vergleich)
    optimum = np.array([0.0, -1.0])
    optimum_wert = konvexe_funktion(optimum[0], optimum[1])
    
    # Startpunkt zufällig wählen
    beste_lösung = np.random.uniform(suchbereich[0], suchbereich[1], size=2)
    bester_wert = konvexe_funktion(beste_lösung[0], beste_lösung[1])
    
    # Historie für die Visualisierung
    historie_lösungen = [beste_lösung.copy()]
    historie_werte = [bester_wert]
    
    for i in range(max_iterationen):
        # Erzeuge einen zufälligen Punkt im Suchbereich
        kandidat = np.random.uniform(suchbereich[0], suchbereich[1], size=2)
        kandidat_wert = konvexe_funktion(kandidat[0], kandidat[1])
        
        # Speichere den Kandidaten für die Visualisierung
        historie_lösungen.append(kandidat.copy())
        historie_werte.append(kandidat_wert)
        
        # Wenn der Kandidat besser ist, aktualisiere die beste Lösung
        if kandidat_wert < bester_wert:
            beste_lösung = kandidat.copy()
            bester_wert = kandidat_wert
    
    return beste_lösung, bester_wert, np.array(historie_lösungen), np.array(historie_werte), optimum, optimum_wert

# Parameter
max_iter = 1000
suchbereich = [-5, 5]  # Suchbereich für x und y: [-5, 5] x [-5, 5]

# Führe die stochastische Optimierung durch
np.random.seed(42)  # Für Reproduzierbarkeit
beste_lösung, bester_wert, historie_lösungen, historie_werte, optimum, optimum_wert = random_search(max_iter, suchbereich)

# Ergebnisse ausgeben
print(f"Beste gefundene Lösung: x = {beste_lösung[0]:.4f}, y = {beste_lösung[1]:.4f}")
print(f"Bester gefundener Wert: {bester_wert:.4f}")
print(f"Analytisches Optimum: x = {optimum[0]:.4f}, y = {optimum[1]:.4f}")
print(f"Optimaler Wert: {optimum_wert:.4f}")
print(f"Abweichung vom Optimum: {abs(bester_wert - optimum_wert):.4f}")

# Visualisierung der Konvergenz
plt.figure(figsize=(15, 6))

# Plot 1: Alle getesteten Punkte im Suchraum
plt.subplot(1, 2, 1)
# Gitterpunkte für den Hintergrund (Konturen der Funktion)
x = np.linspace(suchbereich[0], suchbereich[1], 100)
y = np.linspace(suchbereich[0], suchbereich[1], 100)
X, Y = np.meshgrid(x, y)
Z = np.zeros_like(X)
for i in range(len(x)):
    for j in range(len(y)):
        Z[j, i] = konvexe_funktion(X[j, i], Y[j, i])

# Zeichne Konturen
plt.contour(X, Y, Z, 20, cmap='viridis', alpha=0.7)

# Zeige alle getesteten Punkte
plt.scatter(historie_lösungen[:, 0], historie_lösungen[:, 1], 
            c=np.arange(len(historie_lösungen)), cmap='autumn', 
            alpha=0.6, s=10, label='Getestete Punkte')

# Markiere das gefundene und das analytische Optimum
plt.scatter(beste_lösung[0], beste_lösung[1], 
            color='red', s=100, marker='*', label='Gefundenes Optimum')
plt.scatter(optimum[0], optimum[1], 
            color='blue', s=100, marker='o', label='Analytisches Optimum')

plt.xlim(suchbereich)
plt.ylim(suchbereich)
plt.title('Stochastische Optimierung: Random Search')
plt.xlabel('x')
plt.ylabel('y')
plt.grid(True, alpha=0.3)
plt.legend()

# Plot 2: Konvergenzverlauf des besten Funktionswerts
plt.subplot(1, 2, 2)

# Berechne den besten Wert bis zur i-ten Iteration
beste_werte_bis_i = np.minimum.accumulate(historie_werte)

# Zeichne den Konvergenzverlauf
plt.plot(beste_werte_bis_i, 'r-', linewidth=2, label='Bester Wert')
plt.axhline(y=optimum_wert, color='blue', linestyle='--', label='Optimaler Wert')

plt.title('Konvergenzverlauf')
plt.xlabel('Iteration')
plt.ylabel('Funktionswert')
plt.grid(True, alpha=0.3)
plt.legend()
plt.yscale('log')  # Logarithmische Skala für bessere Sichtbarkeit

plt.tight_layout()
plt.show()

Beste gefundene Lösung: x = -0.2842, y = -0.8816
Bester gefundener Wert: 1.0415
Analytisches Optimum: x = 0.0000, y = -1.0000
Optimaler Wert: 1.0000
Abweichung vom Optimum: 0.0415

Hier sieht man rechts die Konvergenz des niedrigsten gefundenen Werts der Zielfunktion mit der Anzahl der überprüften Punkte. Links sieht man die überprüften Punkte (bunt) und den stochastisch gefunenen Optimalen Wert (Stern) im Vergleich zum bekannten exakten Optimum (blaues Scheibchen).

Theoretische Garantien für stochastische Optimierungsverfahren sind oft schwächer als für deterministische Methoden, aber dennoch wertvoll. Für Simulated Annealing oder auch genetische Algorithmen existieren gewisse probabilistische Garantien, auf die wir hier nicht weiter eingehen. In der Praxis sind diese theoretischen Garantien nämlich oft weniger entscheidend als die empirische Leistung auf konkreten Probleminstanzen.

7.3.4 Anwendungsbereiche für stochastische Optimierung, Vorteile und Nachteile¶

Stochastische Optimierungsverfahren eignen sich besonders für nicht-konvexe, multimodale Probleme mit vielen lokalen Optima, wo deterministische Verfahren scheitern. Sie kommen z.B. bei der Hyperparameter-Optimierung in Machine Learning, kombinatorischen Optimierungsproblemen wie dem Traveling Salesman Problem, im Design und der Strukturoptimierung (z.B. Antennenentwurf), in der Finanzmodellierung (Portfoliooptimierung) und bei Scheduling-Problemen zum Einsatz.

Die Vorteile stochastischer Verfahren liegen in ihrer Robustheit gegenüber lokalen Optima, der Anwendbarkeit auf nicht-differenzierbare oder diskrete Funktionen, und der häufig einfachen Implementierung. Sie benötigen typischerweise weniger Problemwissen und können direkt auf Black-Box-Funktionen angewendet werden. Zudem lassen sie sich leicht parallelisieren, was auf modernen Multi-Core-Systemen oder GPU-Clustern erhebliche Beschleunigungen des Optimierungsprozesses ermöglicht.

Nachteile sind die oft recht langsame Konvergenz, der möglicherweise hohe Rechenaufwand durch zahlreiche Funktionsauswertungen, und die schwierige theoretische Analyse. Die Ergebnisse sind nicht deterministisch, was unter Umständen die Reproduzierbarkeit erschwert. Zudem benötigen viele stochastische Verfahren problemspezifische Anpassungen und Tuning ihrer Hyperparameter (wie Temperaturpläne oder Mutationsraten), was spezifisches Expertenwissen erfordern kann. Im Vergleich zu Gradient-basierten Verfahren nutzen sie weniger Strukturinformationen des Problems, was bei gut strukturierten Problemen ineffizient sein kann.

7.4 Simulated Annealing¶

Nach diesen eher generellen Anmerkungen zur stochastischen Optimierung wenden wir uns jetzt konkreten leistungsfähigen Beispiel-Algorithmen zu.

7.4.1 Wie funktioniert Simulated Annealing?¶

Simulated Annealing (SA) ist ein naturinspiriertes Optimierungsverfahren, das den physikalischen Prozess des kontrollierten Abkühlens von Metallen nachahmt. Beim Tempern (Annealing) wird ein Metall erhitzt und langsam abgekühlt, wodurch die Atome zunächst energiereiche Zustände einnehmen können, um schließlich in einer energiearmen, stabilen Kristallstruktur (das enspricht einem optimierten Zustand des Materials) zu erstarren. Übertragen auf die Optimierung bedeutet dies: Bei hoher “Temperatur” akzeptiert der Algorithmus auch Verschlechterungen mit hoher Wahrscheinlichkeit (Exploration), während bei niedriger Temperatur hauptsächlich Verbesserungen akzeptiert werden (Exploitation). Um das besser zu verstehen, sehen wir uns die Sache im Detail an.

Der Algorithmus beginnt mit einer zufälligen Lösung und einer hohen Anfangstemperatur T. In jeder Iteration wird eine zufällige Nachbarlösung generiert und ihre Qualität (Energieniveau) mit der aktuellen Lösung verglichen. Verbesserungen werden immer akzeptiert. Verschlechterungen werden mit einer Wahrscheinlichkeit nach der folgenden Regel akzeptiert: $P(accept) = \exp(-\Delta E/T)$, wobei $\Delta E$ die Verschlechterung der Zielfunktion ist. Nach einer festgelegten Anzahl von Iterationen wird die Temperatur gemäß einem Abkühlungsplan reduziert, wodurch die Wahrscheinlichkeit für die Akzeptanz von Verschlechterungen sinkt.

Die Implementierung erfordert also vier Hauptkomponenten:

eine Methode zur Generierung von Nachbarlösungen
eine Zielfunktion zur Bewertung der Lösungen
einen Abkühlungsplan für die Temperatur und
ein Abbruchkriterium.

Die Definition der Nachbarschaft ist dabei problemspezifisch und teilweise recht knifflig. Für kontinuierliche Probleme nimmt man oft einfach eine kleine zufällige Änderung aller Variablen, für kombinatorische Probleme wie TSP typischerweise einfache Operationen wie das Vertauschen zweier Städte in der Route (siehe unten).

7.4.2 Temperaturplanung und ihre Auswirkungen auf die Konvergenz¶

Der Temperaturplan (cooling schedule) ist entscheidend für die Leistung von Simulated Annealing. Er bestimmt, wie schnell der Algorithmus von der explorativen Phase (hohe Temperatur) zur exploitativen Phase (niedrige Temperatur) übergeht. Die theoretische Analyse zeigt, dass eine logarithmische Abkühlung $(T(k) \sim 1/\log(k)$, wobei $k$ der Index für die Iteration ist) die Konvergenz zum globalen Optimum garantiert – allerdings mit unpraktisch langsamer Geschwindigkeit.

In der Praxis werden oft schnellere Abkühlungspläne verwendet, wie die geometrische Abkühlung $(T_{i+1} = \alpha T_i$, mit typischerweise $0.9 \le \alpha \lt 1)$, die lineare Abkühlung $(T_{i+1} = T_i – \beta)$, oder adaptivere Schemata, die die Temperatur basierend auf beobachteten Akzeptanzraten oder anderen Fortschrittsmetriken anpassen. Ein zu schneller Temperaturabfall kann zum Einfrieren in lokalen Optima führen, während ein zu langsamer Abfall unnötig Rechenzeit verschwendet.

Neben dem grundlegenden Abkühlungsplan spielen weitere Parameter eine wichtige Rolle: Die Anfangstemperatur sollte hoch genug sein, um anfänglich fast alle Verschlechterungen zu akzeptieren (typischerweise kalibriert, um eine initiale Akzeptanzrate von rund 80% zu erreichen). Die Anzahl der Iterationen pro Temperaturstufe sollte ausreichend sein, um einen quasistationären Zustand bei jeder Temperatur zu erreichen. Einige Implementierungen beinhalten auch Reheating-Strategien, die die Temperatur zeitweise wieder erhöhen, wenn der Algorithmus längere Zeit keine Verbesserungen findet – ähnliche Restart-Strategien findet man in anderen Optimierungsverfahren.

Sehen wir uns hier einmal ein einfaches Beispiel an (anhand der sogenannten Rastrigin-Funktion):

In [27]:

import numpy as np
import matplotlib.pyplot as plt
from mpl_toolkits.mplot3d import Axes3D

# Rastrigin-Funktion: eine bekannte Testfunktion mit vielen lokalen Minima
# f(x,y) = 20 + x^2 + y^2 - 10*cos(2π*x) - 10*cos(2π*y)
# Das globale Minimum ist bei (0,0) mit f(0,0) = 0
def rastrigin(x, y):
    return 20 + x**2 + y**2 - 10*np.cos(2*np.pi*x) - 10*np.cos(2*np.pi*y)

# Implementierung von Simulated Annealing mit verschiedenen Abkühlungsstrategien
def simulated_annealing(cooling_schedule, max_iter, suchbereich, init_temp):
    # Analytisches Optimum (zum Vergleich)
    optimum = np.array([0.0, 0.0])
    optimum_wert = rastrigin(optimum[0], optimum[1])
    
    # Startpunkt zufällig wählen
    aktuelle_lösung = np.random.uniform(suchbereich[0], suchbereich[1], size=2)
    aktueller_wert = rastrigin(aktuelle_lösung[0], aktuelle_lösung[1])
    
    # Beste gefundene Lösung speichern
    beste_lösung = aktuelle_lösung.copy()
    bester_wert = aktueller_wert
    
    # Historie für die Visualisierung
    historie_lösungen = [aktuelle_lösung.copy()]
    historie_werte = [aktueller_wert]
    historie_beste_werte = [bester_wert]
    historie_temperatur = [init_temp]
    
    # Initiale Temperatur
    temperatur = init_temp
    
    # Schleife über alle Iterationen
    for i in range(max_iter):
        # Aktualisiere die Temperatur je nach Abkühlungsstrategie
        if cooling_schedule == "logarithmisch":
            # Logarithmische Abkühlung: T(i) = T_0 / ln(i+2)
            temperatur = init_temp / np.log(i + 2)
        elif cooling_schedule == "geometrisch":
            # Geometrische Abkühlung: T(i) = T_0 * alpha^i
            alpha = 0.99  # Abkühlungsrate
            temperatur = init_temp * (alpha ** i)
        elif cooling_schedule == "linear":
            # Lineare Abkühlung: T(i) = T_0 * (1 - i/max_iter)
            temperatur = init_temp * (1 - i/max_iter)
        
        # Speichere die aktuelle Temperatur
        historie_temperatur.append(temperatur)
        
        # Erzeuge eine neue Nachbarlösung durch Gaußsche Mutation
        # Die Standardabweichung der Mutation hängt von der Temperatur ab
        sigma = 0.1 + temperatur * 0.5  # Größere Schritte bei höherer Temperatur
        nachbar = aktuelle_lösung + np.random.normal(0, sigma, size=2)
        
        # Beschränke die Nachbarlösung auf den Suchbereich
        nachbar = np.clip(nachbar, suchbereich[0], suchbereich[1])
        nachbar_wert = rastrigin(nachbar[0], nachbar[1])
        
        # Speichere den Nachbarn für die Visualisierung
        historie_lösungen.append(nachbar.copy())
        historie_werte.append(nachbar_wert)
        
        # Entscheide, ob der Nachbar akzeptiert wird
        if nachbar_wert < aktueller_wert:
            # Wenn der Nachbar besser ist, akzeptiere ihn immer
            aktuelle_lösung = nachbar.copy()
            aktueller_wert = nachbar_wert
            
            # Aktualisiere ggf. die beste gefundene Lösung
            if aktueller_wert < bester_wert:
                beste_lösung = aktuelle_lösung.copy()
                bester_wert = aktueller_wert
        else:
            # Wenn der Nachbar schlechter ist, akzeptiere ihn mit einer gewissen Wahrscheinlichkeit
            # Die Wahrscheinlichkeit hängt von der Verschlechterung und der Temperatur ab
            delta = nachbar_wert - aktueller_wert
            p = np.exp(-delta / temperatur)
            
            if np.random.random() < p:
                aktuelle_lösung = nachbar.copy()
                aktueller_wert = nachbar_wert
        
        # Speichere den besten Wert bis zur aktuellen Iteration
        historie_beste_werte.append(bester_wert)
    
    return beste_lösung, bester_wert, np.array(historie_lösungen), np.array(historie_werte), np.array(historie_beste_werte), np.array(historie_temperatur), optimum, optimum_wert

# Parameter
max_iter = 10000
suchbereich = [-5.12, 5.12]  # Typischer Suchbereich für die Rastrigin-Funktion
init_temp = 10.0  # Initiale Temperatur

# Liste der zu testenden Abkühlungsstrategien
cooling_schedules = ["logarithmisch", "geometrisch", "linear"]
farben = ["blue", "green", "red"]

# Visualisierung der Rastrigin-Funktion
x = np.linspace(suchbereich[0], suchbereich[1], 100)
y = np.linspace(suchbereich[0], suchbereich[1], 100)
X, Y = np.meshgrid(x, y)
Z = rastrigin(X, Y)

fig = plt.figure(figsize=(12, 9))
ax1 = fig.add_subplot(2, 2, 1, projection='3d')
surf = ax1.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8, linewidth=0, antialiased=True)
ax1.set_xlabel('x')
ax1.set_ylabel('y')
ax1.set_zlabel('f(x,y)')
ax1.set_title('Rastrigin-Funktion')

# Konturplot
ax2 = fig.add_subplot(2, 2, 2)
contour = ax2.contour(X, Y, Z, 20, cmap='viridis')
ax2.set_xlabel('x')
ax2.set_ylabel('y')
ax2.set_title('Höhenlinien der Rastrigin-Funktion')
fig.colorbar(contour, ax=ax2)

# Konvergenzplot für verschiedene Abkühlungsstrategien
ax3 = fig.add_subplot(2, 2, 3)

# Führe Simulated Annealing mit jeder Abkühlungsstrategie durch
for i, schedule in enumerate(cooling_schedules):
    # Setze zufälligen Seed für Reproduzierbarkeit
    np.random.seed(42 + i)
    
    # Führe Simulated Annealing durch
    beste_lösung, bester_wert, historie_lösungen, historie_werte, historie_beste_werte, historie_temperatur, optimum, optimum_wert = simulated_annealing(schedule, max_iter, suchbereich, init_temp)
    
    # Ergebnisse ausgeben
    print(f"\nAbkühlungsstrategie: {schedule}")
    print(f"Beste gefundene Lösung: x = {beste_lösung[0]:.4f}, y = {beste_lösung[1]:.4f}")
    print(f"Bester gefundener Wert: {bester_wert:.4f}")
    print(f"Analytisches Optimum: x = {optimum[0]:.4f}, y = {optimum[1]:.4f}")
    print(f"Optimaler Wert: {optimum_wert:.4f}")
    print(f"Abweichung vom Optimum: {abs(bester_wert - optimum_wert):.4f}")
    
    # Zeichne Konvergenzverlauf
    ax3.plot(historie_beste_werte, color=farben[i], linewidth=2, label=f'{schedule}')
    
    # Zeichne Endpunkt in den Konturplot
    ax2.scatter(beste_lösung[0], beste_lösung[1], color=farben[i], s=100, marker='*', label=f'{schedule}')

# Füge Referenzlinie für das Optimum hinzu
ax3.axhline(y=optimum_wert, color='black', linestyle='--', label='Globales Optimum')

ax3.set_xlabel('Iteration')
ax3.set_ylabel('Bester Funktionswert')
ax3.set_ylim(.02,100)
ax3.set_title('Konvergenzverhalten')
ax3.set_xscale('log')  # Logarithmische Skala für bessere Sichtbarkeit
ax3.set_yscale('log')  # Logarithmische Skala für bessere Sichtbarkeit
ax3.grid(True, alpha=0.3)
ax3.legend()

# Temperaturverlauf für verschiedene Abkühlungsstrategien
ax4 = fig.add_subplot(2, 2, 4)

# Setze Zufallsseed für Reproduzierbarkeit zurück
np.random.seed(42)

# Berechne Temperaturverläufe ohne tatsächliche Optimierung durchzuführen
temperatur = init_temp
temp_log = [temperatur]
temp_geo = [temperatur]
temp_lin = [temperatur]

for i in range(1, max_iter + 1):
    # Logarithmische Abkühlung
    temp_log.append(init_temp / np.log(i + 2))
    
    # Geometrische Abkühlung
    alpha = 0.99
    temp_geo.append(init_temp * (alpha ** i))
    
    # Lineare Abkühlung
    temp_lin.append(init_temp * (1 - i/max_iter))

# Zeichne Temperaturverläufe
ax4.plot(temp_log, color='blue', linewidth=2, label='Logarithmisch')
ax4.plot(temp_geo, color='green', linewidth=2, label='Geometrisch')
ax4.plot(temp_lin, color='red', linewidth=2, label='Linear')

ax4.set_xlabel('Iteration')
ax4.set_ylabel('Temperatur')
ax4.set_title('Temperaturverlauf')
ax4.set_xscale('log')  # Logarithmische Skala für bessere Sichtbarkeit
ax4.grid(True, alpha=0.3)
ax4.legend()

plt.tight_layout()
plt.show()

Abkühlungsstrategie: logarithmisch
Beste gefundene Lösung: x = 0.0175, y = -0.0043
Bester gefundener Wert: 0.0646
Analytisches Optimum: x = 0.0000, y = 0.0000
Optimaler Wert: 0.0000
Abweichung vom Optimum: 0.0646

Abkühlungsstrategie: geometrisch
Beste gefundene Lösung: x = -0.0009, y = -0.9948
Bester gefundener Wert: 0.9951
Analytisches Optimum: x = 0.0000, y = 0.0000
Optimaler Wert: 0.0000
Abweichung vom Optimum: 0.9951

Abkühlungsstrategie: linear
Beste gefundene Lösung: x = 0.0199, y = -0.0155
Bester gefundener Wert: 0.1260
Analytisches Optimum: x = 0.0000, y = 0.0000
Optimaler Wert: 0.0000
Abweichung vom Optimum: 0.1260

Hier sieht man deutlich die Unterschiede im Temperaturverlauf zwischen den verschiedenen Strategien und auch, wie sich das auf die Lösung des Problems auswirkt. Tatsächlich schneidet hier auch die logarithmische Strategie am besten ab, zumindest bei bis zu 10k Iterationen.

7.4.3 Anwendungsbereiche für Simulated Annealing, Vorteile und Nachteile¶

Simulated Annealing eignet sich besonders für kombinatorische Optimierungsprobleme wie das Traveling Salesman Problem, Facility Location, Job-Shop-Scheduling oder VLSI-Design (Chip-Layout). Es findet auch Anwendung in der Bildverarbeitung (z.B. Bildsegmentierung), der statistischen Physik (Simulation von Spingläsern) und beim Materialdesign. In den Biowissenschaften wird es für Proteinstrukturvorhersage und andere molekulare Optimierungsprobleme eingesetzt.

Zu den Vorteilen zählt die Fähigkeit, lokale Optima dank der probabilistischen Akzeptanzregel zu überwinden. SA ist relativ einfach zu implementieren und benötigt nur irgendeine Methode zur Generierung von Nachbarlösungen ohne dass man dazu z.B. den Gradienten der Zielfunktion kennen muss. Es ist daher vielseitig auf verschiedene Problemtypen anwendbar, einschließlich nicht-differenzierbarer und diskreter Probleme.

Typische Nachteile sind möglicherweise langsame Konvergenz, insbesondere bei komplexen Problemen mit vielen Variablen. Die Leistung hängt stark von der richtigen Wahl der Hyperparameter ab, insbesondere des Temperaturplans. Für hochdimensionale Probleme kann die effiziente Exploration des Suchraums schwierig werden. Dazu kommt noch der stochastische Character, der grundsätzlich die Reproduzierbarkeit erschwert.

7.5 Genetische Algorithmen¶

Als nächste stochastische Algorithmen wenden wir uns jetzt den sogenannten Genetischen Algorithmen zu.

7.5.1 Begriffe und Grundprinzipien: Population, Selektion, Rekombination, Mutation¶

Zunächst die Klärung einiger Begriffe und Konzepte:

Genetische Algorithmen (GA) sind evolutionäre Optimierungsverfahren, die Prinzipien der natürlichen Selektion nachahmen. Die Population besteht aus mehreren Lösungskandidaten (Individuen), die parallel evaluiert und weiterentwickelt werden. Jedes Individuum wird durch sein Genom repräsentiert – eine kodierte Form der Lösungsvariablen, traditionell als Binärstring, heute oft auch als reelle Zahlen, Permutationen oder komplexere Datenstrukturen je nach Problemstellung. Ein Beispiel für so ein Genom ist

$$(1,0,0,0,1,1,0,1,1,0,0,1)$$

Die entsprechende Population ist dann ganz einfach ein binäres Array, in dem die Zeilen den Genomen der Individuen entsprechen.

Der Evolutionsprozess verläuft iterativ über mehrere Generationen. In jeder Generation werden die Individuen anhand ihrer Fitness (Qualität bezüglich der Zielfunktion) bewertet. Durch Selektion werden bevorzugt fittere Individuen als “Eltern” für die nächste Generation ausgewählt. Die Rekombination (Crossover) kombiniert das genetische Material zweier Eltern, um neue Nachkommen zu erzeugen, während die Mutation zufällige kleine Änderungen im Genom einführt, um neue Variabilität zu schaffen. Um bereits erfolgreich getestete Individuen nicht aus der Population zu verlieren, kann man zusätzlich auch die besten Individuen unverändert in die nächste Generation übernehmen, sofern sie fitter als ihre Nachkommen sind.

Die Stärke genetischer Algorithmen liegt in ihrer Parallelität und dem Populationsansatz. Sie erkunden gleichzeitig verschiedene Regionen des Suchraums und kombinieren gefundene Teillösungen durch Rekombination. Dies ermöglicht die Identifikation und Kombination von “Building Blocks” – vorteilhaften Teilstrukturen im Genom. Bei einem konkreten Run muss man in der Regel entweder ein Konvergenzkriterium festlegen oder eine maximale Anzahl von Generationen definieren, damit der Algorithmus nicht ewig weiter läuft.

7.5.2 Selektionsmechanismen: Rouletterad, Turnierselektion, Rangbasierte Selektion¶

Für die Selektion der Eltern der nächsten Generation von Nachkommen aus den aktuellen Individuen der Population gibt es mehrere Möglichkeiten. Die meisten davon nehmen darauf Rücksicht, wie fit die einzelnen Individuen der Population sind. Die folgenden Beispiele sind ein paar der wichtigsten Möglichkeiten:

Die Rouletterad-Selektion (Fitness-proportionale Selektion) wählt Individuen mit einer Wahrscheinlichkeit proportional zu ihrer Fitness. Dies lässt sich als Drehen eines Rouletterads visualisieren, bei dem fittere Individuen größere Segmente erhalten. Diese Methode kann jedoch problematisch sein, wenn die Fitnessverteilung sehr ungleichmäßig ist: Bei zu großen Unterschieden dominieren wenige Superindividuen, während bei zu geringen Unterschieden die Selektion nahezu zufällig wird. Skalierungstechniken können diese Probleme mildern.

Die Turnierselektion wählt für jede Elternposition $k$ (z.B. 5) zufällige Individuen aus und nimmt das fitteste davon. Durch Variation der Turniergröße $k$ lässt sich der Selektionsdruck präzise einstellen: Größere Turniere führen zu stärkerem Selektionsdruck. Die Turnierselektion ist einfach zu implementieren, effizient zu berechnen (keine Sortierung der gesamten Population nötig) und robust gegenüber verschiedenen Fitnessverteilungen. Sie gehört zu den am häufigsten verwendeten Selektionsmethoden in modernen GA-Implementierungen.

Die Rangbasierte Selektion sortiert alle Individuen nach ihrer Fitness und weist ihnen Selektionswahrscheinlichkeiten basierend auf ihrem Rang zu, nicht auf dem absoluten Fitnesswert. Dies eliminiert das Problem extremer Fitnessunterschiede und sorgt für einen konstanteren Selektionsdruck über den Verlauf der Evolution. Verschiedene Funktionen zur Zuweisung von Wahrscheinlichkeiten basierend auf dem Rang sind möglich, von linearen bis zu exponentiellen Abhängigkeiten. Diese Methode ist allerdings rechenintensiver, da sie eine vollständige Sortierung der Population erfordert.

7.5.3 Crossover-Operatoren für verschiedene Problemtypen¶

Bevor wir uns ein konkretes Beispiel ansehen können, brauchen wir noch eine weitere Mechanik zusätzlich zur Selektion, nämlich die des Crossovers. Crossover-Operatoren variieren allerdings je nach Problemtyp und Genomrepräsentation. Das wird unmittelbar einsichtig, wenn man sich im Detail überlegt, was es eigentlich bedeutet, zwei Genome von zwei Individuen überhaupt mischen zu können, sodass wieder ein sinnvolles bzw. erlaubtes Genom für ein neues Individuum entsteht.

Für binäre oder reellwertige Genome ist der Ein-Punkt-Crossover am einfachsten: Das Genom wird an einer zufälligen Stelle geschnitten und die resultierenden Teilstücke zwischen den Eltern ausgetauscht. Der Zwei-Punkt-Crossover bzw. N-Punkt-Crossover erweitert dieses Konzept auf mehrere Schnittstellen. Der uniforme Crossover entscheidet für jedes Gen einzeln und unabhängig, von welchem Elternteil es übernommen wird, typischerweise mit einer 50:50-Wahrscheinlichkeit.

Für Situationen, bei denen Zusammenhänge nicht so klar sind, z.B. permutationsbasierte Probleme wie das Traveling Salesman Problem, sind spezielle Operatoren nötig, die die Gültigkeit des Genoms erhalten. Wenn es z.B. darum geht, aus einer Permutation einer Menge eine andere Permutation zu machen, muss man also darauf achten, die Permutationseigenschaft zu erhalten. Man kann sich leicht davon überzeugen, dass die einfache Schnittmethode von oben nicht funktioniert. Z.B. könnte aus den beiden Eltern $$(0, 1, 2, 3, 4, 5, 6, 7)\quad \mathrm{und}\quad (0, 7, 4, 3, 1, 6, 2, 5)$$ durch einen Schnitt an der Stelle 4 (in der Mitte) die neue Zahlenfolge $(0, 1, 2, 3, 1, 6, 2, 5)$ entstehen, die aber keine gültige Permuation ist, weil z.B. die Zahl 1 doppelt vorkommt. Hier muss man also etwas cleverer sein und die die Crossovers geeignet konstruieren.

Die Wahl des Crossover-Operators hat erheblichen Einfluss auf die Leistung des genetischen Algorithmus. Ein guter Operator sollte nach Möglichkeit wertvolle Eigenschaften beider Eltern bewahren, neue Bereiche des Suchraums erschließen und die geforderten Constraints einhalten, also nur gültige Lösungen erzeugen. In der Praxis werden daher problemspezifische Operatoren entwickelt, die Domänenwissen einbeziehen.

7.5.4 Beispiel: Das binäre Rucksackproblem, gelöst mit einem genetischen Algorithmus¶

Nun haben Sie sich ein Beispiel verdient. Wir betrachten das sogenannte “binäre Rucksackproblem”, wo es darum geht, in einem Rucksack mit einem maximalen Fassungsvermögen die ideale Kombination von verschieden wertvollen Dingen mitzunehmen oder nicht mitzunehmen, sodass der wertvollste Inhalt für den Rucksack gefunden wird, der das Limit des Fassungsvermögens (Gewichts) nicht übersteigt. Das ist ein kombinatorisches Optimierungsproblem, an dessen Grenzen man schnell stoßen kann.

Um einen Vergleich zu haben, lösen wir das Problem zunächst mit der Brute-Force-Methode, d.h. wir probieren einfach alle möglichen Lösungen durch und finden so heraus, welche die beste ist. Hier aber erst einmal die Definition der möglichen Inhalte des Rucksacks:

In [62]:

import numpy as np
import time

# Seed für Reproduzierbarkeit
np.random.seed(42)

# Anzahl der Gegenstände
n_items = 20

# Generiere zufällige Gewichte und Werte für die Gegenstände
# Gewichte zwischen, 1 und 10
weights = np.random.randint(1, 11, size=n_items)
# Werte zwischen, 1 und 100
values = np.random.randint(1, 101, size=n_items)

# Kapazität des Rucksacks (ca. 30% der Gesamtgewichte)
capacity = int(np.sum(weights) * 0.3)

# Zeige das Problem
print(f"Rucksackproblem mit {n_items} Gegenständen und Kapazität {capacity}:")
print("\nGegenstände (Index, Gewicht, Wert, Wert/Gewicht-Verhältnis):")
for i in range(n_items):
    print(f"{i:2d}: Gewicht = {weights[i]:2d}, Wert = {values[i]:3d}, Verhältnis = {values[i]/weights[i]:5.2f}")

print(f"\nGesamtgewicht aller Gegenstände: {np.sum(weights)}")
print(f"Gesamtwert aller Gegenstände: {np.sum(values)}")
print(f"Rucksackkapazität: {capacity}")

# Save the problem definition for later reference
problem_size = n_items
problem_capacity = capacity
problem_weights = weights.copy()
problem_values = values.copy()

Rucksackproblem mit 20 Gegenständen und Kapazität 34:

Gegenstände (Index, Gewicht, Wert, Wert/Gewicht-Verhältnis):
 0: Gewicht =  7, Wert =  64, Verhältnis =  9.14
 1: Gewicht =  4, Wert =  60, Verhältnis = 15.00
 2: Gewicht =  8, Wert =  21, Verhältnis =  2.62
 3: Gewicht =  5, Wert =  33, Verhältnis =  6.60
 4: Gewicht =  7, Wert =  76, Verhältnis = 10.86
 5: Gewicht = 10, Wert =  58, Verhältnis =  5.80
 6: Gewicht =  3, Wert =  22, Verhältnis =  7.33
 7: Gewicht =  7, Wert =  89, Verhältnis = 12.71
 8: Gewicht =  8, Wert =  49, Verhältnis =  6.12
 9: Gewicht =  5, Wert =  91, Verhältnis = 18.20
10: Gewicht =  4, Wert =  59, Verhältnis = 14.75
11: Gewicht =  8, Wert =  42, Verhältnis =  5.25
12: Gewicht =  8, Wert =  92, Verhältnis = 11.50
13: Gewicht =  3, Wert =  60, Verhältnis = 20.00
14: Gewicht =  6, Wert =  80, Verhältnis = 13.33
15: Gewicht =  5, Wert =  15, Verhältnis =  3.00
16: Gewicht =  2, Wert =  62, Verhältnis = 31.00
17: Gewicht =  8, Wert =  62, Verhältnis =  7.75
18: Gewicht =  6, Wert =  47, Verhältnis =  7.83
19: Gewicht =  2, Wert =  62, Verhältnis = 31.00

Gesamtgewicht aller Gegenstände: 116
Gesamtwert aller Gegenstände: 1144
Rucksackkapazität: 34

Nun machen wir uns an die Brute-Force-Lösung:

In [63]:

import numpy as np
import itertools
import time

# Brute-Force-Lösung für das Rucksackproblem
def brute_force_knapsack(weights, values, capacity):
    n = len(weights)
    max_value = 0
    best_combination = None
    
    # Starte die Zeitmessung
    start_time = time.time()
    
    # Evaluiere alle möglichen Kombinationen (2^n)
    total_combinations = 2**n
    evaluated = 0
    
    for i in range(1, total_combinations):
        # Binäre Repräsentation der aktuellen Kombination
        binary = bin(i)[2:].zfill(n)
        selection = [int(bit) for bit in binary]
        
        # Berechne Gesamtgewicht und -wert
        total_weight = sum(weights[j] for j in range(n) if selection[j] == 1)
        total_value = sum(values[j] for j in range(n) if selection[j] == 1)
        
        evaluated += 1
        
        # Prüfe, ob diese Kombination gültig ist und besser als die bisherige beste
        if total_weight <= capacity and total_value > max_value:
            max_value = total_value
            best_combination = selection
    
    # Ende der Zeitmessung
    end_time = time.time()
    execution_time = end_time - start_time
    
    # Zeige Details der optimalen Lösung
    if best_combination is not None:
        selected_items = [i for i in range(n) if best_combination[i] == 1]
        total_weight = sum(weights[i] for i in selected_items)
        
        print(f"Brute-Force-Lösung für {n} Gegenstände:")
        print(f"Ausgewählte Gegenstände: {selected_items}")
        print(f"Gewählte Gegenstände: {len(selected_items)} von {n}")
        print(f"Gesamtgewicht: {total_weight} von {capacity} ({total_weight/capacity*100:.1f}%)")
        print(f"Optimaler Wert: {max_value}")
        print(f"Ausgeführt in {execution_time:.6f} Sekunden")
        print(f"Evaluierte Kombinationen: {evaluated:,} von {total_combinations:,} ({evaluated/total_combinations*100:.2f}%)")
    else:
        print("Keine gültige Lösung gefunden!")
    
    return best_combination, max_value, execution_time

# Rufe die globalen Problemdefinitionen ab
weights = problem_weights
values = problem_values
capacity = problem_capacity
n_items = problem_size

# Nur ausführen, wenn die Anzahl der Gegenstände nicht zu groß ist
if n_items <= 25:  # Bei größerer Anzahl wird Brute-Force unpraktisch
    optimale_lösung, optimaler_wert, ausführungszeit_bf = brute_force_knapsack(weights, values, capacity)
else:
    print(f"ACHTUNG: Brute-Force für {n_items} Gegenstände ist zu rechenintensiv!")
    print(f"Das würde {2**n_items:,} Kombinationen erfordern.")
    print("Reduziere die Anzahl der Gegenstände auf <= 25 oder verwende nur den GA.")

Brute-Force-Lösung für 20 Gegenstände:
Ausgewählte Gegenstände: [1, 9, 10, 12, 13, 14, 16, 19]
Gewählte Gegenstände: 8 von 20
Gesamtgewicht: 34 von 34 (100.0%)
Optimaler Wert: 566
Ausgeführt in 7.001990 Sekunden
Evaluierte Kombinationen: 1,048,575 von 1,048,576 (100.00%)

Und nun zum Vergleich die Lösung per GA mit binärem Genom-Vektor:

In [65]:

import numpy as np
import matplotlib.pyplot as plt
import time

class GeneticAlgorithmKnapsack:
    def __init__(self, weights, values, capacity, population_size=100, generations=100, 
                 crossover_rate=0.8, mutation_rate=0.1, elitism=True, tournament_size=3):
        self.weights = weights
        self.values = values
        self.capacity = capacity
        self.population_size = population_size
        self.generations = generations
        self.crossover_rate = crossover_rate
        self.mutation_rate = mutation_rate
        self.elitism = elitism
        self.tournament_size = tournament_size
        
        self.item_count = len(weights)
        self.best_solution = None
        self.best_fitness = 0
        self.fitness_history = []
        
    def initialize_population(self):
        """Erstelle eine zufällige Startpopulation"""
        population = np.random.randint(0, 2, size=(self.population_size, self.item_count))
        return population
    
    def calculate_fitness(self, individual):
        """Berechne die Fitness eines Individuums (= Gesamtwert, wenn gültig)"""
        total_weight = np.sum(individual * self.weights)
        total_value = np.sum(individual * self.values)
        
        # Wenn das Gewicht die Kapazität überschreitet, setze Fitness auf 0
        if total_weight > self.capacity:
            return 0
        return total_value
    
    def evaluate_population(self, population):
        """Berechne die Fitness für die gesamte Population"""
        fitness_values = np.zeros(self.population_size)
        for i in range(self.population_size):
            fitness_values[i] = self.calculate_fitness(population[i])
        return fitness_values
    
    def tournament_selection(self, population, fitness_values):
        """Wähle ein Individuum durch Turnierselektion"""
        # Wähle zufällig tournament_size Individuen
        tournament_indices = np.random.choice(self.population_size, self.tournament_size, replace=False)
        tournament_fitness = fitness_values[tournament_indices]
        
        # Wähle das Individuum mit der höchsten Fitness
        winner_index = tournament_indices[np.argmax(tournament_fitness)]
        return population[winner_index].copy()
    
    def crossover(self, parent1, parent2):
        """Ein-Punkt-Crossover zwischen zwei Eltern"""
        if np.random.random() < self.crossover_rate:
            # Wähle zufälligen Crossover-Punkt
            crossover_point = np.random.randint(1, self.item_count)
            
            # Erzeuge Kinder durch Austausch der Gene ab dem Crossover-Punkt
            child1 = np.concatenate([parent1[:crossover_point], parent2[crossover_point:]])
            child2 = np.concatenate([parent2[:crossover_point], parent1[crossover_point:]])
            
            return child1, child2
        else:
            # Keine Kreuzung, gib Eltern unverändert zurück
            return parent1.copy(), parent2.copy()
    
    def mutate(self, individual):
        """Bit-Flip-Mutation für ein Individuum"""
        for i in range(self.item_count):
            if np.random.random() < self.mutation_rate:
                individual[i] = 1 - individual[i]  # Flip 0->1 oder 1->0
        return individual
    
    def evolve(self, verbose=True):
        """Führe den genetischen Algorithmus aus"""
        start_time = time.time()
        
        # Initialisiere Population
        population = self.initialize_population()
        
        # Evaluiere initiale Population
        fitness_values = self.evaluate_population(population)
        
        # Finde das beste Individuum
        best_idx = np.argmax(fitness_values)
        self.best_solution = population[best_idx].copy()
        self.best_fitness = fitness_values[best_idx]
        
        # Sammle Fitness-Historie für die Visualisierung
        self.fitness_history = [self.best_fitness]
        
        # Evolutionsschleife
        for generation in range(self.generations):
            # Erzeuge neue Population
            new_population = np.zeros((self.population_size, self.item_count), dtype=int)
            
            # Elitismus: Bewahre das beste Individuum
            elite_offset = 0
            if self.elitism:
                new_population[0] = self.best_solution
                elite_offset = 1
            
            # Fülle die neue Population
            for i in range(elite_offset, self.population_size, 2):
                # Selektion
                parent1 = self.tournament_selection(population, fitness_values)
                parent2 = self.tournament_selection(population, fitness_values)
                
                # Crossover
                if i + 1 < self.population_size:
                    child1, child2 = self.crossover(parent1, parent2)
                    
                    # Mutation
                    child1 = self.mutate(child1)
                    child2 = self.mutate(child2)
                    
                    new_population[i] = child1
                    new_population[i+1] = child2
                else:
                    # Wenn ungerade Populationsgröße, füge nur ein Kind hinzu
                    child1 = self.mutate(parent1)
                    new_population[i] = child1
            
            # Ersetze alte Population
            population = new_population
            
            # Evaluiere neue Population
            fitness_values = self.evaluate_population(population)
            
            # Aktualisiere beste Lösung
            current_best_idx = np.argmax(fitness_values)
            current_best_fitness = fitness_values[current_best_idx]
            
            if current_best_fitness > self.best_fitness:
                self.best_solution = population[current_best_idx].copy()
                self.best_fitness = current_best_fitness
            
            # Füge zur Historie hinzu
            self.fitness_history.append(self.best_fitness)
            
            # Ausgabe des Fortschritts (optional)
            if verbose and (generation + 1) % 10 == 0:
                print(f"Generation {generation + 1}/{self.generations}, Beste Fitness: {self.best_fitness}")
        
        end_time = time.time()
        execution_time = end_time - start_time
        
        # Ergebnisse ausgeben
        if verbose:
            selected_items = [i for i in range(self.item_count) if self.best_solution[i] == 1]
            total_weight = sum(self.weights[i] for i in selected_items)
            
            print(f"\nGA-Lösung für {self.item_count} Gegenstände:")
            print(f"Ausgewählte Gegenstände: {selected_items}")
            print(f"Gewählte Gegenstände: {len(selected_items)} von {self.item_count}")
            print(f"Gesamtgewicht: {total_weight} von {self.capacity} ({total_weight/self.capacity*100:.1f}%)")
            print(f"Bester gefundener Wert: {self.best_fitness}")
            print(f"Ausgeführt in {execution_time:.6f} Sekunden")
        
        return self.best_solution, self.best_fitness, execution_time
    
    def plot_progress(self):
        """Visualisiere den Fortschritt des GA über die Generationen"""
        plt.figure(figsize=(10, 6))
        plt.plot(range(len(self.fitness_history)), self.fitness_history, 'b-')
        plt.title('Fortschritt des Genetischen Algorithmus')
        plt.xlabel('Generation')
        plt.ylabel('Beste Fitness (Wert)')
        plt.grid(True, alpha=0.3)
        
        # Zeichne Endwert als roten Punkt
        plt.plot(len(self.fitness_history)-1, self.fitness_history[-1], 'ro', markersize=8)
        plt.annotate(f'Finaler Wert: {self.fitness_history[-1]}', 
                    xy=(len(self.fitness_history)-1, self.fitness_history[-1]),
                    xytext=(10, -20), textcoords='offset points',
                    bbox=dict(boxstyle='round,pad=0.5', fc='yellow', alpha=0.5))
        
        plt.tight_layout()
        plt.show()

# Rufe die globalen Problemdefinitionen ab
weights = problem_weights
values = problem_values
capacity = problem_capacity
n_items = problem_size

# Parameter für den GA
population_size = 100
generations = 100
crossover_rate = 0.8
mutation_rate = 0.1
elitism = True
tournament_size = 3

# Führe den GA aus
print(f"Löse das Rucksackproblem mit {n_items} Gegenständen durch einen Genetischen Algorithmus...")
ga = GeneticAlgorithmKnapsack(
    weights, values, capacity,
    population_size=population_size,
    generations=generations,
    crossover_rate=crossover_rate,
    mutation_rate=mutation_rate,
    elitism=elitism,
    tournament_size=tournament_size
)

beste_lösung, bester_wert, ausführungszeit = ga.evolve(verbose=True)

# Visualisiere den Fortschritt
ga.plot_progress()

# Vergleiche mit Brute-Force, falls verfügbar
if n_items <= 25 and 'optimaler_wert' in globals():
    print("\nVergleich mit Brute-Force:")
    print(f"Brute-Force-Wert: {optimaler_wert}")
    print(f"GA-Wert: {bester_wert}")
    print(f"Unterschied: {abs(optimaler_wert - bester_wert)} ({abs(optimaler_wert - bester_wert)/optimaler_wert*100:.2f}%)")
    print(f"Brute-Force-Zeit: {ausführungszeit_bf:.6f} Sekunden")
    print(f"GA-Zeit: {ausführungszeit:.6f} Sekunden")
    print(f"Zeitverhältnis (Brute-Force/GA): {ausführungszeit_bf/ausführungszeit:.2f}")

Löse das Rucksackproblem mit 20 Gegenständen durch einen Genetischen Algorithmus...
Generation 10/100, Beste Fitness: 506.0
Generation 20/100, Beste Fitness: 559.0
Generation 30/100, Beste Fitness: 559.0
Generation 40/100, Beste Fitness: 559.0
Generation 50/100, Beste Fitness: 566.0
Generation 60/100, Beste Fitness: 566.0
Generation 70/100, Beste Fitness: 566.0
Generation 80/100, Beste Fitness: 566.0
Generation 90/100, Beste Fitness: 566.0
Generation 100/100, Beste Fitness: 566.0

GA-Lösung für 20 Gegenstände:
Ausgewählte Gegenstände: [1, 9, 10, 12, 13, 14, 16, 19]
Gewählte Gegenstände: 8 von 20
Gesamtgewicht: 34 von 34 (100.0%)
Bester gefundener Wert: 566.0
Ausgeführt in 0.323067 Sekunden

Vergleich mit Brute-Force:
Brute-Force-Wert: 566
GA-Wert: 566.0
Unterschied: 0.0 (0.00%)
Brute-Force-Zeit: 7.001990 Sekunden
GA-Zeit: 0.323067 Sekunden
Zeitverhältnis (Brute-Force/GA): 21.67

Insbesondere bei der verbrauchten Zeit wird die Effizienz des GA deutlich. Noch wichtiger ist aber, dass dieser Algorithmus auch dann noch schnell und gut funktioniert, wenn wir 42 mögliche Gegenstände haben, wofür unsere Brute-Force-Lösung $2^{42}$ Möglichkeiten durchgehen müsste, was laut unserer Zeitmessung etwa ein Jahr dauern würde.

7.5.5 Vorteile und Nachteile genetischer Algorithmen gegenüber traditioneller Optimierung¶

Genetische Algorithmen bieten mehrere Vorteile gegenüber klassischen Optimierungsverfahren. Sie sind äußerst robust gegenüber lokalen Optima und zwar sowohl durch ihre populationsbasierte Natur als auch die verwendeten stochastischen Operatoren von Mutation und Crossover. GA können wieder ohne Kenntnis des Gradienten arbeiten, was sie für nicht-differenzierbare, diskrete oder Black-Box-Funktionen geeignet macht. Bereits durch ihre inhärente Parallelität über die Population erkunden sie gleichzeitig verschiedene Regionen des Suchraums. Sie sind vielseitig einsetzbar für unterschiedlichste Problemtypen, von kombinatorischen über kontinuierliche bis zu gemischten Problemen, und lassen sich einfach an Probleme mit mehreren Zielfunktionen anpassen.

Ein weiterer Vorteil ist die einfache Anpassbarkeit an verschiedene Problemrepräsentationen. Ob Binärstrings, reelle Zahlen, Permutationen oder komplexe Datenstrukturen – es lassen sich dazu jeweils passende genetische Operatoren definieren. GA können auch mit verrauschten Zielfunktionen gut umgehen, da sie auf der Basis relativer Fitness und nicht absoluter Werte arbeiten. Bei sehr komplexen Problemen liefern sie oft akzeptable Lösungen in angemessener Zeit, auch wenn keine optimale Lösung garantiert werden kann. Mit “akzeptabel” ist dabei gemeint, dass die gefundene beste Lösung nahe genug (für den praktischen Zweck) an der tatsächlich optimalen Lösung liegt.

Nachteile sind die möglicherweise langsame Konvergenz und der dadurch entstehende hohe Rechenaufwand durch die Evaluierung vieler Individuen über viele Generationen. GA bieten außerdem keine Optimalitätsgarantien – sie finden typischerweise gute, aber nicht notwendigerweise optimale Lösungen. Die Leistung ist stark von der richtigen Parametereinstellung abhängig (Populationsgröße, Mutations- und Crossover-Raten), die oft empirisch ermittelt werden muss. Auch die Wahl einer geeigneten Genomkodierung ist entscheidend und erfordert Domänenwissen bzw. kann eine beträchtliche Herausforderung darstellen.

Ein weiteres Problem ist der Genetic Drift – der Verlust genetischer Vielfalt durch zufällige Fixierung bestimmter Genomteile, was zu vorzeitiger Konvergenz führen kann. Bei komplexen Constraints kann die Erzeugung gültiger Lösungen schwierig sein, was Reparaturmechanismen oder spezielle Constraint-Handling-Techniken erfordert. Im Vergleich zu spezialisierten Algorithmen (z.B. für lineare Probleme) sind GA für einfachere, gut strukturierte Probleme oft übermäßig komplex und ineffizient.

7.6 Übungsaufgabe: Lösen eines Traveling Salesman Problems mit einem genetischen Algorithmus¶

In dieser Übungsaufgabe werden wir uns mit dem klassischen Traveling Salesman Problem (TSP) befassen, einem der bekanntesten kombinatorischen Optimierungsprobleme. Ein Handelsreisender muss eine Reihe von Städten besuchen und zu seinem Ausgangspunkt zurückkehren, wobei jede Stadt genau einmal besucht werden soll. Die Herausforderung besteht darin, die kürzestmögliche Route zu finden. Dieses Problem eignet sich hervorragend, um die Stärken genetischer Algorithmen zu demonstrieren, da es für größere Anzahlen von Städten mit rein analytischen Methoden nicht effizient lösbar ist.

Im der folgenden Code-Zelle habe ich für Sie eine Instanz mit fantasievollen Namen und Städtekoordinaten generiert und visualisiert. Sie sollen nun in Zusammenarbeit mit dem LLM Ihrer Wahl einen genetischen Algorithmus mit geeigneter Genomrepräsentation (typischerweise eine Permutation der Städteindizes), passenden Crossover-Operatoren (wie z.B. Order Crossover oder Partially Mapped Crossover – diskutieren Sie diese Möglichkeiten mit dem LLM) und Mutationsoperatoren (wie Swap Mutation oder Inversion Mutation) implementieren. Die Fitnessfunktion entspricht dabei der inversen Gesamtlänge der Route – kürzere Routen erhalten höhere Fitnesswerte. Die Distanzen zwischen allen Städte-Paaren können (und sollten) Sie vorab in einer sogenannten “Distanzmatrix” einmal berechnen, damit Sie das nicht jedes Mal aufs Neue tun müssen.

Hier zunächst einmal die Daten, danach finden Sie eine Liste der nächsten Schritte.

In [50]:

import numpy as np
import matplotlib.pyplot as plt
from math import factorial

# Seed für Reproduzierbarkeit
np.random.seed(42)

# Anzahl der Städte
n_cities = 15

# Erstelle Fantasienamen für die Städte
city_names = [
    "Bergheim", "Talblick", "Waldkirchen", "Seehausen", "Flussbach",
    "Sonnental", "Mondberg", "Sternfeld", "Nebeldorf", "Windhaven",
    "Regenbogen", "Donnerfels", "Blitzhügel", "Schneegipfel", "Feuertal"
]

# Koordinaten der Städte generieren (in einem Bereich von 0 bis 100)
x_coords = np.random.uniform(0, 100, n_cities)
y_coords = np.random.uniform(0, 100, n_cities)

# Erstelle eine Liste von Stadt-Dictionaries mit Namen und Koordinaten
cities = []
for i in range(n_cities):
    cities.append({
        "name": city_names[i],
        "x": x_coords[i],
        "y": y_coords[i]
    })

# Zeige die Städte und ihre Koordinaten an
print(f"TSP-Problem mit {n_cities} Städten:")
print("\nStädte und ihre Koordinaten:")
for i, city in enumerate(cities):
    print(f"{i}: {city['name']} ({city['x']:.2f}, {city['y']:.2f})")

# Erstelle eine Karte der Städte
plt.figure(figsize=(10, 8))
plt.scatter(x_coords, y_coords, c='darkblue', s=100, zorder=5)

# Beschrifte die Städte
for i, city in enumerate(cities):
    plt.annotate(
        city['name'],
        (city['x'], city['y']),
        xytext=(5, 5),
        textcoords='offset points',
        fontsize=9,
        bbox=dict(boxstyle="round,pad=0.3", fc="white", ec="gray", alpha=0.8)
    )

plt.title('Fantasiekarte für das TSP-Problem')
plt.xlabel('x-Koordinate')
plt.ylabel('y-Koordinate')
plt.grid(alpha=0.3)
plt.xlim(-5, 105)
plt.ylim(-5, 105)
plt.tight_layout()
plt.show()

# Information über das Problem und die optimale Lösung
print(f"Die Gesamtzahl möglicher Routen beträgt (n-1)!/2 = {factorial(n_cities-1)/2:.2e}")

# Speichern der Daten für spätere Verwendung
tsp_n_cities = n_cities
tsp_city_names = city_names
tsp_x_coords = x_coords
tsp_y_coords = y_coords

TSP-Problem mit 15 Städten:

Städte und ihre Koordinaten:
0: Bergheim (37.45, 18.34)
1: Talblick (95.07, 30.42)
2: Waldkirchen (73.20, 52.48)
3: Seehausen (59.87, 43.19)
4: Flussbach (15.60, 29.12)
5: Sonnental (15.60, 61.19)
6: Mondberg (5.81, 13.95)
7: Sternfeld (86.62, 29.21)
8: Nebeldorf (60.11, 36.64)
9: Windhaven (70.81, 45.61)
10: Regenbogen (2.06, 78.52)
11: Donnerfels (96.99, 19.97)
12: Blitzhügel (83.24, 51.42)
13: Schneegipfel (21.23, 59.24)
14: Feuertal (18.18, 4.65)

Die Gesamtzahl möglicher Routen beträgt (n-1)!/2 = 4.36e+10

Nächste Schritte:

Implementieren Sie das Grundgerüst Ihres Genetischen Algorithmus für dieses Problem, basierend auf Permutationen als Genomrepräsentation.
Lassen Sie den Algorithmus einige Male laufen, um ein Gefühl für die Konvergenz in Abhängigkeit von der Anzahl der Generationen, der Größe der Population, sowie der Mutations- und Crossover-Rate zu bekommen.
Schärfen Sie Ihre Intuition durch Visualisierungen
Wenn alles läuft, erhöhen Sie die Anzahl der Städte und versuchen Sie noch einmal, eine gute und möglichst verlässliche Lösung zu erhalten.

In [ ]:

FMCA-25 06: Graphalgorithmen: Darstellungen, Traversierungen, Kürzeste Wege und Spannbäume

Inhalt des Skriptums seit dem Sommersemester 2025

Hier finden Sie die Kapitel aus den Vergangenen Jahren (legacy):

Die Jupyter-Notebooks zur Legacy-Variante der Lehrveranstaltung finden Sie im zugehörigen GitHub-Repository.

6 Graphalgorithmen: Darstellungen, Traversierungen, Kürzeste Wege und Spannbäume¶

Der Einsatz von Graphen in unserer modernen Welt ist in vielen Bereichen gegenwärtig. Besonders nützlich sind sie bei der mathematischen Formulierungen von Zusammenhängen in Gruppen von Individuen. Das können zwar auch Menschen sein, aber Graphen lassen sich viel allgemeiner und vor allem abstrakter anwenden. Daher ist ihnen diese Einheit gewidmet. Code-Beispiele kommen wie gewohnt von Claude 3.7 Sonnet.

Nach dem Studium dieser Einheit sollten Sie zumindest folgende drei der wichtigsten Punkte hier verstehen:¶

Was Graphen sind und welche Eigenschaften sie characterisieren.
Wie Algorithmen aufgebaut sind, die Graphen beschreiben und analysieren können.
Welcherart Probleme man überhaupt lösen muss, wenn man sich mit Graphen beschäftigt, bzw. Graphen in Wissenschaft und Forschung einsetzt.

6.1 Ultra-Kurzer Crash-Kurs zum Thema Graphen(theorie)¶

In diesem Abschnitt werden wir zunächst die grundlegenden Konzepte der Graphentheorie kennenlernen. Graphen sind eine der mächtigsten und vielseitigsten Datenstrukturen in der Informatik und Mathematik. Sie eignen sich hervorragend zur Modellierung von Beziehungen zwischen Objekten und finden Anwendung in zahlreichen Bereichen wie sozialen Netzwerken, Verkehrsplanung, Molekularbiologie, Computernetzwerken und vielen weiteren Gebieten.

6.1.1 Grundlegende Begriffe und Definitionen, Arten von Graphen¶

Ein Graph $G = (V, E)$ besteht aus einer Menge von Knoten (oder Vertices) $V$ und einer Menge von Kanten (oder Edges) $E$, die Verbindungen zwischen diesen bzw. mancher dieser Knoten darstellen.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/5/5b/6n-graf.svg

Je nach Art der Kanten und weiteren Eigenschaften unterscheiden wir verschiedene Arten von Graphen:

Gerichtete vs. ungerichtete Graphen:
- In ungerichteten Graphen haben Kanten keine Richtung; eine Kante $(u,v)$ ist identisch mit $(v,u)$.
- In gerichteten Graphen (auch Digraphen genannt) haben Kanten eine bestimmte Richtung; eine Kante $(u,v)$ bedeutet eine Verbindung von $u$ nach $v$, aber nicht notwendigerweise umgekehrt.

Bildquellen: https://upload.wikimedia.org/wikipedia/commons/thumb/a/a2/Directed.svg/240px-Directed.svg.png, https://upload.wikimedia.org/wikipedia/commons/thumb/b/bf/Undirected.svg/240px-Undirected.svg.png

Gewichtete vs. ungewichtete Graphen:
- In ungewichteten Graphen haben alle Kanten den gleichen Wert oder die gleiche Wichtigkeit.
- In gewichteten Graphen wird jeder Kante ein Wert (Gewicht) zugeordnet, der Kosten, Distanz, Kapazität oder eine andere Metrik darstellen kann.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/thumb/5/58/Weighted_Graph.svg/320px-Weighted_Graph.svg.png

Zyklische vs. azyklische Graphen:
- Ein zyklischer Graph enthält mindestens einen Zyklus, d.h. einen Pfad, der bei einem Knoten beginnt und beim selben Knoten endet.
- Ein azyklischer Graph enthält keine Zyklen. Ein gerichteter azyklischer Graph (DAG) wird oft zur Darstellung von Abhängigkeiten verwendet.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/0/03/Directed_acyclic_graph_2.svg

Zusammenhängende vs. nicht zusammenhängende Graphen:
- Ein zusammenhängender Graph ist ein Graph, in dem von jedem Knoten ein Pfad zu jedem anderen Knoten existiert.
- Ein nicht zusammenhängender Graph besteht aus mehreren Komponenten ohne Verbindung untereinander.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/thumb/0/0f/Disconnected_undirected_graph_2.svg/320px-Disconnected_undirected_graph_2.svg.png

Bipartite Graphen:
- Ein bipartiter Graph ist ein Graph, dessen Knoten in zwei disjunkte Mengen aufgeteilt werden können, sodass jede Kante einen Knoten aus der ersten Menge mit einem Knoten aus der zweiten Menge verbindet.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/thumb/e/e8/Simple-bipartite-graph.svg/320px-Simple-bipartite-graph.svg.png

Planare Graphen:
- Ein planarer Graph kann in der Ebene gezeichnet werden, ohne dass sich Kanten kreuzen.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/thumb/8/83/Gem_graph.svg/320px-Gem_graph.svg.png

6.1.2 Grundlegende Grapheigenschaften und -operationen¶

Grad eines Knotens:

Der Grad eines Knotens in einem ungerichteten Graphen ist die Anzahl der mit ihm verbundenen Kanten.
In einem gerichteten Graphen unterscheiden wir zwischen Eingangsgrad (Anzahl der eingehenden Kanten) und Ausgangsgrad (Anzahl der ausgehenden Kanten).

In unserem Beispiel von oben hat z.B. Knoten 1 den Grad 2, Knoten 2 den Grad 3, Knoten 3 den Grad 2, usw.

Pfade und Zyklen:

Ein Pfad ist eine Folge von Knoten, wobei aufeinanderfolgende Knoten durch Kanten verbunden sind.
Ein einfacher Pfad enthält keine wiederholten Knoten.
Ein Zyklus ist ein Pfad, der an seinem Ausgangspunkt endet.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/thumb/9/91/5n_PERT_graph_with_critical_path.svg/320px-5n_PERT_graph_with_critical_path.svg.png

Zusammenhang:

Eine Zusammenhangskomponente ist ein maximaler zusammenhängender Teilgraph.
Ein stark zusammenhängender gerichteter Graph ist ein Graph, in dem von jedem Knoten ein gerichteter Pfad zu jedem anderen Knoten existiert.

Operationen auf Graphen:

Einfügen eines Knotens: Hinzufügen eines neuen Knotens zum Graphen.
Entfernen eines Knotens: Entfernen eines Knotens und aller mit ihm verbundenen Kanten.
Einfügen einer Kante: Hinzufügen einer neuen Verbindung zwischen zwei Knoten.
Entfernen einer Kante: Entfernen einer bestehenden Verbindung zwischen zwei Knoten.

6.1.3 Außer Konkurrenz: Die Euler’sche Formel für planare Graphen in verschiedenen Topologien¶

Die Euler’sche Formel ist eine der schönsten und grundlegendsten Beziehungen in der Graphentheorie. Für einen zusammenhängenden planaren Graphen mit $V$ Knoten, $E$ Kanten und $F$ Flächen (einschließlich der äußeren Fläche) gilt:

$$V – E + F = 2$$

Diese Formel lässt sich auf verschiedene topologische Oberflächen verallgemeinern. Für eine Oberfläche vom Geschlecht $g$ (d.h. mit $g$ “Löchern”) gilt:

$$V – E + F = 2 – 2g$$

Zum Beispiel:

Für die Ebene (Geschlecht 0): $V – E + F = 2$
Für einen Torus (Geschlecht 1): $V – E + F = 0$

Die Formel hat tiefgreifende Konsequenzen, wie z.B. die Tatsache, dass es nur fünf regelmäßige Polyeder (platonische Körper) gibt (das kann man sich über die Eigeschaft der Regelmäßigkeit und der Anzahl der Flächen des Polyeders überlegen). Sie bildet auch die Grundlage für viele Sätze in der Graphentheorie, wie etwa, dass jeder planare Graph mit $n \geq 3$ Knoten höchstens $3n – 6$ Kanten haben kann.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/thumb/7/77/Platonic_Solids_Transparent.svg/320px-Platonic_Solids_Transparent.svg.png

6.2 Implementation von Graphen in Python¶

In diesem Abschnitt werden wir uns damit beschäftigen, wie Graphen in Python implementiert werden können. Die richtige Datenstruktur ist entscheidend für die Effizienz der Algorithmen, die wir später auf den Graphen anwenden möchten.

6.2.1 Darstellung von Graphen in Computercode¶

Es gibt verschiedene Möglichkeiten, Graphen in Computercode zu repräsentieren. Jede hat ihre Vor- und Nachteile in Bezug auf Speicherplatz und Zugriffszeit.

Adjazenzmatrix¶

Eine Adjazenzmatrix ist eine $n \times n$-Matrix (wobei $n$ die Anzahl der Knoten ist), in der der Eintrag an Position $(i,j)$ angibt, ob eine Kante zwischen den Knoten $i$ und $j$ existiert. Bei gerichteten Graphen steht der Eintrag nur an der Stelle, welche die korrekte Richtung angibt, also z.B. von Knoten $i$ nach $j$, aber nicht von $j$ nach $i$. Dadurch ist die Adjazenzmatrix für einen gerichteten Graphen nicht symmetrisch. Die Einträge sind:

Bei ungewichteten Graphen: 1 für vorhandene Kante, 0 sonst
Bei gewichteten Graphen: Gewicht für vorhandene Kante, 0 oder ∞ sonst

Hier ein Beispiel für eine Adjazenzmatrix eines ungewichteten ungerichteten Graphen:

   A B C D
A [0 1 1 0]
B [1 0 1 1]
C [1 1 0 0]
D [0 1 0 0]

Vorteile:

Schneller Zugriff (O(1)) zum Prüfen, ob eine Kante existiert
Einfach zu implementieren
Gut für dichte Graphen (viele Kanten)

Nachteile:

Speicheraufwand von O(n²), ineffizient für große, dünn besetzte Graphen
Aufwendiges Auflisten aller Nachbarn eines Knotens (O(n))

Adjazenzliste¶

Eine Adjazenzliste speichert für jeden Knoten eine Liste seiner Nachbarn. Hier ein einfaches Beispiel:

A -> [B, C]
B -> [A, C, D]
C -> [A, B]
D -> [B]

Vorteile:

Speichereffizient für dünn besetzte Graphen (O(|V|+|E|))
Schnelles (de facto unmittelbares) Auflisten der Nachbarn eines Knotens
Gut für Traversierungsalgorithmen (siehe etwas weiter unten)

Nachteile:

Langsamer beim Prüfen, ob eine bestimmte Kante existiert (O(d), wobei d der Grad des Knotens ist)
Komplexere Implementierung als bei der Adjazenzmatrix

Inzidenzmatrix¶

Eine Inzidenzmatrix ist eine $n \times m$-Matrix (wobei $n$ die Anzahl der Knoten und $m$ die Anzahl der Kanten ist), in der der Eintrag an Position $(i,j)$ angibt, ob der Knoten $i$ mit der Kante $j$ verbunden ist.

Bei ungerichteten Graphen: 1 wenn verbunden, 0 sonst
Bei gerichteten Graphen: -1 für ausgehende Kante, 1 für eingehende Kante, 0 sonst

Hier wieder ein einfaches Beispiel für einen ungerichteten Graphen:

    E1 E2 E3
V1 [0  1  0]
V2 [1  1  1]
V3 [0  0  1]
V4 [1  0  0]

Vorteile:

Gut für Analysen auf Kanten-Ebene
Besonders nützlich bei Mehrgraphen (mehrere Kanten zwischen denselben Knoten)

Nachteile:

Sehr speicherintensiv für große Graphen
Ineffizient für die meisten Graphoperationen

Implementierung in Python (Grundlegende Datenstrukturen)¶

Hier ein einfaches Beispiel für die Implementierung eines ungerichteten, ungewichteten Graphen als Adjazenzliste in Python:

# Einfache Implementierung einer Adjazenzliste
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'C', 'D'],
    'C': ['A', 'B'],
    'D': ['B']
}

# Funktion zum Hinzufügen eines Knotens
def add_node(graph, node):
    if node not in graph:
        graph[node] = []

# Funktion zum Hinzufügen einer Kante (ungerichtet)
def add_edge(graph, node1, node2):
    if node1 in graph and node2 in graph:
        if node2 not in graph[node1]:
            graph[node1].append(node2)
        if node1 not in graph[node2]:
            graph[node2].append(node1)

Und hier eine Implementierung als Adjazenzmatrix:

In [1]:

import numpy as np

# Einfache Implementierung einer Adjazenzmatrix
nodes = ['A', 'B', 'C', 'D']
n = len(nodes)
# Erstellen einer n x n Matrix mit Nullen
matrix = np.zeros((n, n), dtype=int)

# Indizierung der Knoten
node_indices = {nodes[i]: i for i in range(n)}

# Hinzufügen von Kanten
def add_edge_matrix(matrix, node1, node2, node_indices):
    i = node_indices[node1]
    j = node_indices[node2]
    matrix[i][j] = 1
    matrix[j][i] = 1  # Für ungerichtete Graphen

# Beispielkanten hinzufügen
add_edge_matrix(matrix, 'A', 'B', node_indices)
add_edge_matrix(matrix, 'A', 'C', node_indices)
add_edge_matrix(matrix, 'B', 'C', node_indices)
add_edge_matrix(matrix, 'B', 'D', node_indices)

print("Adjazenzmatrix:")
print(matrix)

Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.
Intel MKL WARNING: Support of Intel(R) Streaming SIMD Extensions 4.2 (Intel(R) SSE4.2) enabled only processors has been deprecated. Intel oneAPI Math Kernel Library 2025.0 will require Intel(R) Advanced Vector Extensions (Intel(R) AVX) instructions.
Adjazenzmatrix:
[[0 1 1 0]
 [1 0 1 1]
 [1 1 0 0]
 [0 1 0 0]]

6.2.2 Visualisierung von Graphen: Furball vs. Hiveplot¶

Die Visualisierung von Graphen ist ein wichtiges Werkzeug, um Strukturen und Muster zu erkennen. Es gibt verschiedene Ansätze, von denen einige für bestimmte Arten von Daten besser geeignet sind als andere.

“Furball”-Visualisierungen¶

Die traditionelle “Furball” (Haarball)-Visualisierung versucht, Knoten und Kanten in einer ästhetisch ansprechenden Weise darzustellen, oft mit Hilfe von kräftebasierten Algorithmen, die Knoten wie physikalische Teilchen behandeln.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/thumb/9/90/Visualization_of_wiki_structure_using_prefuse_visualization_package.png/640px-Visualization_of_wiki_structure_using_prefuse_visualization_package.png

Vorteile:

Intuitiv zu interpretieren
Kann visuelle Muster offenbaren
Gut für kleinere Graphen

Nachteile:

Wird schnell unübersichtlich bei großen oder dichten Graphen
Layout-Algorithmen können instabil sein
Kann zu visuellen Fehlinterpretationen führen

Hiveplots¶

Hiveplots sind eine alternative Visualisierungsmethode, die versucht, die Unordnung von Furball-Darstellungen zu vermeiden, indem sie Knoten entlang von Achsen anordnet, basierend auf Netzwerkeigenschaften wie Grad oder Clustering-Koeffizient. Hier ein Beispiel für eine konkrete Anwendung:

Bildquelle: https://hiveplot.com/img/hiveplot-ecoli.png

Vorteile:

Reduziert visuelle Unordnung
Ermöglicht systematischen Vergleich von Netzwerkstrukturen
Skaliert besser mit der Netzwerkgröße

Nachteile:

Weniger intuitiv für Anfänger
Erfordert Entscheidungen über die Anordnung von Knoten
Kann bestimmte globale Strukturen verschleiern

Visualisierung mit NetworkX und Matplotlib¶

NetworkX bietet in Verbindung mit Matplotlib einfache Möglichkeiten zur Visualisierung von Graphen:

In [ ]:

!conda install networkx conda-forge::python-igraph conda-forge::holoviews conda-forge::pycairo conda-forge::fa2 -y
# !conda install conda-forge::pycairo -y

In [2]:

import networkx as nx
import matplotlib.pyplot as plt

# Erstellen eines Graphen
G = nx.Graph()
G.add_edges_from([('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D')])

# Visualisierung mit verschiedenen Layout-Algorithmen
plt.figure(figsize=(12, 8))

# Spring Layout (kräftebasiert)
plt.subplot(221)
nx.draw(G, pos=nx.spring_layout(G), with_labels=True, node_color='lightblue', 
        node_size=500, font_weight='bold')
plt.title("Spring Layout")

# Circular Layout
plt.subplot(222)
nx.draw(G, pos=nx.circular_layout(G), with_labels=True, node_color='lightgreen', 
        node_size=500, font_weight='bold')
plt.title("Circular Layout")

# Random Layout
plt.subplot(223)
nx.draw(G, pos=nx.random_layout(G), with_labels=True, node_color='lightcoral', 
        node_size=500, font_weight='bold')
plt.title("Random Layout")

# Spectral Layout
plt.subplot(224)
nx.draw(G, pos=nx.spectral_layout(G), with_labels=True, node_color='lightyellow', 
        node_size=500, font_weight='bold')
plt.title("Spectral Layout")

plt.tight_layout()
plt.show()

6.2.3 Komplexitätsvergleich der verschiedenen Darstellungen¶

Die Wahl der richtigen Datenstruktur hängt von den geplanten Operationen ab. Hier ist ein Vergleich der Zeitkomplexität für häufige Operationen:

Operation	Adjazenzmatrix	Adjazenzliste	Inzidenzmatrix
Speicherbedarf	O(V²)	O(V+E)	O(V×E)
Kante einfügen	O(1)	O(1)	O(1)
Kante entfernen	O(1)	O(E)	O(E)
Kante prüfen	O(1)	O(deg(V))	O(E)
Alle Nachbarn finden	O(V)	O(deg(V))	O(E)
Alle Kanten finden	O(V²)	O(V+E)	O(V×E)

Wobei:

V = Anzahl der Knoten (Vertices)
E = Anzahl der Kanten (Edges)
deg(V) = Grad eines Knotens (typischerweise viel kleiner als V)

Hier noch einmal die wichtigsten Empfehlungen für die Auswahl geeigneter Datenstrukturen:

Adjazenzmatrix: Gut für dichte Graphen und wenn schnelle Kanten-Lookups wichtig sind
Adjazenzliste: Gut für dünn besetzte Graphen und wenn Nachbar-Iteration wichtig ist
Inzidenzmatrix: Selten verwendet, nützlich für spezielle Anwendungen mit Fokus auf Kanten

6.2.4 Verwendung spezialisierter Bibliotheken¶

Python bietet mehrere leistungsstarke Bibliotheken für die Arbeit mit Graphen:

NetworkX¶

NetworkX (bereits oben kurz verwendet) ist eine umfassende Bibliothek für die Erstellung, Manipulation und Analyse komplexer Netzwerke. Es ist für allgemeine Graphalgorithmen optimiert und bietet eine benutzerfreundliche API.

In [3]:

import networkx as nx

# Erstellen eines Graphen
G = nx.Graph()  # ungerichtet
# G = nx.DiGraph()  # für gerichtete Graphen

# Hinzufügen von Knoten
G.add_node('A', role='source')  # Knoten mit Attributen
G.add_nodes_from(['B', 'C', 'D'])

# Hinzufügen von Kanten
G.add_edge('A', 'B', weight=0.6)  # Kante mit Gewicht
G.add_edges_from([('A', 'C'), ('B', 'C'), ('B', 'D')])

# Grundlegende Informationen
print(f"Knoten: {G.nodes()}")
print(f"Kanten: {G.edges()}")
print(f"Anzahl der Knoten: {G.number_of_nodes()}")
print(f"Anzahl der Kanten: {G.number_of_edges()}")

# Zugriff auf Nachbarn
print(f"Nachbarn von B: {list(G.neighbors('B'))}")

# Zentralitätsmaße
print(f"Betweenness Centrality: {nx.betweenness_centrality(G)}")
print(f"Degree Centrality: {nx.degree_centrality(G)}")

# Kürzeste Pfade
print(f"Kürzester Pfad von A nach D: {nx.shortest_path(G, 'A', 'D')}")
print(f"Alle kürzesten Pfade: {dict(nx.all_pairs_shortest_path(G))}")

Knoten: ['A', 'B', 'C', 'D']
Kanten: [('A', 'B'), ('A', 'C'), ('B', 'C'), ('B', 'D')]
Anzahl der Knoten: 4
Anzahl der Kanten: 4
Nachbarn von B: ['A', 'C', 'D']
Betweenness Centrality: {'A': 0.0, 'B': 0.6666666666666666, 'C': 0.0, 'D': 0.0}
Degree Centrality: {'A': 0.6666666666666666, 'B': 1.0, 'C': 0.6666666666666666, 'D': 0.3333333333333333}
Kürzester Pfad von A nach D: ['A', 'B', 'D']
Alle kürzesten Pfade: {'A': {'A': ['A'], 'B': ['A', 'B'], 'C': ['A', 'C'], 'D': ['A', 'B', 'D']}, 'B': {'B': ['B'], 'A': ['B', 'A'], 'C': ['B', 'C'], 'D': ['B', 'D']}, 'C': {'C': ['C'], 'A': ['C', 'A'], 'B': ['C', 'B'], 'D': ['C', 'B', 'D']}, 'D': {'D': ['D'], 'B': ['D', 'B'], 'A': ['D', 'B', 'A'], 'C': ['D', 'B', 'C']}}

igraph¶

Python-igraph ist eine schnelle und effiziente Bibliothek, die besonders für große Graphen optimiert ist. Es bietet hervorragende Performance für rechenintensive Aufgaben.

In [4]:

import igraph as ig

# Erstellen eines Graphen
g = ig.Graph()
g.add_vertices(4)  # Indizes 0-3 statt Bezeichnern
g.vs["name"] = ["A", "B", "C", "D"]  # Namen zuweisen
g.add_edges([(0, 1), (0, 2), (1, 2), (1, 3)])  # Indizes nutzen

# Visualisierung
visual_style = {}
visual_style["vertex_size"] = 45
visual_style["vertex_label"] = g.vs["name"]
visual_style["edge_width"] = [1, 2, 3, 1]
visual_style["layout"] = g.layout("kk")
visual_style["bbox"] = (300, 300)
visual_style["margin"] = 40

ig.plot(g, **visual_style)

# Eigenschaften berechnen
print(f"Grad: {g.degree()}")
print(f"Durchmesser: {g.diameter()}")
print(f"Clustering-Koeffizient: {g.transitivity_undirected()}")

Grad: [2, 3, 2, 1]
Durchmesser: 2
Clustering-Koeffizient: 0.6

PyViz Ecosystem (HoloViews/hvPlot)¶

Für fortgeschrittene interaktive Visualisierungen bietet das PyViz-Ökosystem (mit Paketen wie HoloViews und hvPlot) leistungsstarke Werkzeuge. Diese sind besonders für die explorative Datenanalyse von Graphen nützlich.

In [5]:

import networkx as nx
import holoviews as hv
from holoviews import opts
hv.extension('bokeh')

# Graph erstellen
G = nx.karate_club_graph()  # Ein klassischer Beispielgraph

# In HoloViews-Format konvertieren
graph = hv.Graph.from_networkx(G, nx.layout.spring_layout)

# Visualisierung anpassen
graph.opts(
    opts.Graph(width=600, height=400, xaxis=None, yaxis=None,
               edge_line_width=1, node_size=10, node_color='category'))

Out[5]:

Beim Arbeiten mit großen Graphen ist die Auswahl der richtigen Bibliothek entscheidend für die Performance. NetworkX ist gut für Prototyping und kleinere Graphen, während igraph für größere Graphen und rechenintensive Operationen optimiert ist. Das PyViz-Ökosystem glänzt bei interaktiven, datengetriebenen Visualisierungen.

6.3 Graphtraversierung: Breitensuche (BFS) und Tiefensuche (DFS)¶

Graphtraversierung bezeichnet den Prozess des systematischen Besuchens aller Knoten in einem Graphen. Die zwei fundamentalen Algorithmen zur Graphtraversierung sind die Breitensuche (Breadth-First Search, BFS) und die Tiefensuche (Depth-First Search, DFS). Diese Algorithmen sind nicht nur grundlegend für das Verständnis von Graphen, sondern dienen auch als Bausteine für komplexere Algorithmen.

6.3.1 Grundprinzipien und Algorithmen im Vergleich¶

Breitensuche (BFS)¶

Die Breitensuche beginnt an einem Startknoten und besucht zuerst alle direkten Nachbarn, bevor sie zu den Nachbarn der Nachbarn übergeht. Dies führt zu einer ebenenweisen Traversierung des Graphen, bei der zuerst alle Knoten mit Abstand 1 vom Startknoten, dann alle mit Abstand 2 usw. besucht werden.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/5/5d/Breadth-First-Search-Algorithm.gif

Eigenschaften der BFS:

Verwendet eine Queue (FIFO – First In, First Out) zur Verwaltung der zu besuchenden Knoten
Findet den kürzesten Pfad in ungewichteten Graphen
Gut für die Suche nach Knoten in der Nähe des Startpunkts
Speicherbedarf kann bei großen Graphen problematisch sein, da die Queue alle Knoten einer Ebene speichern muss

Tiefensuche (DFS)¶

Die Tiefensuche beginnt ebenfalls an einem Startknoten, geht aber so weit wie möglich entlang eines Pfades, bevor sie zurückkehrt und alternative Pfade erkundet. Dies führt zu einer pfadorientierten Traversierung des Graphen.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/7/7f/Depth-First-Search.gif

Eigenschaften der DFS:

Verwendet einen Stack (LIFO – Last In, First Out) oder Rekursion für die Implementierung
Kann effizienter sein, wenn man erwartet, dass Lösungen weit vom Startpunkt entfernt sind
Gut für die Erkundung aller möglichen Pfade
Ideal für Aufgaben wie die Erkennung von Zyklen oder topologische Sortierung

6.3.2 Implementierung von BFS mit Queue-Datenstruktur¶

Die Breitensuche wird typischerweise mit einer Queue implementiert, die das FIFO-Prinzip (First-In-First-Out) verwendet. Hier ist ein grundlegender Algorithmus für BFS:

Initialisiere eine leere Queue und füge den Startknoten hinzu.
Markiere den Startknoten als besucht.
Solange die Queue nicht leer ist: a. Entferne den vordersten Knoten aus der Queue. b. Verarbeite den Knoten (z.B. gib ihn aus). c. Füge alle unbesuchten Nachbarn des Knotens zur Queue hinzu und markiere sie als besucht.

Implementierung in Python¶

In [6]:

from collections import deque

def bfs(graph, start):
    """
    Führt eine Breitensuche auf dem Graphen durch, beginnend beim Startknoten.
    
    Parameter:
    graph -- Ein Graph als Adjazenzliste (Dictionary)
    start -- Der Startknoten
    
    Rückgabe:
    Eine Liste mit den besuchten Knoten in der Reihenfolge ihres Besuchs
    """
    # Initialisiere die Datenstrukturen
    visited = set()  # Menge zur Speicherung besuchter Knoten
    queue = deque([start])  # Queue mit dem Startknoten
    visited.add(start)  # Markiere den Startknoten als besucht
    
    # Liste zur Speicherung der Besuchsreihenfolge
    traversal_order = []
    
    # BFS-Algorithmus
    while queue:
        # Entferne den vordersten Knoten aus der Queue
        current_node = queue.popleft()
        traversal_order.append(current_node)
        
        # Füge alle unbesuchten Nachbarn zur Queue hinzu
        for neighbor in graph[current_node]:
            if neighbor not in visited:
                visited.add(neighbor)
                queue.append(neighbor)
    
    return traversal_order

# Beispielgraph
graph = {
    'A': ['B', 'C'],
    'B': ['A', 'D', 'E'],
    'C': ['A', 'F'],
    'D': ['B'],
    'E': ['B', 'F'],
    'F': ['C', 'E']
}

# BFS durchführen
bfs_order = bfs(graph, 'A')
print("BFS-Reihenfolge:", bfs_order)

BFS-Reihenfolge: ['A', 'B', 'C', 'D', 'E', 'F']

Berechnung der kürzesten Pfade mit BFS¶

Eine wichtige Anwendung von BFS ist die Berechnung der kürzesten Pfade in ungewichteten Graphen. Hier ist eine Implementierung, die nicht nur die Knoten besucht, sondern auch die kürzesten Pfade und Distanzen vom Startknoten zu allen erreichbaren Knoten berechnet:

In [7]:

def bfs_shortest_paths(graph, start):
    """
    Berechnet die kürzesten Pfade von einem Startknoten zu allen anderen Knoten
    in einem ungewichteten Graphen mittels BFS.
    
    Parameter:
    graph -- Ein Graph als Adjazenzliste (Dictionary)
    start -- Der Startknoten
    
    Rückgabe:
    distances -- Dictionary mit Distanzen vom Startknoten
    predecessors -- Dictionary mit Vorgängerknoten für die Pfadrekonstruktion
    """
    # Initialisiere die Datenstrukturen
    visited = {start}  # Menge besuchter Knoten
    queue = deque([(start, 0)])  # Queue mit (Knoten, Distanz)
    
    # Distanzen und Vorgänger für die Pfadrekonstruktion
    distances = {start: 0}
    predecessors = {start: None}
    
    while queue:
        current_node, distance = queue.popleft()
        
        for neighbor in graph[current_node]:
            if neighbor not in visited:
                visited.add(neighbor)
                distances[neighbor] = distance + 1
                predecessors[neighbor] = current_node
                queue.append((neighbor, distance + 1))
    
    return distances, predecessors

def reconstruct_path(predecessors, start, end):
    """
    Rekonstruiert den Pfad vom Start- zum Zielknoten anhand der Vorgängerinformationen.
    
    Parameter:
    predecessors -- Dictionary mit Vorgängerknoten
    start -- Startknoten
    end -- Zielknoten
    
    Rückgabe:
    path -- Liste mit dem Pfad vom Start zum Ziel
    """
    if end not in predecessors:
        return None  # Zielknoten ist nicht erreichbar
    
    path = []
    current = end
    
    # Gehe vom Ziel zum Start zurück
    while current != start:
        path.append(current)
        current = predecessors[current]
    
    path.append(start)  # Füge den Startknoten hinzu
    path.reverse()  # Drehe den Pfad um
    
    return path

# Anwendung
distances, predecessors = bfs_shortest_paths(graph, 'A')
print("Distanzen von A:", distances)

# Kürzesten Pfad von A nach F berechnen
path_to_F = reconstruct_path(predecessors, 'A', 'F')
print("Kürzester Pfad von A nach F:", path_to_F)

Distanzen von A: {'A': 0, 'B': 1, 'C': 1, 'D': 2, 'E': 2, 'F': 2}
Kürzester Pfad von A nach F: ['A', 'C', 'F']

6.3.3 Rekursive und iterative Implementierung von DFS¶

Die Tiefensuche kann sowohl rekursiv als auch iterativ mit einem Stack implementiert werden. Beide Ansätze sind äquivalent, haben aber unterschiedliche Vor- und Nachteile.

Rekursive Implementierung¶

Die rekursive Implementierung nutzt den Funktionsaufrufstack des Systems:

In [9]:

def dfs_recursive(graph, start, visited=None, traversal_order=None):
    """
    Führt eine rekursive Tiefensuche auf dem Graphen durch.
    
    Parameter:
    graph -- Ein Graph als Adjazenzliste (Dictionary)
    start -- Der aktuelle Knoten
    visited -- Menge bereits besuchter Knoten
    traversal_order -- Liste zur Speicherung der Besuchsreihenfolge
    
    Rückgabe:
    Die Liste mit den besuchten Knoten in DFS-Reihenfolge
    """
    # Initialisiere visited und traversal_order beim ersten Aufruf
    if visited is None:
        visited = set()
    if traversal_order is None:
        traversal_order = []
    
    # Markiere den aktuellen Knoten als besucht
    visited.add(start)
    traversal_order.append(start)
    
    # Rekursiver Aufruf für alle unbesuchten Nachbarn
    for neighbor in graph[start]:
        if neighbor not in visited:
            dfs_recursive(graph, neighbor, visited, traversal_order)
    
    return traversal_order

# DFS rekursiv durchführen
dfs_recursive_order = dfs_recursive(graph, 'A')
print("Rekursive DFS-Reihenfolge:", dfs_recursive_order)

Rekursive DFS-Reihenfolge: ['A', 'B', 'D', 'E', 'F', 'C']

Vorteile:

Eleganter und lesbarer Code
Natürliche Umsetzung des Algorithmus

Nachteile:

Risiko eines Stack-Overflows bei sehr tiefen Graphen
Höherer Overhead durch Funktionsaufrufe

Iterative Implementierung¶

Die iterative Implementierung verwendet einen expliziten Stack:

In [10]:

def dfs_iterative(graph, start):
    """
    Führt eine iterative Tiefensuche auf dem Graphen durch.
    
    Parameter:
    graph -- Ein Graph als Adjazenzliste (Dictionary)
    start -- Der Startknoten
    
    Rückgabe:
    Eine Liste mit den besuchten Knoten in DFS-Reihenfolge
    """
    # Initialisiere die Datenstrukturen
    visited = set()
    stack = [start]  # Initialisiere den Stack mit dem Startknoten
    traversal_order = []
    
    while stack:
        # Entferne den obersten Knoten vom Stack
        current_node = stack.pop()
        
        # Wenn der Knoten noch nicht besucht wurde
        if current_node not in visited:
            visited.add(current_node)
            traversal_order.append(current_node)
            
            # Füge alle unbesuchten Nachbarn zum Stack hinzu (in umgekehrter Reihenfolge)
            for neighbor in reversed(graph[current_node]):
                if neighbor not in visited:
                    stack.append(neighbor)
    
    return traversal_order

# DFS iterativ durchführen
dfs_iterative_order = dfs_iterative(graph, 'A')
print("Iterative DFS-Reihenfolge:", dfs_iterative_order)

Iterative DFS-Reihenfolge: ['A', 'B', 'D', 'E', 'F', 'C']

Vorteile:

Keine Gefahr eines Stack-Overflows
Potentiell effizienter bei sehr tiefen Graphen

Nachteile:

Etwas komplexere Implementierung
Die Besuchsreihenfolge kann sich von der rekursiven Version unterscheiden

6.3.4 Vergleich und Visualisierung von BFS und DFS¶

Um die unterschiedlichen Traversierungsstrategien von BFS und DFS besser zu verstehen, ist es hilfreich, sie zu visualisieren. Hier ist ein Beispielcode, der beide Algorithmen auf demselben Graphen anwendet und die Traversierungsreihenfolge visualisiert:

In [14]:

import networkx as nx
import matplotlib.pyplot as plt
import matplotlib.animation as animation
from collections import deque

def create_visualization(graph, start, algorithm="bfs"):
    """
    Erstellt eine Animation der Graph-Traversierung.
    
    Parameter:
    graph -- Der Graph als Adjazenzliste
    start -- Der Startknoten
    algorithm -- "bfs" oder "dfs"
    """
    # Erstelle einen NetworkX-Graphen
    G = nx.Graph()
    for node in graph:
        for neighbor in graph[node]:
            G.add_edge(node, neighbor)
    
    # Berechne das Layout (Positionen der Knoten)
    pos = nx.spring_layout(G, seed=42)
    
    # Initialisiere Figure
    fig, ax = plt.subplots(figsize=(10, 8))
    
    # Sammle die Frames für die Animation
    frames = []
    
    if algorithm == "bfs":
        # BFS-Animation
        visited = set([start])
        queue = deque([start])
        
        # Anfangszustand
        node_colors = ['red' if node == start else 'lightblue' for node in G.nodes()]
        edge_colors = ['black' for _ in G.edges()]
        frames.append((node_colors.copy(), edge_colors.copy()))
        
        while queue:
            current = queue.popleft()
            
            for neighbor in graph[current]:
                if neighbor not in visited:
                    visited.add(neighbor)
                    queue.append(neighbor)
                    
                    # Aktualisiere Farben
                    node_colors = ['red' if node in visited else 'lightblue' for node in G.nodes()]
                    edge_colors = ['red' if (u, v) == (current, neighbor) or (u, v) == (neighbor, current) 
                                   else 'red' if any((u == node and v in visited and node in visited) or
                                                    (v == node and u in visited and node in visited) 
                                                    for node in visited)
                                   else 'black' 
                                   for u, v in G.edges()]
                    
                    frames.append((node_colors.copy(), edge_colors.copy()))
    
    else:  # DFS
        # DFS-Animation
        visited = set()
        stack = [start]
        
        # Anfangszustand
        node_colors = ['red' if node == start else 'lightblue' for node in G.nodes()]
        edge_colors = ['black' for _ in G.edges()]
        frames.append((node_colors.copy(), edge_colors.copy()))
        
        while stack:
            current = stack.pop()
            
            if current not in visited:
                visited.add(current)
                
                for neighbor in reversed(graph[current]):
                    if neighbor not in visited:
                        stack.append(neighbor)
                
                # Aktualisiere Farben
                node_colors = ['red' if node in visited else 'lightblue' for node in G.nodes()]
                edge_colors = ['red' if any((u == node and v in visited and node in visited) or
                                           (v == node and u in visited and node in visited) 
                                           for node in visited)
                              else 'black' 
                              for u, v in G.edges()]
                
                frames.append((node_colors.copy(), edge_colors.copy()))
    
    # Make sure we have frames before creating animation
    if not frames:
        print(f"Warning: No frames collected for {algorithm} animation!")
        # Add at least one dummy frame to avoid errors
        frames.append((['lightblue' for _ in G.nodes()], ['black' for _ in G.edges()]))
    
    # Erstelle Animation
    def update(frame_idx):
        ax.clear()
        node_colors, edge_colors = frames[frame_idx]
        nx.draw(G, pos, with_labels=True, node_color=node_colors, 
                edge_color=edge_colors, node_size=500, font_weight='bold', ax=ax)
        ax.set_title(f"{algorithm.upper()}-Traversierung (Schritt {frame_idx})")
        return ax
    
    # Use the correct number of frames
    ani = animation.FuncAnimation(fig, update, frames=len(frames), interval=1000)
    return ani

# BFS-Animation erstellen
bfs_animation = create_visualization(graph, 'A', "bfs")
# DFS-Animation erstellen
dfs_animation = create_visualization(graph, 'A', "dfs")

# Animationen speichern (optional)
bfs_animation.save('bfs_animation.gif', writer='pillow')
dfs_animation.save('dfs_animation.gif', writer='pillow')

plt.show()

Zusammenfassung der Unterschiede¶

Die Visualisierungen verdeutlichen die grundlegenden Unterschiede zwischen BFS und DFS:

BFS exploriert den Graphen ebenenweise, beginnend mit allen direkten Nachbarn des Startknotens, bevor es zu den Nachbarn der Nachbarn übergeht. Dies führt zu einem konzentrisch expandierenden Muster um den Startknoten herum.
DFS erkundet den Graphen pfadorientiert, indem es so weit wie möglich entlang eines Pfades geht, bevor es zurückkehrt und alternative Pfade erkundet. Dies führt zu einem eher linearen Muster, das sich verzweigt, wenn Sackgassen erreicht werden.

In unserem konkreten Beispiel ist der Unterschied konkret am Besuch von C sichtbar, der zu verschiedenen Zeiten an der Reihe ist. Beide Algorithmen besuchen alle Knoten, die vom Startknoten aus erreichbar sind (also all Knoten in diesem Beispielgraph), aber in unterschiedlicher Reihenfolge.

Die Wahl zwischen BFS und DFS hängt vom spezifischen Anwendungsfall ab:

Verwenden Sie BFS, wenn Sie den kürzesten Pfad in einem ungewichteten Graphen finden möchten oder wenn das Ziel wahrscheinlich nahe am Startpunkt liegt.
Verwenden Sie DFS, wenn Sie den Graphen vollständig erkunden möchten, wenn Pfade wichtiger sind als kürzeste Distanzen, oder wenn das Ziel wahrscheinlich tief im Graphen liegt.

6.4 Einführung in erweiterte Graphalgorithmen¶

In diesem Abschnitt führen wir zwei fundamentale Problemklassen in der Graphentheorie ein: das Kürzeste-Wege-Problem und das Problem des minimalen Spannbaums. Diese Probleme sind nicht nur theoretisch interessant, sondern haben auch zahlreiche praktische Anwendungen. Wir beschränken uns hier aber auf einen reinen Überblick und die Erwähnung der wichtigsten Beispiel-Algorithmen.

6.4.1 Das Kürzeste-Wege-Problem: Definition und Anwendungen¶

Das Kürzeste-Wege-Problem besteht darin, den Pfad mit minimaler Länge (oder minimalem Gewicht) zwischen zwei Knoten in einem Graphen zu finden. Je nach Problemstellung unterscheiden wir verschiedene Varianten:

Single-Source Shortest Path (SSSP): Finde kürzeste Pfade von einem Startknoten zu allen anderen Knoten.
Single-Target Shortest Path: Finde kürzeste Pfade von allen Knoten zu einem Zielknoten.
Single-Pair Shortest Path: Finde den kürzesten Pfad zwischen einem spezifischen Startknoten und einem Zielknoten.
All-Pairs Shortest Paths (APSP): Finde kürzeste Pfade zwischen allen Paaren von Knoten.

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/thumb/3/3b/Shortest_path_with_direct_weights.svg/640px-Shortest_path_with_direct_weights.svg.png

Die wichtigsten Algorithmen für das Kürzeste-Wege-Problem sind der Dijkstra-Algorithmus, der Bellman-Ford-Algorithmus, der Floyd-Warshall-Algorithmus und der $A^\ast$-Algorithmus. Wie diese Algorithmen im Detail funktionieren, sprengt den Rahmen unserer Lehrveranstaltung.

Praktische Anwendungen des Kürzeste-Wege-Problems:¶

Solche Anwendungen sind praktisch überall zu finden. Es ist auch instinktiv einsichtig, wo man überall ein System mit Hilfe eines Netzwerks beschreiben kann, und dann einen kürzesten oder möglichst kurzen Weg zwischen zwei oder mehreren Punkten im Netzwerk finden will. Hier sind einige konkrete Beispiele:

Navigationssysteme: Berechnung der schnellsten Route zwischen zwei Orten.
Netzwerkrouting: Finden des effizientesten Pfades für Datenpakete.
Künstliche Intelligenz: Pathfinding in Spielen und Roboternavigation.
Soziale Netzwerkanalyse: Berechnung der “Grad der Trennung” zwischen Personen.
Logistik: Optimierung von Lieferketten und Transportrouten.

6.4.2 Minimale Spannbäume: Definition und Anwendungen¶

Ein Spannbaum (auf Englisch Spanning Tree) eines ungerichteten, zusammenhängenden Graphen ist ein Teilgraph, der alle Knoten verbindet und ein Baum ist (d.h., zusammenhängend und ohne Zyklen). Ein minimaler Spannbaum (Minimum Spanning Tree, MST) ist ein Spannbaum mit minimaler Summe der Kantengewichte. Er hat genau $|V| – 1$ Kanten (wobei $|V|$ die Anzahl der Knoten ist). Hier sehen Sie ein konkretes Beispiel für so einen MST:

Bildquelle: https://upload.wikimedia.org/wikipedia/commons/thumb/d/d2/Minimum_spanning_tree.svg/640px-Minimum_spanning_tree.svg.png

Die wichtigsten Algorithmen für minimale Spannbäume sind beispielhaft der Kruskal-Algorithmus und der Prim-Algorithmus. Beide Algorithmen bauen den MST auf ihre jeweilige spezielle Weise aus allen Knoten und Kanten zusammen.

Auch für minimale Spannbäume gibt es reihenweise konkrete Anwendungen. Auch hier ist es einsichtig, dass ein Baum, der das ganze Netzwerk möglichst effizient durchzieht, eine praktische und interessante Fragestellung sein kann. Hier sind wieder einige konkrete Beispiele:

Netzwerkdesign: Entwurf von kostengünstigen Kommunikations- oder Transportnetzwerken.
Clusteranalyse: Identifikation von Clustern in Datenpunkten durch Entfernen teurer Kanten aus dem MST.
Stromnetze: Planung von effizienten Stromversorgungsnetzen.
Wasserleitungen, Gasleitungen: Planung von Versorgungsinfrastruktur.
Approximationsalgorithmen: MSTs werden auch in Approximationsalgorithmen für NP-schwere Probleme wie das Traveling Salesman Problem verwendet.

6.4.3 Zusammenhang zwischen Graphtraversierung und erweiterten Algorithmen¶

Bisher haben wir sowohl die Traversierungsalgorithmen als auch die fortgeschritteneren Probleme gesondert betrachtet. Diese hängen jedoch zusammen, weil man in vielen komplexeren Situation einfach “nur” möglichst kurze Wege oder bestimmte andere Eigenschaften im Netzwerk herausfinden muss. Die grundlegenden Traversierungsalgorithmen BFS und DFS bilden dabei die Basis für viele der erweiterten Graphalgorithmen:

Zum Beispiel ist BFS die Grundlage für Kürzeste-Wege-Algorithmen, denn BFS findet automatisch den kürzesten Pfad in ungewichteten Graphen. Dijkstra’s Algorithmus kann dann etwa als eine Erweiterung von BFS für gewichtete Graphen betrachtet werden.

DFS kann man in ähnlicher Weise als Grundlage für Zyklen- und Strukturerkennung ansehen. DFS eignet sich z.B. hervorragend für die Erkennung von strukturellen Eigenschaften in Graphen, wie etwa Zyklen: Wenn DFS auf einen bereits auf dem aktuellen Pfad besuchten Knoten trifft, wurde ein Zyklus gefunden.

Eine analoge Ähnlichkeit verbindet sowohl BFS als auch DFS mit minimalen Spannbäumen. Insgesamt sehen wir also, wie wichtig es ist, die Grundlagen der Graph-Algorithmen gut zu verstehen. Mit diesem Wissen können wir dann im Bedarfsfall auch komplexere Algorithmen besser nachvollziehen und anpassen.

6.5 Übungsaufgabe: Analyse eines sozialen Netzwerks¶

In dieser Übungsaufgabe werden wir uns mit der Analyse eines “sozialen Netzwerks” beschäftigen. Konkret geht es dabei um die Marvel-Superhelden, deren “soziales Netzwerk” so organisiert ist, dass Charaktere miteinander verbunden sind, wenn sie in denselben Comics aufgetreten sind. Damit kann man bereits recht viel anstellen und hier ist wieder Ihre Kreativität gefragt.

6.5.1 Der Datensatz¶

Der Marvel-Netzwerk-Datensatz enthält Informationen über gemeinsame Auftritte von Marvel-Superhelden in Comics. Jeder Knoten repräsentiert einen Charakter, und eine Kante zwischen zwei Charakteren bedeutet, dass sie in mindestens einem Comic zusammen aufgetreten sind. Diese Daten findet man z.B. auch auf der Kaggle-Platform, konkret hier: https://www.kaggle.com/datasets/csanhueza/the-marvel-universe-social-network/ Bitte beachten Sie zur Nachverfolgung aller Quellen auch die Hinweise auf der hier verlinkten Webseite.

Um nicht mit der Konstruktion des Netzwerks kämpfen zu müssen, sondern gleich mit dem fertigen Beziehungs-Graph arbeiten zu können, starten wir damit. Die Datei wird hier zunächst eingelesen und dann extrahieren wir noch die Bezeichnungen der Knoten (also die Namen der Superhelden).

In [22]:

import pandas as pd
import networkx as nx
import matplotlib.pyplot as plt
from collections import Counter
import os
import pickle

# Datei einlesen
print("Lade Superhelden-Netzwerk...")
df = pd.read_csv(os.path.join('data','hero-network.csv'))

# Schneller Überblick über die Daten
print("\nErste paar Zeilen der Datei:")
print(df.head(10))

print("\nInformationen zum DataFrame:")
print(df.info())

# Überprüfen auf doppelte Einträge
duplicate_count = df.duplicated().sum()
print(f"\nAnzahl doppelter Einträge: {duplicate_count}")

if duplicate_count > 0:
    print("Beispiele für doppelte Einträge:")
    print(df[df.duplicated(keep=False)].sort_values(by=['hero1', 'hero2']).head(10))

# Erstelle eine Liste aller eindeutigen Helden
all_heroes = pd.concat([df['hero1'], df['hero2']]).unique()
print(f"\nAnzahl eindeutiger Helden: {len(all_heroes)}")
print(f"Beispiele für Heldennamen: {all_heroes[:5]}")

# Zähle, wie oft jeder Held im Datensatz vorkommt
hero_occurrences = Counter(pd.concat([df['hero1'], df['hero2']]))

# Top 10 Helden nach Häufigkeit anzeigen
print("\nTop 10 Helden nach Anzahl der Verbindungen:")
for hero, count in hero_occurrences.most_common(10):
    print(f"{hero}: {count} Verbindungen")

# Überprüfen, ob es Paare gibt, die mehrfach vorkommen (implizite Gewichtung)
pair_counts = df.groupby(['hero1', 'hero2']).size().reset_index(name='weight')
multi_pairs = pair_counts[pair_counts['weight'] > 1]

print(f"\nAnzahl der Heldenpaare: {len(pair_counts)}")
print(f"Davon mit mehrfachen Verbindungen: {len(multi_pairs)}")

if len(multi_pairs) > 0:
    print("\nBeispiele für Paare mit mehrfachen Verbindungen:")
    print(multi_pairs.sort_values(by='weight', ascending=False).head(10))
    
    # Erstelle eine bereinigte Version mit Gewichten
    print("\nErstelle bereinigte Datenversion mit Gewichten...")
    network_with_weights = pair_counts
else:
    print("\nKeine mehrfachen Verbindungen gefunden, jedes Paar erscheint nur einmal.")
    # Füge eine Gewichtsspalte mit einheitlichem Wert 1 hinzu
    network_with_weights = pair_counts

# Check for self-loops
self_loops = df[df['hero1'] == df['hero2']]
print(f"\nAnzahl der Selbstverbindungen (Helden mit sich selbst verbunden): {len(self_loops)}")

if len(self_loops) > 0:
    print("Beispiele für Selbstverbindungen:")
    print(self_loops.head())
    
    # Filtere Selbstverbindungen aus dem bereinigten DataFrame
    network_with_weights = network_with_weights[network_with_weights['hero1'] != network_with_weights['hero2']]
    print(f"Bereinigte Anzahl der Heldenpaare: {len(network_with_weights)}")

# Erstelle einen NetworkX-Graphen
G = nx.Graph()

# Füge Knoten hinzu (alle eindeutigen Helden)
G.add_nodes_from(all_heroes)

# Füge Kanten mit Gewichten hinzu
for _, row in network_with_weights.iterrows():
    G.add_edge(row['hero1'], row['hero2'], weight=row['weight'])

# Grundlegende Netzwerkstatistiken
print("\nGrundlegende Netzwerkstatistiken:")
print(f"Anzahl der Knoten (Helden): {G.number_of_nodes()}")
print(f"Anzahl der Kanten (Verbindungen): {G.number_of_edges()}")
print(f"Ist das Netzwerk zusammenhängend? {nx.is_connected(G)}")

if not nx.is_connected(G):
    components = list(nx.connected_components(G))
    print(f"Anzahl der Zusammenhangskomponenten: {len(components)}")
    print(f"Größe der größten Komponente: {len(max(components, key=len))}")

# Speichere den Graphen für spätere Verwendung
print("\nSpeichere Netzwerkdaten für weitere Analysen...")

# Speichervorgang hier optional implementieren, z.B.:
# nx.write_graphml(G, "hero_network.graphml")
# Oder als Pickle-Datei:
# import pickle
with open(os.path.join("data","hero_network.pickle"), "wb") as f:
    pickle.dump(G, f)

print("\nDatenvorverarbeitung abgeschlossen. Bereit für weitere Analysen!")

Lade Superhelden-Netzwerk...

Erste paar Zeilen der Datei:
                  hero1                 hero2
0         LITTLE, ABNER        PRINCESS ZANDA
1         LITTLE, ABNER  BLACK PANTHER/T'CHAL
2  BLACK PANTHER/T'CHAL        PRINCESS ZANDA
3         LITTLE, ABNER        PRINCESS ZANDA
4         LITTLE, ABNER  BLACK PANTHER/T'CHAL
5  BLACK PANTHER/T'CHAL        PRINCESS ZANDA
6  STEELE, SIMON/WOLFGA      FORTUNE, DOMINIC
7  STEELE, SIMON/WOLFGA   ERWIN, CLYTEMNESTRA
8  STEELE, SIMON/WOLFGA  IRON MAN/TONY STARK 
9  STEELE, SIMON/WOLFGA  IRON MAN IV/JAMES R.

Informationen zum DataFrame:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 574467 entries, 0 to 574466
Data columns (total 2 columns):
 #   Column  Non-Null Count   Dtype 
---  ------  --------------   ----- 
 0   hero1   574467 non-null  object
 1   hero2   574467 non-null  object
dtypes: object(2)
memory usage: 8.8+ MB
None

Anzahl doppelter Einträge: 350286
Beispiele für doppelte Einträge:
                       hero1                 hero2
188178  3-D MAN/CHARLES CHAN           GORILLA-MAN
188206  3-D MAN/CHARLES CHAN           GORILLA-MAN
211082  3-D MAN/CHARLES CHAN           GORILLA-MAN
188177  3-D MAN/CHARLES CHAN           HUMAN ROBOT
188207  3-D MAN/CHARLES CHAN           HUMAN ROBOT
211080  3-D MAN/CHARLES CHAN           HUMAN ROBOT
188179  3-D MAN/CHARLES CHAN  JONES, RICHARD MILHO
188204  3-D MAN/CHARLES CHAN  JONES, RICHARD MILHO
188202  3-D MAN/CHARLES CHAN  MARVEL BOY III/ROBER
211081  3-D MAN/CHARLES CHAN  MARVEL BOY III/ROBER

Anzahl eindeutiger Helden: 6426
Beispiele für Heldennamen: ['LITTLE, ABNER' "BLACK PANTHER/T'CHAL" 'STEELE, SIMON/WOLFGA'
 'RAVEN, SABBATH II/EL' 'IRON MAN IV/JAMES R.']

Top 10 Helden nach Anzahl der Verbindungen:
CAPTAIN AMERICA: 16499 Verbindungen
SPIDER-MAN/PETER PAR: 13717 Verbindungen
IRON MAN/TONY STARK : 11817 Verbindungen
THOR/DR. DONALD BLAK: 11427 Verbindungen
THING/BENJAMIN J. GR: 10681 Verbindungen
WOLVERINE/LOGAN : 10353 Verbindungen
HUMAN TORCH/JOHNNY S: 10237 Verbindungen
SCARLET WITCH/WANDA : 9911 Verbindungen
MR. FANTASTIC/REED R: 9775 Verbindungen
VISION : 9696 Verbindungen

Anzahl der Heldenpaare: 224181
Davon mit mehrfachen Verbindungen: 85352

Beispiele für Paare mit mehrfachen Verbindungen:
                       hero1                 hero2  weight
142514     PATRIOT/JEFF MACE     PATRIOT/JEFF MACE    1275
142513     PATRIOT/JEFF MACE  MISS AMERICA/MADELIN    1267
124770  MISS AMERICA/MADELIN  MISS AMERICA/MADELIN     672
124772  MISS AMERICA/MADELIN     PATRIOT/JEFF MACE     627
196026  THING/BENJAMIN J. GR  HUMAN TORCH/JOHNNY S     382
85445   HUMAN TORCH/JOHNNY S  MR. FANTASTIC/REED R     366
196250  THING/BENJAMIN J. GR  MR. FANTASTIC/REED R     365
129194  MR. FANTASTIC/REED R  INVISIBLE WOMAN/SUE      362
85724   HUMAN TORCH/JOHNNY S  THING/BENJAMIN J. GR     362
89234   INVISIBLE WOMAN/SUE   HUMAN TORCH/JOHNNY S     353

Erstelle bereinigte Datenversion mit Gewichten...

Anzahl der Selbstverbindungen (Helden mit sich selbst verbunden): 2232
Beispiele für Selbstverbindungen:
                     hero1                 hero2
8888  MISS AMERICA/MADELIN  MISS AMERICA/MADELIN
8889  MISS AMERICA/MADELIN  MISS AMERICA/MADELIN
8890  MISS AMERICA/MADELIN  MISS AMERICA/MADELIN
8891  MISS AMERICA/MADELIN  MISS AMERICA/MADELIN
8892  MISS AMERICA/MADELIN  MISS AMERICA/MADELIN
Bereinigte Anzahl der Heldenpaare: 224169

Grundlegende Netzwerkstatistiken:
Anzahl der Knoten (Helden): 6426
Anzahl der Kanten (Verbindungen): 167207
Ist das Netzwerk zusammenhängend? False
Anzahl der Zusammenhangskomponenten: 4
Größe der größten Komponente: 6408

Speichere Netzwerkdaten für weitere Analysen...

Datenvorverarbeitung abgeschlossen. Bereit für weitere Analysen!

6.5.2 Nächste Schritte¶

Sie haben mit diesem Datensatz wieder vielfältige Möglichkeiten. Zunächst sollten Sie versuchen, einen Überblick zu bekommen, der über die bloßen Outputs der organisatorischen Code-Zelle von oben hinausgeht. Dafür eignet sich natürlich eine Visualisierung, doch Achtung: Dieser Datensatz ist sehr umfangreich und es empfiehlt sich, irgendeine Auswahl zu treffen. Diskutieren Sie also diese Siuation mit Ihrem LLM. Geben sie ihm die Outputs der Analyse am Ende des organisatorischen Code-Outputs und einigen Sie sich auf gangbare Wege für eine Visualisierung.

Danach diskutieren Sie, welche Analysen für so ein Superhelden-Social-Network interessant wären, und führen Sie diese durch. Visualisieren Sie, was Sie an interessanten Ergebnissen erhalten. Viel Spaß!

In [25]:

import networkx as nx
import matplotlib.pyplot as plt
import numpy as np
from fa2 import ForceAtlas2
import pandas as pd
from matplotlib.cm import get_cmap
from tqdm import tqdm

def visualize_hero_network(G, method="subset"):
    """
    Visualisiert das Superhelden-Netzwerk mit verschiedenen Methoden.
    
    Parameter:
    G -- NetworkX Graph-Objekt
    method -- Visualisierungsmethode: "subset", "largest_component", oder "community"
    """
    print(f"Visualisiere Netzwerk mit Methode: {method}")
    
    if method == "subset":
        # 1. Visualisierung eines Teilgraphen (Top-Helden nach Grad)
        print("Erstelle Teilgraph basierend auf Knotengrad...")
        degrees = dict(G.degree())
        top_nodes = sorted(degrees, key=degrees.get, reverse=True)[:100]  # Top 100
        subgraph = G.subgraph(top_nodes)
        
        print(f"Teilgraph erstellt mit {subgraph.number_of_nodes()} Knoten und {subgraph.number_of_edges()} Kanten")
        
        plt.figure(figsize=(15, 15))
        pos = nx.spring_layout(subgraph, seed=42)
        
        # Knotengröße basierend auf Grad
        node_size = [20 + 0.5 * degrees[n] for n in subgraph.nodes()]
        
        nx.draw_networkx(
            subgraph,
            pos=pos,
            node_size=node_size,
            node_color='lightblue',
            edge_color='gray',
            alpha=0.7,
            width=0.3,
            with_labels=False
        )
        
        # Nur für die Top 20 Knoten Namen anzeigen
        top20 = top_nodes[:20]
        nx.draw_networkx_labels(
            subgraph,
            pos,
            {node: node for node in top20},
            font_size=8,
            font_weight='bold'
        )
        
        plt.title("Teilgraph der Top-100 Superhelden (nach Grad)")
        plt.axis('off')
        plt.tight_layout()
        plt.savefig('top_heroes_network.png', dpi=300, bbox_inches='tight')
        plt.show()
        
    elif method == "largest_component":
        # 2. Visualisierung der größten Zusammenhangskomponente mit ForceAtlas2
        try:
            # Finde die größte Zusammenhangskomponente
            print("Identifiziere größte Zusammenhangskomponente...")
            largest_cc = max(nx.connected_components(G), key=len)
            largest_cc_graph = G.subgraph(largest_cc).copy()
            
            # Wähle zufällig 1000 Knoten aus, wenn die Komponente zu groß ist
            if largest_cc_graph.number_of_nodes() > 1000:
                print("Komponente zu groß für Visualisierung, wähle 1000 zufällige Knoten...")
                nodes = list(largest_cc_graph.nodes())
                np.random.seed(42)
                sampled_nodes = np.random.choice(nodes, 1000, replace=False)
                largest_cc_graph = largest_cc_graph.subgraph(sampled_nodes)
            
            print(f"Berechne Layout für Graphen mit {largest_cc_graph.number_of_nodes()} Knoten...")
            
            # Konvertiere zu NumPy für ForceAtlas2
            A = nx.to_numpy_array(largest_cc_graph)
            nodes = list(largest_cc_graph.nodes())
            
            # ForceAtlas2 Layout
            forceatlas2 = ForceAtlas2(
                outboundAttractionDistribution=True,  
                linLogMode=False,
                adjustSizes=False, 
                edgeWeightInfluence=1.0,
                jitterTolerance=1.0, 
                barnesHutOptimize=True,
                barnesHutTheta=1.2,
                multiThreaded=False
            )
            
            print("Berechne ForceAtlas2-Layout (kann einige Zeit dauern)...")
            positions = forceatlas2.forceatlas2_networkx_layout(largest_cc_graph, pos=None, iterations=100)
            
            # Visualisierung
            plt.figure(figsize=(20, 20))
            
            # Knotengröße basierend auf Degree-Centrality
            centrality = nx.degree_centrality(largest_cc_graph)
            node_size = [3000 * centrality[node] for node in largest_cc_graph.nodes()]
            
            # Knotenfarbe basierend auf Clustering-Koeffizient
            clustering = nx.clustering(largest_cc_graph)
            node_color = [clustering[node] for node in largest_cc_graph.nodes()]
            
            nx.draw_networkx_nodes(
                largest_cc_graph,
                positions,
                node_size=node_size,
                node_color=node_color,
                cmap=plt.cm.viridis,
                alpha=0.8
            )
            
            nx.draw_networkx_edges(
                largest_cc_graph,
                positions,
                width=0.1,
                alpha=0.1,
                edge_color='gray'
            )
            
            # Beschriftungen für die Top-50 Knoten nach Zentralität
            top_centrality = sorted(centrality.items(), key=lambda x: x[1], reverse=True)[:50]
            labels = {node: node for node, _ in top_centrality}
            nx.draw_networkx_labels(
                largest_cc_graph,
                positions,
                labels=labels,
                font_size=8,
                font_weight='bold'
            )
            
            plt.title("Größte Zusammenhangskomponente des Superhelden-Netzwerks")
            plt.axis('off')
            plt.tight_layout()
            plt.savefig('largest_component_network.png', dpi=300, bbox_inches='tight')
            plt.show()
            
        except ImportError:
            print("ForceAtlas2 nicht verfügbar. Verwende Standard-Layout...")
            # Fallback auf standard Spring-Layout
            visualize_hero_network(G, "subset")
        
    elif method == "community":
        # 3. Visualisierung mit Community-Erkennung (auf einem Teilgraphen)
        print("Führe Community-Erkennung auf einem Teilgraphen durch...")
        
        # Verwende einen Teilgraphen von angemessener Größe
        degrees = dict(G.degree())
        top_nodes = sorted(degrees, key=degrees.get, reverse=True)[:500]  # Top 500
        subgraph = G.subgraph(top_nodes)
        
        # Community-Erkennung
        print(f"Erkenne Communities im Teilgraphen mit {subgraph.number_of_nodes()} Knoten...")
        
        try:
            from community import best_partition
            partition = best_partition(subgraph)
            
            # Anzahl der Communities
            communities = set(partition.values())
            print(f"Gefundene Communities: {len(communities)}")
            
            # Visualisierung
            plt.figure(figsize=(20, 20))
            pos = nx.spring_layout(subgraph, seed=42, k=0.3)
            
            # Farbzuordnung für Communities
            cmap = get_cmap('tab20')
            colors = [cmap(i % 20) for i in range(len(communities))]
            
            # Zeichne Knoten mit Community-Farben
            for i, comm in enumerate(communities):
                list_nodes = [node for node, com_id in partition.items() if com_id == comm]
                nx.draw_networkx_nodes(
                    subgraph,
                    pos,
                    nodelist=list_nodes,
                    node_color=[colors[i]] * len(list_nodes),
                    node_size=[100 + 10 * degrees[node] for node in list_nodes],
                    alpha=0.8,
                    label=f"Community {i+1}"
                )
            
            # Zeichne Kanten
            nx.draw_networkx_edges(
                subgraph,
                pos,
                width=0.2,
                alpha=0.2,
                edge_color='gray'
            )
            
            # Beschriftungen für die Top-50 Knoten nach Grad
            top_degree = sorted(degrees.items(), key=lambda x: x[1], reverse=True)[:50]
            top_nodes = [node for node, _ in top_degree if node in subgraph.nodes()]
            labels = {node: node for node in top_nodes}
            nx.draw_networkx_labels(
                subgraph,
                pos,
                labels=labels,
                font_size=8,
                font_weight='bold'
            )
            
            plt.title("Superhelden-Netzwerk mit Community-Struktur (Top 500 Knoten)")
            plt.axis('off')
            plt.legend(scatterpoints=1, loc='lower left')
            plt.tight_layout()
            plt.savefig('community_network.png', dpi=300, bbox_inches='tight')
            plt.show()
            
        except ImportError:
            print("Community-Erkennungspaket nicht verfügbar. Verwende einfachere Visualisierung...")
            visualize_hero_network(G, "subset")
    
    else:
        print(f"Unbekannte Methode: {method}. Verwende 'subset' stattdessen.")
        visualize_hero_network(G, "subset")


def create_2d_visualization_grid(G):
    """Erstellt ein 2x2-Grid mit verschiedenen Visualisierungen."""
    plt.figure(figsize=(20, 20))
    
    # 1. Subgraph der Top-100 Knoten nach Grad
    degrees = dict(G.degree())
    top_nodes = sorted(degrees, key=degrees.get, reverse=True)[:100]
    subgraph = G.subgraph(top_nodes)
    
    # Spring Layout für alle Visualisierungen verwenden
    pos = nx.spring_layout(subgraph, seed=42)
    
    # Plot 1: Grundvisualisierung mit Knotengröße nach Grad
    plt.subplot(2, 2, 1)
    node_size = [20 + 0.5 * degrees[n] for n in subgraph.nodes()]
    nx.draw_networkx(
        subgraph,
        pos=pos,
        node_size=node_size,
        node_color='lightblue',
        edge_color='gray',
        alpha=0.7,
        width=0.3,
        with_labels=False
    )
    
    # Nur für die Top 10 Knoten Namen anzeigen
    top10 = top_nodes[:10]
    nx.draw_networkx_labels(
        subgraph,
        pos,
        {node: node for node in top10},
        font_size=8,
        font_weight='bold'
    )
    plt.title("Top-100 Superhelden nach Anzahl der Verbindungen")
    plt.axis('off')
    
    # Plot 2: Betweenness Centrality
    plt.subplot(2, 2, 2)
    betweenness = nx.betweenness_centrality(subgraph)
    node_color = [betweenness[n] for n in subgraph.nodes()]
    nx.draw_networkx(
        subgraph,
        pos=pos,
        node_size=node_size,
        node_color=node_color,
        cmap=plt.cm.YlOrRd,
        edge_color='gray',
        alpha=0.7,
        width=0.3,
        with_labels=False
    )
    
    # Top 10 nach Betweenness
    top_betweenness = sorted(betweenness.items(), key=lambda x: x[1], reverse=True)[:10]
    top_betweenness_nodes = [node for node, _ in top_betweenness]
    nx.draw_networkx_labels(
        subgraph,
        pos,
        {node: node for node in top_betweenness_nodes},
        font_size=8,
        font_weight='bold'
    )
    plt.title("Betweenness Centrality (Brücken im Netzwerk)")
    plt.axis('off')
    
    # Plot 3: Clustering Coefficient
    plt.subplot(2, 2, 3)
    clustering = nx.clustering(subgraph)
    node_color = [clustering[n] for n in subgraph.nodes()]
    nx.draw_networkx(
        subgraph,
        pos=pos,
        node_size=node_size,
        node_color=node_color,
        cmap=plt.cm.Blues,
        edge_color='gray',
        alpha=0.7,
        width=0.3,
        with_labels=False
    )
    
    # Top 10 nach Clustering
    top_clustering = sorted(clustering.items(), key=lambda x: x[1], reverse=True)[:10]
    top_clustering_nodes = [node for node, _ in top_clustering]
    nx.draw_networkx_labels(
        subgraph,
        pos,
        {node: node for node in top_clustering_nodes},
        font_size=8,
        font_weight='bold'
    )
    plt.title("Clustering Coefficient (Dichte lokaler Verbindungen)")
    plt.axis('off')
    
    # Plot 4: Versuche Community-Erkennung
    plt.subplot(2, 2, 4)
    try:
        from community import best_partition
        partition = best_partition(subgraph)
        communities = set(partition.values())
        node_color = [partition[n] for n in subgraph.nodes()]
        
        nx.draw_networkx(
            subgraph,
            pos=pos,
            node_size=node_size,
            node_color=node_color,
            cmap=plt.cm.tab20,
            edge_color='gray',
            alpha=0.7,
            width=0.3,
            with_labels=False
        )
        plt.title(f"Community-Struktur ({len(communities)} Communities)")
    except ImportError:
        # Alternative: Eigenvektor-Zentralität
        eigenvector = nx.eigenvector_centrality_numpy(subgraph)
        node_color = [eigenvector[n] for n in subgraph.nodes()]
        nx.draw_networkx(
            subgraph,
            pos=pos,
            node_size=node_size,
            node_color=node_color,
            cmap=plt.cm.plasma,
            edge_color='gray',
            alpha=0.7,
            width=0.3,
            with_labels=False
        )
        
        # Top 10 nach Eigenvektor-Zentralität
        top_eigenvector = sorted(eigenvector.items(), key=lambda x: x[1], reverse=True)[:10]
        top_eigenvector_nodes = [node for node, _ in top_eigenvector]
        nx.draw_networkx_labels(
            subgraph,
            pos,
            {node: node for node in top_eigenvector_nodes},
            font_size=8,
            font_weight='bold'
        )
        plt.title("Eigenvektor-Zentralität (Einfluss im Netzwerk)")
    plt.axis('off')
    
    plt.tight_layout()
    plt.savefig('hero_network_analysis_grid.png', dpi=300, bbox_inches='tight')
    plt.show()


def create_heatmap_visualization(G):
    """Erstellt eine Heatmap der Adjazenzmatrix für einen Teilgraphen."""
    # Wähle einen Teilgraphen der Top-50 Knoten
    degrees = dict(G.degree())
    top_nodes = sorted(degrees, key=degrees.get, reverse=True)[:50]
    subgraph = G.subgraph(top_nodes)
    
    # Erstelle Adjazenzmatrix
    adj_matrix = nx.to_numpy_array(subgraph)
    
    # Knotennamen für die Achsenbeschriftung
    nodes_list = list(subgraph.nodes())
    
    plt.figure(figsize=(15, 15))
    plt.imshow(adj_matrix, cmap='Blues', interpolation='nearest')
    
    # Achsenbeschriftungen mit Knotennamen (gekürzt)
    shortened_names = [name[:15] + "..." if len(name) > 15 else name for name in nodes_list]
    plt.xticks(range(len(nodes_list)), shortened_names, rotation=90, fontsize=8)
    plt.yticks(range(len(nodes_list)), shortened_names, fontsize=8)
    
    plt.title("Adjazenzmatrix der Top-50 Superhelden")
    plt.colorbar(label="Verbindungsstärke")
    plt.tight_layout()
    plt.savefig('hero_adjacency_heatmap.png', dpi=300, bbox_inches='tight')
    plt.show()


# Hauptfunktion, die alle Visualisierungen erstellt
def visualize_full_hero_network(G):
    """Erstellt verschiedene Visualisierungen des Superhelden-Netzwerks."""
    print("Erstelle verschiedene Visualisierungen des Superhelden-Netzwerks...\n")
    
    # 1. Visualisierung eines Teilgraphen
    print("Visualisierung 1: Teilgraph der wichtigsten Superhelden")
    visualize_hero_network(G, "subset")
    
    # 2. Grid mit verschiedenen Zentralitätsmaßen
    print("\nVisualisierung 2: Analyseraster mit verschiedenen Metriken")
    create_2d_visualization_grid(G)
    
    # 3. Heatmap-Visualisierung
    print("\nVisualisierung 3: Heatmap der Adjazenzmatrix")
    create_heatmap_visualization(G)
    
    # 4. Versuch der ForceAtlas2-Visualisierung (wenn verfügbar)
    try:
        print("\nVisualisierung 4: Fortgeschrittene Visualisierung mit ForceAtlas2")
        visualize_hero_network(G, "largest_component")
    except Exception as e:
        print(f"ForceAtlas2-Visualisierung fehlgeschlagen: {e}")
    
    # 5. Community-Visualisierung (wenn verfügbar)
    try:
        print("\nVisualisierung 5: Community-Struktur des Netzwerks")
        visualize_hero_network(G, "community")
    except Exception as e:
        print(f"Community-Visualisierung fehlgeschlagen: {e}")
    
    print("\nAlle Visualisierungen abgeschlossen und gespeichert!")


# Beispielaufruf, wenn dieses Skript direkt ausgeführt wird
if __name__ == "__main__":
    # Lade das Netzwerk (falls es noch nicht geladen wurde)
    try:
        # Versuche zuerst, einen vorhandenen Graphen zu laden
        import pickle
        with open(os.path.join("data","hero_network.pickle"), "rb") as f:
            G = pickle.load(f)
        print("Netzwerk aus Pickle-Datei geladen.")
    except:
        # Falls kein gespeicherter Graph existiert, erstelle einen neuen
        print("Erstelle Netzwerk aus CSV-Datei...")
        
        # Code zum Laden und Erstellen des Netzwerks hier einfügen...
        # z.B.:
        import pandas as pd
        df = pd.read_csv('hero-network.csv')
        G = nx.Graph()
        for _, row in df.iterrows():
            G.add_edge(row['hero1'], row['hero2'])
        
        print(f"Netzwerk erstellt mit {G.number_of_nodes()} Knoten und {G.number_of_edges()} Kanten.")
    
    # Erstelle Visualisierungen
    visualize_full_hero_network(G)

Netzwerk aus Pickle-Datei geladen.
Erstelle verschiedene Visualisierungen des Superhelden-Netzwerks...

Visualisierung 1: Teilgraph der wichtigsten Superhelden
Visualisiere Netzwerk mit Methode: subset
Erstelle Teilgraph basierend auf Knotengrad...
Teilgraph erstellt mit 100 Knoten und 4325 Kanten

Visualisierung 2: Analyseraster mit verschiedenen Metriken

Visualisierung 3: Heatmap der Adjazenzmatrix

Visualisierung 4: Fortgeschrittene Visualisierung mit ForceAtlas2
Visualisiere Netzwerk mit Methode: largest_component
Identifiziere größte Zusammenhangskomponente...
Komponente zu groß für Visualisierung, wähle 1000 zufällige Knoten...
Berechne Layout für Graphen mit 1000 Knoten...
Berechne ForceAtlas2-Layout (kann einige Zeit dauern)...
ForceAtlas2-Visualisierung fehlgeschlagen: module 'networkx' has no attribute 'to_scipy_sparse_matrix'

Visualisierung 5: Community-Struktur des Netzwerks
Visualisiere Netzwerk mit Methode: community
Führe Community-Erkennung auf einem Teilgraphen durch...
Erkenne Communities im Teilgraphen mit 500 Knoten...
Community-Erkennungspaket nicht verfügbar. Verwende einfachere Visualisierung...
Visualisiere Netzwerk mit Methode: subset
Erstelle Teilgraph basierend auf Knotengrad...
Teilgraph erstellt mit 100 Knoten und 4325 Kanten

Alle Visualisierungen abgeschlossen und gespeichert!

FMCA-25 05: Arbeiten mit Daten: Vorbereitung, Visualisierung, Analyse

Inhalt des Skriptums seit dem Sommersemester 2025

Hier finden Sie die Kapitel aus den Vergangenen Jahren (legacy):

Die Jupyter-Notebooks zur Legacy-Variante der Lehrveranstaltung finden Sie im zugehörigen GitHub-Repository.

5 Arbeiten mit Daten: Vorbereitung, Visualisierung, Analyse¶

In dieser Einheit werden wir uns mit einem zentralen Aspekt Ihrer Arbeit und unser aller Gegenwart und Zukunft befassen: Der Arbeit mit realen Datensätzen. Die Fähigkeit, Daten effizient einzulesen, zu analysieren und zu visualisieren, ist heute in nahezu allen wissenschaftlichen und wirtschaftlichen Bereichen von grundlegender Bedeutung. Ganz zu schweigen davon, dass die Arbeit mit Daten unglaublich viel Spaß macht. Lassen Sie uns also gleich damit beginnen.

Nach dem Studium dieser Einheit sollten Sie zumindest folgende drei der wichtigsten Punkte hier verstehen:¶

Die gute Vor- und Aufbereitung der Daten ist essentiell. In der Praxis steht und fällt Ihre spätere Analyse eines Datensatzes mit der Sorgfalt der Vorbereitung. Ebenso ist dieser Teil oft der Arbeits-intensivste.
Die Macht der Visualisierung wird Ihnen helfen, mögliche Zusammenhänge und Muster in Daten zu erkennen, die man in einer Tabelle mit Zahlen niemals sehen würde. Die Welt der Visualisierung ist vielfältig und faszinierend.
Kombinierte Analysemethoden helfen Ihnen dabei, auch komplexe Datensätze umfassend zu verstehen. Dabei fügt man vor der Visualisierung noch geeignete spezielle Analyseschritte ein, die helfen, mögliche Strukturen ans Licht zu bringen.

In dieser Einheit werden wir mit einem realen Datensatz zu Erdbeben arbeiten. Es handelt sich dabei um Ort und Zeit sowie Magnitude (und noch einige Informationen mehr) der Erdbeben mit $M>5.5$ von 1965 bis 2016. Die Quelle für diesen Datensatz ist eine Plattform namens Kaggle, auf der Machine-Learning-Wettbewerbe ausgetragen werden. Der spezielle Datensatz kommt von hier: https://www.kaggle.com/datasets/usgs/earthquake-database. Für uns sind diese Daten eine hervorragende Grundlage, um verschiedene Datenverarbeitungs- und Visualisierungstechniken zu demonstrieren.

Die Code-Snippets und Beispiele in dieser Einheit stammen in bewährter Manier von Claude 3.7 Sonnet, wenn auch mit etwas mehr zwischenzeitlicher und nachträglicher menschlicher Intervention als bisher.

5.1 Daten Einlesen und erste Analyse und Aufbereitung¶

Der erste Schritt bei jeder Datenanalyse besteht darin, die Daten einzulesen und sich einen Überblick über ihre Struktur und Qualität zu verschaffen. Dieser Prozess ist entscheidend, da er die Grundlage für alle weiteren Analyseschritte bildet.

5.1.1 Einlesen von csv Dateien in Python mit Pandas¶

Comma-Separated Values (CSV) ist eines der am häufigsten verwendeten Formate für den Austausch tabellarischer Daten. Die Python-Bibliothek Pandas bietet leistungsstarke und hochoptimierte Funktionen zum Einlesen, Verarbeiten und Analysieren solcher Daten, in weiterer Folge auch als NumPy-Array.

Zunächst importieren wir die benötigten Bibliotheken:

In [1]:

# Import der grundlegenden Bibliotheken für Datenanalyse und Visualisierung
import pandas as pd  # Für Datenverarbeitung und -analyse
import numpy as np   # Für numerische Berechnungen
import matplotlib.pyplot as plt  # Für Visualisierungen
import seaborn as sns  # Für erweiterte statistische Visualisierungen
import os # Für Zugriff auf das Dateisystem

# Anpassung der Darstellung
sns.set_theme(style="whitegrid")  # Setzt den seaborn whitegrid-Stil 
plt.rcParams['figure.figsize'] = (12, 8)  # Setzt die Standardgröße für Plots
plt.rcParams['font.size'] = 12  # Setzt die Standardschriftgröße

Nun können wir den Erdbeben-Datensatz einlesen. Wir verwenden die read_csv()-Funktion von Pandas, die im Prinzip auch eine Vielzahl von Parametern bietet, um den Einleseprozess anzupassen, die wir hier aber erst einmal nicht nutzen, sondern den Datensatz einfach so einlesen, wie er ist:

In [2]:

# Pfad zur CSV-Datei
file_path = os.path.join('data','earthquake_database.csv')  # Pfad anpassen, falls nötig

# Einlesen der Daten mit Pandas (ohne Datum/Zeit zu kombinieren)
earthquakes = pd.read_csv(file_path)

# Kombinieren von Datum und Zeit nach dem Einlesen
if 'Date' in earthquakes.columns and 'Time' in earthquakes.columns:
    # Datum und Zeit zu einem String kombinieren und dann in datetime umwandeln
    earthquakes['Date_Time'] = pd.to_datetime(earthquakes['Date'] + ' ' + earthquakes['Time'], errors='coerce')

# Überprüfen, ob die Daten korrekt eingelesen wurden
print(f"Datensatz erfolgreich eingelesen: {len(earthquakes)} Einträge gefunden.")

Datensatz erfolgreich eingelesen: 23412 Einträge gefunden.

5.1.2 Anzeigen der Datenstruktur und von Teilen der Daten¶

Nachdem wir den Datensatz eingelesen haben, ist es hilfreich, einen ersten Überblick über dessen Struktur und Inhalt zu gewinnen. Pandas bietet dafür verschiedene Methoden:

head(n): Zeigt die ersten n Zeilen des Datensatzes, Standardwert ist 5
tail(n): Zeigt die letzten n Zeilen des Datensatzes, Standardwert ist wieder 5
info(): Gibt Informationen über die Datentypen und fehlende Werte
describe(): Liefert grundlegende statistische Kennzahlen für numerische Spalten

In [3]:

# Anzeige der ersten Zeilen des Datensatzes
print("Die ersten 5 Einträge des Datensatzes:")
display(earthquakes.head())

# Anzeige der letzten Zeilen des Datensatzes
print("\nDie letzten 5 Einträge des Datensatzes:")
display(earthquakes.tail())

# Informationen über den Datensatz
print("\nInformationen zur Struktur des Datensatzes:")
earthquakes.info()

# Grundlegende statistische Kennzahlen
print("\nStatistische Übersicht der numerischen Spalten:")
display(earthquakes.describe())

# Anzeigen aller Spaltennamen
print("\nVerfügbare Spalten im Datensatz:")
for i, column in enumerate(earthquakes.columns):
    print(f"{i+1}. {column}")

Die ersten 5 Einträge des Datensatzes:

	Date	Time	Latitude	Longitude	Type	Depth	Depth Error	Depth Seismic Stations	Magnitude	Magnitude Type	…	Azimuthal Gap	Horizontal Distance	Horizontal Error	Root Mean Square	ID	Source	Location Source	Magnitude Source	Status	Date_Time
0	01/02/1965	13:44:18	19.246	145.616	Earthquake	131.6	NaN	NaN	6.0	MW	…	NaN	NaN	NaN	NaN	ISCGEM860706	ISCGEM	ISCGEM	ISCGEM	Automatic	1965-01-02 13:44:18
1	01/04/1965	11:29:49	1.863	127.352	Earthquake	80.0	NaN	NaN	5.8	MW	…	NaN	NaN	NaN	NaN	ISCGEM860737	ISCGEM	ISCGEM	ISCGEM	Automatic	1965-01-04 11:29:49
2	01/05/1965	18:05:58	-20.579	-173.972	Earthquake	20.0	NaN	NaN	6.2	MW	…	NaN	NaN	NaN	NaN	ISCGEM860762	ISCGEM	ISCGEM	ISCGEM	Automatic	1965-01-05 18:05:58
3	01/08/1965	18:49:43	-59.076	-23.557	Earthquake	15.0	NaN	NaN	5.8	MW	…	NaN	NaN	NaN	NaN	ISCGEM860856	ISCGEM	ISCGEM	ISCGEM	Automatic	1965-01-08 18:49:43
4	01/09/1965	13:32:50	11.938	126.427	Earthquake	15.0	NaN	NaN	5.8	MW	…	NaN	NaN	NaN	NaN	ISCGEM860890	ISCGEM	ISCGEM	ISCGEM	Automatic	1965-01-09 13:32:50

5 rows × 22 columns

Die letzten 5 Einträge des Datensatzes:

	Date	Time	Latitude	Longitude	Type	Depth	Depth Error	Depth Seismic Stations	Magnitude	Magnitude Type	…	Azimuthal Gap	Horizontal Distance	Horizontal Error	Root Mean Square	ID	Source	Location Source	Magnitude Source	Status	Date_Time
23407	12/28/2016	08:22:12	38.3917	-118.8941	Earthquake	12.30	1.2	40.0	5.6	ML	…	42.47	0.120	NaN	0.1898	NN00570710	NN	NN	NN	Reviewed	2016-12-28 08:22:12
23408	12/28/2016	09:13:47	38.3777	-118.8957	Earthquake	8.80	2.0	33.0	5.5	ML	…	48.58	0.129	NaN	0.2187	NN00570744	NN	NN	NN	Reviewed	2016-12-28 09:13:47
23409	12/28/2016	12:38:51	36.9179	140.4262	Earthquake	10.00	1.8	NaN	5.9	MWW	…	91.00	0.992	4.8	1.5200	US10007NAF	US	US	US	Reviewed	2016-12-28 12:38:51
23410	12/29/2016	22:30:19	-9.0283	118.6639	Earthquake	79.00	1.8	NaN	6.3	MWW	…	26.00	3.553	6.0	1.4300	US10007NL0	US	US	US	Reviewed	2016-12-29 22:30:19
23411	12/30/2016	20:08:28	37.3973	141.4103	Earthquake	11.94	2.2	NaN	5.5	MB	…	97.00	0.681	4.5	0.9100	US10007NTD	US	US	US	Reviewed	2016-12-30 20:08:28

5 rows × 22 columns

Informationen zur Struktur des Datensatzes:
<class 'pandas.core.frame.DataFrame'>
RangeIndex: 23412 entries, 0 to 23411
Data columns (total 22 columns):
 #   Column                      Non-Null Count  Dtype         
---  ------                      --------------  -----         
 0   Date                        23412 non-null  object        
 1   Time                        23412 non-null  object        
 2   Latitude                    23412 non-null  float64       
 3   Longitude                   23412 non-null  float64       
 4   Type                        23412 non-null  object        
 5   Depth                       23412 non-null  float64       
 6   Depth Error                 4461 non-null   float64       
 7   Depth Seismic Stations      7097 non-null   float64       
 8   Magnitude                   23412 non-null  float64       
 9   Magnitude Type              23409 non-null  object        
 10  Magnitude Error             327 non-null    float64       
 11  Magnitude Seismic Stations  2564 non-null   float64       
 12  Azimuthal Gap               7299 non-null   float64       
 13  Horizontal Distance         1604 non-null   float64       
 14  Horizontal Error            1156 non-null   float64       
 15  Root Mean Square            17352 non-null  float64       
 16  ID                          23412 non-null  object        
 17  Source                      23412 non-null  object        
 18  Location Source             23412 non-null  object        
 19  Magnitude Source            23412 non-null  object        
 20  Status                      23412 non-null  object        
 21  Date_Time                   23412 non-null  datetime64[ns]
dtypes: datetime64[ns](1), float64(12), object(9)
memory usage: 3.9+ MB

Statistische Übersicht der numerischen Spalten:

	Latitude	Longitude	Depth	Depth Error	Depth Seismic Stations	Magnitude	Magnitude Error	Magnitude Seismic Stations	Azimuthal Gap	Horizontal Distance	Horizontal Error	Root Mean Square	Date_Time
count	23412.000000	23412.000000	23412.000000	4461.000000	7097.000000	23412.000000	327.000000	2564.000000	7299.000000	1604.000000	1156.000000	17352.000000	23412
mean	1.679033	39.639961	70.767911	4.993115	275.364098	5.882531	0.071820	48.944618	44.163532	3.992660	7.662759	1.022784	1993-02-18 09:25:46.351700096
min	-77.080000	-179.997000	-1.100000	0.000000	0.000000	5.500000	0.000000	0.000000	0.000000	0.004505	0.085000	0.000000	1965-01-02 13:44:18
25%	-18.653000	-76.349750	14.522500	1.800000	146.000000	5.600000	0.046000	10.000000	24.100000	0.968750	5.300000	0.900000	1981-04-11 02:19:14.250000
50%	-3.568500	103.982000	33.000000	3.500000	255.000000	5.700000	0.059000	28.000000	36.000000	2.319500	6.700000	1.000000	1993-11-30 20:40:43
75%	26.190750	145.026250	54.000000	6.300000	384.000000	6.000000	0.075500	66.000000	54.000000	4.724500	8.100000	1.130000	2005-09-09 21:17:39.500000
max	86.005000	179.998000	700.000000	91.295000	934.000000	9.100000	0.410000	821.000000	360.000000	37.874000	99.000000	3.440000	2016-12-30 20:08:28
std	30.113183	125.511959	122.651898	4.875184	162.141631	0.423066	0.051466	62.943106	32.141486	5.377262	10.430396	0.188545	NaN

Verfügbare Spalten im Datensatz:
1. Date
2. Time
3. Latitude
4. Longitude
5. Type
6. Depth
7. Depth Error
8. Depth Seismic Stations
9. Magnitude
10. Magnitude Type
11. Magnitude Error
12. Magnitude Seismic Stations
13. Azimuthal Gap
14. Horizontal Distance
15. Horizontal Error
16. Root Mean Square
17. ID
18. Source
19. Location Source
20. Magnitude Source
21. Status
22. Date_Time

5.1.3 Checken der Einträge, Auflistung der Werte und Überprüfung auf Lücken¶

Ein entscheidender Schritt bei der Datenaufbereitung ist die Identifikation und Behandlung fehlender oder ungültiger Werte. Unbehandelte Datenlücken können zu fehlerhaften Analysen und Schlussfolgerungen führen. Zunächst überprüfen wir, ob und in welchem Umfang fehlende Werte im Datensatz vorhanden sind:

In [4]:

# Überprüfung auf fehlende Werte in jeder Spalte
missing_values = earthquakes.isnull().sum()

# Berechnung des prozentualen Anteils fehlender Werte
missing_percentage = (missing_values / len(earthquakes)) * 100

# Zusammenfassung in einem DataFrame
missing_data = pd.DataFrame({
    'Fehlende Werte': missing_values,
    'Prozent fehlend': missing_percentage.round(2)
})

# Sortieren nach der Anzahl fehlender Werte (absteigend)
missing_data = missing_data.sort_values('Fehlende Werte', ascending=False)

print("Überblick über fehlende Werte im Datensatz:")
display(missing_data)

# Visualisierung fehlender Werte (nur für die Top-10-Spalten mit den meisten fehlenden Werten)
plt.figure(figsize=(12, 6))
sns.barplot(x=missing_data.index[:10], y='Prozent fehlend', data=missing_data[:10])
plt.title('Prozentsatz fehlender Werte nach Spalte (Top 10)')
plt.xticks(rotation=45, ha='right')
plt.ylabel('Prozent fehlend')
plt.tight_layout()
plt.show()

# Überprüfung der Verteilung von kategorialen Werten in der Spalte "Type"
if 'Type' in earthquakes.columns:
    print("\nVerteilung der Ereignistypen:")
    display(earthquakes['Type'].value_counts())

# Überprüfung der Verteilung von kategorialen Werten in der Spalte "Magnitude Type"
if 'Magnitude Type' in earthquakes.columns:
    print("\nVerteilung der Magnitude-Typen:")
    display(earthquakes['Magnitude Type'].value_counts())

# Überprüfung der Verteilung von kategorialen Werten in der Spalte "Status"
if 'Status' in earthquakes.columns:
    print("\nVerteilung der Status-Werte:")
    display(earthquakes['Status'].value_counts())

Überblick über fehlende Werte im Datensatz:

	Fehlende Werte	Prozent fehlend
Magnitude Error	23085	98.60
Horizontal Error	22256	95.06
Horizontal Distance	21808	93.15
Magnitude Seismic Stations	20848	89.05
Depth Error	18951	80.95
Depth Seismic Stations	16315	69.69
Azimuthal Gap	16113	68.82
Root Mean Square	6060	25.88
Magnitude Type	3	0.01
Status	0	0.00
Magnitude Source	0	0.00
Location Source	0	0.00
Source	0	0.00
ID	0	0.00
Date	0	0.00
Time	0	0.00
Magnitude	0	0.00
Depth	0	0.00
Type	0	0.00
Longitude	0	0.00
Latitude	0	0.00
Date_Time	0	0.00

Verteilung der Ereignistypen:

Type
Earthquake           23232
Nuclear Explosion      175
Explosion                4
Rock Burst               1
Name: count, dtype: int64

Verteilung der Magnitude-Typen:

Magnitude Type
MW     7722
MWC    5669
MB     3761
MWB    2458
MWW    1983
MS     1702
ML       77
MWR      26
MD        6
MH        5
Name: count, dtype: int64

Verteilung der Status-Werte:

Status
Reviewed     20773
Automatic     2639
Name: count, dtype: int64

5.1.4 Statistische Plots für numerische Daten, Häufigkeitsplots für andere Datentypen¶

Visualisierungen helfen uns, die Verteilung und Struktur der Daten besser zu verstehen. Wir erstellen verschiedene Plots, um einen tieferen Einblick in die Eigenschaften der Erdbebendaten zu gewinnen:

Histogramme der wichtigsten numerischen Variablen: Diese zeigen die Häufigkeitsverteilung von Werten wie Magnitude und Tiefe.
Box-Plots: Diese verdeutlichen die Verteilung und identifizieren Ausreißer.
Zeitreihenanalyse: Die Verteilung der Erdbeben über die Zeit.

In [5]:

# 1. Histogramm der Magnitude
plt.figure(figsize=(12, 6))
sns.histplot(earthquakes['Magnitude'].dropna(), bins=30, kde=True)
plt.title('Verteilung der Erdbebenmagnitude')
plt.xlabel('Magnitude')
plt.ylabel('Anzahl')
plt.grid(True, alpha=0.3)
plt.show()

# 2. Histogramm der Tiefe
plt.figure(figsize=(12, 6))
# Logarithmische Skala für bessere Sichtbarkeit
sns.histplot(earthquakes['Depth'].dropna(), bins=30, kde=True, log_scale=(False, True))
plt.title('Verteilung der Erdbebenteife (logarithmische Skala)')
plt.xlabel('Tiefe (km)')
plt.ylabel('Anzahl (log)')
plt.grid(True, alpha=0.3)
plt.show()

# 3. Box-Plots für Magnitude und Tiefe
plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
sns.boxplot(y=earthquakes['Magnitude'].dropna())
plt.title('Box-Plot der Magnitude')
plt.ylabel('Magnitude')
plt.grid(True, alpha=0.3)

plt.subplot(1, 2, 2)
sns.boxplot(y=earthquakes['Depth'].dropna())
plt.title('Box-Plot der Tiefe')
plt.ylabel('Tiefe (km)')
plt.grid(True, alpha=0.3)
plt.tight_layout()
plt.show()

# 4. Zeitreihenanalyse - Erdbeben pro Jahr
# Überprüfen, ob die Date_Time-Spalte existiert und im richtigen Format ist
if 'Date_Time' in earthquakes.columns:
    try:
        # Extrahieren des Jahres aus dem Datum
        earthquakes['Year'] = earthquakes['Date_Time'].dt.year
        
        # Zählen der Erdbeben pro Jahr
        yearly_counts = earthquakes['Year'].value_counts().sort_index()
        
        plt.figure(figsize=(14, 6))
        yearly_counts.plot(kind='bar')
        plt.title('Anzahl der Erdbeben pro Jahr')
        plt.xlabel('Jahr')
        plt.ylabel('Anzahl der Erdbeben')
        plt.grid(True, alpha=0.3)
        plt.xticks(rotation=45)
        plt.tight_layout()
        plt.show()
    except Exception as e:
        print(f"Fehler bei der Zeitreihenanalyse: {e}")
        print("Überprüfen Sie das Format der Date_Time-Spalte.")
else:
    print("Die Spalte 'Date_Time' wurde nicht gefunden. Zeitreihenanalyse nicht möglich.")

# 5. Scatter-Plot: Magnitude vs. Tiefe
plt.figure(figsize=(10, 8))
sns.scatterplot(x='Depth', y='Magnitude', data=earthquakes, alpha=0.5)
plt.title('Beziehung zwischen Erdbebenteife und Magnitude')
plt.xlabel('Tiefe (km)')
plt.ylabel('Magnitude')
plt.grid(True, alpha=0.3)
plt.show()

# 6. Korrelationsmatrix für die numerischen Spalten
# Auswahl der numerischen Spalten
numeric_columns = earthquakes.select_dtypes(include=[np.number]).columns.tolist()

if len(numeric_columns) > 1:  # Nur ausführen, wenn mindestens zwei numerische Spalten vorhanden sind
    correlation_matrix = earthquakes[numeric_columns].corr()
    
    plt.figure(figsize=(12, 10))
    sns.heatmap(correlation_matrix, annot=True, cmap='coolwarm', linewidths=0.5)
    plt.title('Korrelationsmatrix der numerischen Variablen')
    plt.tight_layout()
    plt.show()

Hier wird man gleich mit Informationen versorgt, die verschiedene weitere Analyseschritte auslösen oder anregen können. Aber bevor wir weitermachen, werden wir den Datensatz auf jenen Teil beschränken, der kaum Löcher hat und sinnvoll verwendet werden kann. In unserem fall schränken wir zunächst auf die beinahe vollständigen Spalten ein und geben dann die Zeilen aus, für die es Löcher in den Werten gibt.

In [6]:

# Auswahl der relevanten Spalten
selected_columns = ['Date_Time', 'Latitude', 'Longitude', 'Magnitude', 'Depth', 'Type', 'Magnitude Type']
earthquakes_subset = earthquakes[selected_columns]

# Überblick über das reduzierte Dataset
print(f"Reduzierter Datensatz: {earthquakes_subset.shape[0]} Zeilen und {earthquakes_subset.shape[1]} Spalten")

# Überprüfung auf fehlende Werte im reduzierten Datensatz
missing_values = earthquakes_subset.isnull().sum()
print("\nFehlende Werte im reduzierten Datensatz:")
display(missing_values)

# Identifikation der Zeilen mit fehlenden Magnitude Type-Werten
rows_missing_magtype = earthquakes_subset[earthquakes_subset['Magnitude Type'].isnull()]
print("\nZeilen mit fehlenden Magnitude Type-Werten:")
display(rows_missing_magtype)

# Häufigkeitsverteilung der Magnitude Type-Werte
mag_type_counts = earthquakes_subset['Magnitude Type'].value_counts()
print("\nHäufigkeitsverteilung der Magnitude-Typen:")
display(mag_type_counts)

# Häufigkeitsverteilung der Type-Werte
type_counts = earthquakes_subset['Type'].value_counts()
print("\nHäufigkeitsverteilung der Ereignistypen:")
display(type_counts)

Reduzierter Datensatz: 23412 Zeilen und 7 Spalten

Fehlende Werte im reduzierten Datensatz:

Date_Time         0
Latitude          0
Longitude         0
Magnitude         0
Depth             0
Type              0
Magnitude Type    3
dtype: int64

Zeilen mit fehlenden Magnitude Type-Werten:

	Date_Time	Latitude	Longitude	Magnitude	Depth	Type	Magnitude Type
6703	1983-08-24 13:36:00	40.3732	-124.9227	5.70	11.93	Earthquake	NaN
7294	1984-11-23 18:08:00	37.4600	-118.5900	5.82	9.00	Earthquake	NaN
7919	1986-03-31 11:55:00	37.4788	-121.6858	5.60	9.17	Earthquake	NaN

Häufigkeitsverteilung der Magnitude-Typen:

Magnitude Type
MW     7722
MWC    5669
MB     3761
MWB    2458
MWW    1983
MS     1702
ML       77
MWR      26
MD        6
MH        5
Name: count, dtype: int64

Häufigkeitsverteilung der Ereignistypen:

Type
Earthquake           23232
Nuclear Explosion      175
Explosion                4
Rock Burst               1
Name: count, dtype: int64

Hier sieht man die Kontrolle der Lücken und die fehlenden Werte. Aufgrund der Verteilung der Magnitude-Typen ist es vernünftig, die drei fehlenden Werte durch den häufigsten Wert zu ersetzen. Das ist eine gängige Praxis, die wir hier übernehmen, weil wir dadurch auch jene drei Zeilen komplett in alle Analysen einbinden können. Eine Alternative wäre, einen neue Bezeichnung (unknown) einzuführen und so diese Kategorie extra mitzunehmen. Wir belassen es aber der Einfachheit halber dabei, einen vorhandenen Wert zu übernehmen.

In [7]:

# Explizites Erstellen einer Kopie des DataFrames
earthquakes_subset = earthquakes[selected_columns].copy()

# Füllen der fehlenden Magnitude Type-Werte mit 'MW'
earthquakes_subset.loc[:, 'Magnitude Type'] = earthquakes_subset['Magnitude Type'].fillna('MW')

# Überprüfung, ob alle fehlenden Werte gefüllt wurden
missing_values_after = earthquakes_subset.isnull().sum()
print("Fehlende Werte nach der Bereinigung:")
display(missing_values_after)

# Finale Überprüfung der Datenstruktur
print("\nStruktur des bereinigten Datensatzes:")
display(earthquakes_subset.head())

print(f"Der bereinigte Datensatz enthält {len(earthquakes_subset)} Einträge und ist bereit für die weitere Analyse.")

Fehlende Werte nach der Bereinigung:

Date_Time         0
Latitude          0
Longitude         0
Magnitude         0
Depth             0
Type              0
Magnitude Type    0
dtype: int64

Struktur des bereinigten Datensatzes:

	Date_Time	Latitude	Longitude	Magnitude	Depth	Type	Magnitude Type
0	1965-01-02 13:44:18	19.246	145.616	6.0	131.6	Earthquake	MW
1	1965-01-04 11:29:49	1.863	127.352	5.8	80.0	Earthquake	MW
2	1965-01-05 18:05:58	-20.579	-173.972	6.2	20.0	Earthquake	MW
3	1965-01-08 18:49:43	-59.076	-23.557	5.8	15.0	Earthquake	MW
4	1965-01-09 13:32:50	11.938	126.427	5.8	15.0	Earthquake	MW

Der bereinigte Datensatz enthält 23412 Einträge und ist bereit für die weitere Analyse.

5.2 Geographische Visualisierung von Erdbebendaten¶

Nach der Bereinigung und Aufbereitung unserer Daten wenden wir uns nun der geographischen Analyse zu. Erdbeben sind ein globales Phänomen, das eng mit der tektonischen Struktur unseres Planeten verbunden ist. Durch geographische Visualisierungen können wir Muster und Häufungen erkennen, die uns tiefere Einblicke in diese Naturereignisse ermöglichen.

5.2.1 Geographische Verteilung der Erdbeben auf der Erdoberfläche¶

Die Verteilung von Erdbeben auf der Erdoberfläche ist nicht zufällig. Vielmehr folgt sie den Grenzen tektonischer Platten, die als zusammenhängende Stücke der Erdkruste und des oberen Erdmantels unseren Planeten bedecken. An diesen Plattengrenzen entstehen die meisten Erdbeben, wenn Platten aneinander reiben, unter- oder übereinander gleiten.

Um diese Zusammenhänge zu visualisieren, erstellen wir verschiedene Darstellungen der globalen Erdbebenverteilung. Dabei werden wir die Erdbeben nach Magnitude und anderen Eigenschaften differenzieren, um zusätzliche Informationsebenen in unsere Visualisierungen einzubringen.

In [8]:

# Import der benötigten Bibliotheken
import matplotlib.pyplot as plt
import numpy as np
import seaborn as sns

# Stil für verbesserte Ästhetik setzen
sns.set_theme(style="whitegrid")

# Welt-Plot der Erdbeben erstellen
plt.figure(figsize=(14, 8))

# Hintergrund einfügen für visuellen Kontext
# Dies ist ein vereinfachter Ansatz, da wir keine Basemap verwenden können
# Wir erstellen ein transparent blaues Rechteck als "Ozean"
plt.axhspan(-90, 90, facecolor='lightblue', alpha=0.3, zorder=0)

# Scatterplot der Erdbeben
scatter = plt.scatter(
    earthquakes_subset['Longitude'], 
    earthquakes_subset['Latitude'],
    c=earthquakes_subset['Magnitude'],
    s=earthquakes_subset['Magnitude']**1.5,  # Größe basierend auf Magnitude
    alpha=0.6,
    cmap='YlOrRd',
    edgecolor='k',
    linewidth=0.2,
    zorder=2
)

# Grenzen und Beschriftungen
plt.xlim(-180, 180)
plt.ylim(-90, 90)
plt.grid(True, alpha=0.3, zorder=1)
plt.xlabel('Längengrad', fontsize=12)
plt.ylabel('Breitengrad', fontsize=12)
plt.title('Globale Verteilung von Erdbeben', fontsize=16)

# Farbbalken hinzufügen
cbar = plt.colorbar(scatter, extend='both', pad=0.01)
cbar.set_label('Magnitude (Richter-Skala)', fontsize=12)

# Anmerkung zur Datensatzgröße
plt.annotate(f'Datensatz umfasst {len(earthquakes_subset)} Erdbebenereignisse', 
             xy=(0.01, 0.01), xycoords='figure fraction', fontsize=10)


plt.tight_layout()
plt.show()

In [9]:

# Erstellen einer Heatmap der Erdbebenintensität mit Matplotlib
import matplotlib.pyplot as plt
import numpy as np
from scipy.stats import gaussian_kde
import seaborn as sns

# Für bessere Ästhetik
sns.set_theme(style="white")

plt.figure(figsize=(14, 8))

# Hintergrund einfügen für visuellen Kontext
plt.axhspan(-90, 90, facecolor='lightblue', alpha=0.3, zorder=0)

# Daten vorbereiten
# Wir verwenden nur eine Stichprobe für eine effizientere Berechnung der KDE
sample_size = min(5000, len(earthquakes_subset))
sampled_data = earthquakes_subset.sample(sample_size, random_state=42)

# Daten für die heatmap
x = sampled_data['Longitude']
y = sampled_data['Latitude']
weights = sampled_data['Magnitude'] ** 2  # Quadrierung für stärkere Betonung höherer Magnituden

# Punkte für das Hintergrundraster erstellen
x_grid, y_grid = np.mgrid[-180:180:360j, -90:90:180j]
positions = np.vstack([x_grid.ravel(), y_grid.ravel()])

# Kerneldichteberechnung mit Gewichten
kde = gaussian_kde(np.vstack([x, y]), weights=weights)
z = kde(positions)

# Umformen für Plotting
z = z.reshape(x_grid.shape)

# Heatmap zeichnen
plt.contourf(x_grid, y_grid, z, levels=50, cmap='inferno', alpha=0.7, zorder=1)

# Grenzen und Beschriftungen
plt.xlim(-180, 180)
plt.ylim(-90, 90)
plt.grid(True, alpha=0.3, zorder=0)
plt.xlabel('Längengrad', fontsize=12)
plt.ylabel('Breitengrad', fontsize=12)
plt.title('Heatmap der globalen Erdbebenintensität', fontsize=16)

# Beschreibung hinzufügen
plt.annotate('Höhere Intensität zeigt Regionen mit stärkerer seismischer Aktivität', 
            xy=(0.5, 0.02), xycoords='figure fraction', 
            ha='center', fontsize=11, bbox=dict(facecolor='white', alpha=0.7))

plt.tight_layout()
plt.show()

5.2.2 Dreidimensionale Visualisierung unter Berücksichtigung der Bebentiefe¶

Während die zweidimensionale Darstellung der Erdbeben auf der Erdoberfläche bereits wertvolle Erkenntnisse liefert, bietet eine dreidimensionale Betrachtung zusätzliche Einblicke. Die Tiefe, in der ein Erdbeben stattfindet, ist ein entscheidender Parameter, der Hinweise auf die tektonischen Prozesse gibt, die das Beben verursacht haben.

Flache Erdbeben (weniger als 70 km Tiefe) treten typischerweise an Spreizungszonen oder Transformstörungen auf. Mittlere Erdbeben (70-300 km) und tiefe Erdbeben (300-700 km) sind hingegen charakteristisch für Subduktionszonen, wo eine tektonische Platte unter eine andere abtaucht.

Im Folgenden erstellen wir verschiedene dreidimensionale Visualisierungen, um diese räumliche Dimension der Erdbebendaten zu erfassen. Dies ermöglicht uns, die tektonischen Strukturen unterhalb der Erdoberfläche besser zu verstehen.

In [10]:

# 3D-Visualisierung mit Standard-Matplotlib
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.colors as mcolors
import pandas as pd

# Filtern der Daten für bessere Sichtbarkeit (nur stärkere Erdbeben)
strong_earthquakes = earthquakes_subset[earthquakes_subset['Magnitude'] > 5.5].copy()

# Falls der Datensatz sehr groß ist, Sample nehmen
if len(strong_earthquakes) > 2000:
    strong_earthquakes = strong_earthquakes.sample(2000, random_state=42)

# Jahr aus dem Date_Time-Feld extrahieren für Farbcodierung
strong_earthquakes['Year'] = strong_earthquakes['Date_Time'].dt.year

# Farbskala vorbereiten
min_year = strong_earthquakes['Year'].min()
max_year = strong_earthquakes['Year'].max()
norm = mcolors.Normalize(min_year, max_year)
cmap = plt.cm.viridis

# 3D-Plot erstellen
fig = plt.figure(figsize=(12, 10))
ax = fig.add_subplot(111, projection='3d')

# Daten plotten
scatter = ax.scatter(
    strong_earthquakes['Longitude'],
    strong_earthquakes['Latitude'],
    -strong_earthquakes['Depth'],  # Minus für korrekte Darstellung unter der Oberfläche
    c=strong_earthquakes['Year'],
    cmap=cmap,
    norm=norm,
    s=strong_earthquakes['Magnitude']**2 * 0.5,
    alpha=0.7,
    edgecolor='k',
    linewidth=0.2
)

# Achsenbeschriftung
ax.set_xlabel('Längengrad', fontsize=12)
ax.set_ylabel('Breitengrad', fontsize=12)
ax.set_zlabel('Tiefe (km)', fontsize=12)

# Farbbalken für das Jahr
cbar = fig.colorbar(scatter, shrink=0.6, aspect=20)
cbar.set_label('Jahr des Erdbebens', fontsize=12)

# Legende für Magnitudenskala erstellen
from matplotlib.lines import Line2D
legend_elements = [
    Line2D([0], [0], marker='o', color='w', markerfacecolor='gray', 
           label=f'Magnitude {mag}', markersize=np.sqrt(mag**2 * 0.5), 
           markeredgecolor='k', markeredgewidth=0.2, alpha=0.7)
    for mag in [6.0, 7.0, 8.0]
]
ax.legend(handles=legend_elements, loc='upper right', title='Magnitude')

# Tiefenskala anpassen und Orientierung verbessern
ax.set_zlim(-700, 0)  # Typische Erdbebengrenze bei ca. 700 km
ax.view_init(elev=30, azim=45)  # Perspektive anpassen

# Einfache "Erdoberfläche" als Referenz hinzufügen
# Wir verwenden ein vereinfachtes Gitter
max_lon, min_lon = 180, -180
max_lat, min_lat = 90, -90
xx, yy = np.meshgrid([min_lon, max_lon], [min_lat, max_lat])
zz = np.zeros(xx.shape)
ax.plot_surface(xx, yy, zz, alpha=0.1, color='lightblue')

# Titel
ax.set_title('3D-Visualisierung von Erdbeben (Magnitude > 5.5)', fontsize=14)

plt.tight_layout()
plt.show()

In [11]:

# Funktion für die regionale Analyse von Erdbeben mit Matplotlib
from mpl_toolkits.mplot3d import Axes3D
import matplotlib.pyplot as plt
import numpy as np
import matplotlib.colors as mcolors
import pandas as pd

def visualize_region(data, region_name, lon_range, lat_range, min_magnitude=5.0):
    """
    Erstellt eine 2D- und 3D-Visualisierung für eine spezifische tektonische Region.
    
    Parameters:
    -----------
    data : DataFrame
        Erdbebendaten
    region_name : str
        Name der Region für den Titel
    lon_range : tuple
        (min_lon, max_lon) für die Region
    lat_range : tuple
        (min_lat, max_lat) für die Region
    min_magnitude : float
        Minimale Magnitude zur Filterung der Daten
    """
    # Filtern der relevanten Daten
    mask = ((data['Longitude'] >= lon_range[0]) & 
            (data['Longitude'] <= lon_range[1]) &
            (data['Latitude'] >= lat_range[0]) & 
            (data['Latitude'] <= lat_range[1]) &
            (data['Magnitude'] >= min_magnitude))
    
    region_data = data[mask].copy()
    
    # Prüfen, ob Daten vorhanden sind
    if len(region_data) == 0:
        print(f"Keine Daten für die Region {region_name} gefunden.")
        return
    
    print(f"Analysiere {len(region_data)} Erdbeben in der Region {region_name}.")
    
    # Kategorie der Tiefe hinzufügen
    region_data['Depth_Category'] = pd.cut(
        region_data['Depth'],
        bins=[0, 70, 300, 700],
        labels=['Flach (0-70 km)', 'Mittel (70-300 km)', 'Tief (>300 km)']
    )
    
    # Erstellen einer Figur mit zwei Subplots (2D und 3D)
    fig = plt.figure(figsize=(14, 10))
    
    # 2D-Plot (oben)
    ax1 = fig.add_subplot(211)
    
    # Hintergrund für Meer
    ax1.axhspan(lat_range[0], lat_range[1], facecolor='lightblue', alpha=0.3, zorder=0)
    
    # Plotten nach Tiefenkategorie
    categories = region_data['Depth_Category'].unique()
    
    # Farbpalette für Tiefenkategorien
    colors = {'Flach (0-70 km)': 'yellow', 
              'Mittel (70-300 km)': 'orange', 
              'Tief (>300 km)': 'red'}
    
    # Nach Kategorie plotten
    for category in categories:
        subset = region_data[region_data['Depth_Category'] == category]
        ax1.scatter(
            subset['Longitude'],
            subset['Latitude'],
            c=colors[category],
            s=subset['Magnitude']**1.5,
            alpha=0.7,
            edgecolor='k',
            linewidth=0.2,
            label=category
        )
    
    # Achsenbeschriftung und Titel
    ax1.set_xlim(lon_range)
    ax1.set_ylim(lat_range)
    ax1.set_xlabel('Längengrad', fontsize=12)
    ax1.set_ylabel('Breitengrad', fontsize=12)
    ax1.set_title(f'2D-Ansicht: {region_name}', fontsize=14)
    ax1.grid(True, alpha=0.3)
    ax1.legend()
    
    # 3D-Plot (unten)
    ax2 = fig.add_subplot(212, projection='3d')
    
    # Nach Kategorie plotten
    for category in categories:
        subset = region_data[region_data['Depth_Category'] == category]
        ax2.scatter(
            subset['Longitude'],
            subset['Latitude'],
            -subset['Depth'],
            c=colors[category],
            s=subset['Magnitude']**1.5,
            alpha=0.7,
            edgecolor='k',
            linewidth=0.2,
            label=category
        )
    
    # Einfache "Erdoberfläche" hinzufügen
    xx, yy = np.meshgrid([lon_range[0], lon_range[1]], [lat_range[0], lat_range[1]])
    zz = np.zeros(xx.shape)
    ax2.plot_surface(xx, yy, zz, alpha=0.1, color='lightblue')
    
    # Achsenbeschriftung und Konfiguration
    ax2.set_xlim(lon_range)
    ax2.set_ylim(lat_range)
    ax2.set_zlim(-max(region_data['Depth'].max() * 1.1, 200), 0)
    ax2.set_xlabel('Längengrad', fontsize=12)
    ax2.set_ylabel('Breitengrad', fontsize=12)
    ax2.set_zlabel('Tiefe (km)', fontsize=12)
    ax2.set_title(f'3D-Ansicht: {region_name}', fontsize=14)
    
    # Perspektive anpassen
    ax2.view_init(elev=30, azim=225)
    
    # Haupttitel für die gesamte Figur
    plt.suptitle(f'Erdbebenanalyse: {region_name} (Magnitude ≥ {min_magnitude})', 
                fontsize=16, y=0.98)
    
    plt.tight_layout()
    plt.subplots_adjust(top=0.9)
    plt.show()

# Analyse verschiedener tektonischer Regionen

# 1. Japan und Umgebung (Subduktionszone)
visualize_region(earthquakes_subset, "Japan und Umgebung", 
               lon_range=(125, 150), lat_range=(25, 45), min_magnitude=5.5)

# 2. Anden (Südamerika) - Subduktionszone
visualize_region(earthquakes_subset, "Anden (Südamerika)", 
               lon_range=(-85, -65), lat_range=(-45, 0), min_magnitude=5.5)

Analysiere 2014 Erdbeben in der Region Japan und Umgebung.

Analysiere 1525 Erdbeben in der Region Anden (Südamerika).

Soviel also zur geographischen Visualisierung. Wie Sie sich inzwischen vorstellen können, ist so eine Analyse nach fast beliebigen Gesichtspunkten und Kriterien möglich.

5.3 Zeitliche Visualisierung der globalen Erdbebentätigkeit seit 1965¶

Neben der räumlichen Verteilung ist die zeitliche Dimension von Erdbeben ein faszinierender Aspekt, der uns erlaubt, die dynamische Natur seismischer Aktivität zu erfassen. Durch Animationen können wir die Entwicklung der Erdbebentätigkeit über Jahrzehnte hinweg verfolgen und möglicherweise Muster oder Veränderungen in der globalen seismischen Aktivität identifizieren.

In diesem Abschnitt erstellen wir Animationen, die die Erdbeben seit 1965 chronologisch darstellen. Dabei verwenden wir monatliche Zusammenfassungen, um die Datenmenge handhabbar zu halten und gleichzeitig aussagekräftige Visualisierungen zu ermöglichen.

5.3.1 2D-Animation der auftretenden Erdbeben auf der Erdoberfläche¶

Eine zweidimensionale Animation auf der Weltkarte erlaubt es uns, die globale Verteilung der Erdbeben im Zeitverlauf zu betrachten. Dabei können wir erkennen, wie sich die seismische Aktivität entlang der tektonischen Plattengrenzen entwickelt und wie bestimmte Regionen in verschiedenen Zeiträumen aktiver oder weniger aktiv sind.

In [12]:

# Import der benötigten Bibliotheken
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.animation as animation
from matplotlib.animation import FuncAnimation
from IPython.display import HTML
import matplotlib.colors as mcolors

# Erhöhung des Animationslimits (setzen auf 100 MB statt der Standard 20 MB)
plt.rcParams['animation.embed_limit'] = 100  # in MB

# Stil für bessere Ästhetik
sns.set_theme(style="whitegrid")

# Daten vorbereiten: Gruppieren nach Jahr und Monat
earthquakes_subset['year_month'] = earthquakes_subset['Date_Time'].dt.to_period('M')

# Sortieren nach Datum für die Animation
earthquakes_subset = earthquakes_subset.sort_values('Date_Time')

# Liste der einzigartigen Jahr-Monat-Kombinationen
unique_periods = earthquakes_subset['year_month'].unique()

# Funktion zum Erstellen der Animation
def create_2d_animation():
    # Figur und Achse erstellen
    fig, ax = plt.subplots(figsize=(12, 8))
    
    # Hintergrund für Meer
    ax.axhspan(-90, 90, facecolor='lightblue', alpha=0.3, zorder=0)
        
    # Grenzen und Beschriftungen
    ax.set_xlim(-180, 180)
    ax.set_ylim(-90, 90)
    ax.grid(True, alpha=0.3, zorder=0)
    ax.set_xlabel('Longitude', fontsize=12)
    ax.set_ylabel('Latitude', fontsize=12)
    
    # Titel vorbereiten (wird in der Animation aktualisiert)
    title = ax.set_title('Earthquakes over time', fontsize=14)
    
    # Scatter-Plot erstellen (leer zu Beginn)
    scatter = ax.scatter([], [], c=[], s=[], alpha=0.7, edgecolor='k', linewidth=0.2, cmap='YlOrRd', zorder=2)
    
    # Colorbar für die Magnitude
    cbar = plt.colorbar(scatter, ax=ax, pad=0.01)
    cbar.set_label('Magnitude', fontsize=12)
    
    # Counter für die Anzahl der dargestellten Monate
    counter_text = ax.text(0.01, 0.01, '', transform=ax.transAxes, fontsize=10,
                         bbox=dict(facecolor='white', alpha=0.7))
    
    # Initialisierung für die Animation
    def init():
        scatter.set_offsets(np.empty((0, 2)))
        title.set_text('')
        counter_text.set_text('')
        return scatter, title, counter_text
    
    # Haltezeit für jeden Frame in Millisekunden (für langsamere Animation)
    frame_interval = 200  # ms
    
    # Variable für die kumulierten Daten - HIER außerhalb definieren
    all_data = pd.DataFrame()
    
    # Animationsfunktion für jeden Frame
    def update(frame):
        # Zugriff auf die äußere Variable ohne global-Deklaration
        nonlocal all_data
        
        # Daten für den aktuellen Monat und alle vorherigen Monate
        current_period_str = str(unique_periods[frame])
        current_period = pd.Period(current_period_str)
        
        # Aktuellen Monat zum kumulierten Datensatz hinzufügen
        month_data = earthquakes_subset[earthquakes_subset['year_month'] == unique_periods[frame]]
        all_data = pd.concat([all_data, month_data])
        
        # Visualisiere die letzten x Monate oder alle bisherigen Daten, je nachdem was weniger ist
        display_window = 12  # Monate
        
        if frame >= display_window:
            # Letzte x Monate anzeigen
            display_periods = unique_periods[frame-display_window+1:frame+1]
            display_data = earthquakes_subset[earthquakes_subset['year_month'].isin(display_periods)]
        else:
            # Alle bisherigen Daten anzeigen
            display_data = all_data.copy()
        
        # Skalierungsfaktor für die Größe, abhängig von der Menge der Daten
        size_factor = max(0.5, min(2.0, 1000 / len(display_data)))
        
        # Daten aktualisieren
        scatter.set_offsets(np.vstack((display_data['Longitude'], display_data['Latitude'])).T)
        scatter.set_array(display_data['Magnitude'])
        
        # Größe aktualisieren (basierend auf Magnitude)
        sizes = display_data['Magnitude']**1.5 * size_factor
        scatter.set_sizes(sizes)
        
        # Titel und Counter aktualisieren
        title.set_text(f'Global earthquakes above M 5.5 during 12 month up to {current_period_str}')
        counter_text.set_text(f'Number of earthquakes: {len(display_data)}')
        
        # Farbbalken-Grenzen aktualisieren
        scatter.set_clim(
            vmin=earthquakes_subset['Magnitude'].min(),
            vmax=earthquakes_subset['Magnitude'].max()
        )
        
        return scatter, title, counter_text
    
    # Animation erstellen
    anim = FuncAnimation(
        fig, update, frames=len(unique_periods),
        init_func=init, blit=True, interval=frame_interval
    )
    
    plt.tight_layout()
    
    return anim

# Animation erstellen
anim_2d = create_2d_animation()

# Animation als HTML anzeigen
# HTML(anim_2d.to_jshtml())

# Optional: Animation als Datei speichern
# anim_2d.save('erdbeben_2d_animation_12_monate.mp4', writer='ffmpeg', fps=5, dpi=300)

5.3.2 3D-Animation der auftretenden Erdbeben auf der Erdkugel¶

Eine dreidimensionale Animation auf einer Erdkugel bietet eine noch realistischere Darstellung der globalen Erdbebentätigkeit. Durch die Einbeziehung der Tiefe und die sphärische Darstellung können wir ein umfassenderes Bild der seismischen Aktivität gewinnen, insbesondere in Subduktionszonen, wo Erdbeben in unterschiedlichen Tiefen auftreten.

In der folgenden Visualisierung modellieren wir die Erde als Kugel und platzieren die Erdbeben entsprechend ihrer geografischen Koordinaten und Tiefe. Dabei skalieren wir die Tiefe für eine bessere visuelle Wirkung und lassen die Kugel zur besseren räumlichen Wahrnehmung rotieren.

In [13]:

# Erhöhung des Animationslimits auf 100 MB
plt.rcParams['animation.embed_limit'] = 100  # in MB

# Vereinfachte Funktion zur Umrechnung von Längen-/Breitengrad in 3D-Koordinaten
def lat_lon_to_cartesian(lat, lon, depth=0, earth_radius=6371):
    """
    Konvertiert Längen- und Breitengrad in 3D-Koordinaten.
    
    Parameters:
    -----------
    lat : float
        Breitengrad in Grad (-90 bis 90)
    lon : float
        Längengrad in Grad (-180 bis 180)
    depth : float
        Tiefe in km unter der Oberfläche (positive Werte)
    earth_radius : float
        Erdradius in km (Standardwert: 6371 km)
        
    Returns:
    --------
    x, y, z : float
        3D-Koordinaten
    """
    # Umrechnung in Radianten
    lat_rad = np.radians(lat)
    lon_rad = np.radians(lon)
    
    # Angepasster Radius (Erdradius minus Tiefe mal 5, für bessere Sichtbarkeit)
    radius = earth_radius - depth * 5
    
    # Umrechnung in kartesische Koordinaten
    x = radius * np.cos(lat_rad) * np.cos(lon_rad)
    y = radius * np.cos(lat_rad) * np.sin(lon_rad)
    z = radius * np.sin(lat_rad)
    
    return x, y, z

# Funktion zum Erstellen der vereinfachten 3D-Animation
def create_simplified_3d_animation():
    # Figur und Achse erstellen
    fig = plt.figure(figsize=(12, 6))
    ax = fig.add_subplot(111, projection='3d')
    ax.set_axis_off()
    
    # Normalisierter Radius für die Visualisierung (echter Erdradius = 6371 km)
    # Wir normalisieren auf einen Wert von 1 für bessere Darstellung
    visualization_radius = 1.0
    scale_factor = visualization_radius / 6371
    
    # Gitter für die Erdoberfläche (nur Gitterlinien, keine Fläche)
    u = np.linspace(0, 2 * np.pi, 30)
    v = np.linspace(0, np.pi, 30)
    
    # Zeichnen der Längen- und Breitengrade als einfaches Gitter
    # Breitengrade
    for lat in np.arange(-90, 91, 30):
        lat_rad = np.radians(lat)
        circle_radius = visualization_radius * np.cos(lat_rad)
        z_value = visualization_radius * np.sin(lat_rad)
        
        theta = np.linspace(0, 2 * np.pi, 100)
        x = circle_radius * np.cos(theta)
        y = circle_radius * np.sin(theta)
        z = np.ones_like(theta) * z_value
        
        if lat == 0:  # Äquator hervorheben
            ax.plot(x, y, z, color='blue', linewidth=1.0, alpha=0.7)
        else:
            ax.plot(x, y, z, color='gray', linewidth=0.5, alpha=0.3)
    
    # Längengrade
    for lon in np.arange(-180, 181, 30):
        lon_rad = np.radians(lon)
        
        theta = np.linspace(-np.pi/2, np.pi/2, 100)
        x = visualization_radius * np.cos(theta) * np.cos(lon_rad)
        y = visualization_radius * np.cos(theta) * np.sin(lon_rad)
        z = visualization_radius * np.sin(theta)
        
        if lon == 0:  # Nullmeridian hervorheben
            ax.plot(x, y, z, color='green', linewidth=1.0, alpha=0.7)
        else:
            ax.plot(x, y, z, color='gray', linewidth=0.5, alpha=0.3)
    
    # Grenzen und Beschriftungen
    ax.set_xlim(-visualization_radius*1.2, visualization_radius*1.2)
    ax.set_ylim(-visualization_radius*1.2, visualization_radius*1.2)
    ax.set_zlim(-visualization_radius*1.2, visualization_radius*1.2)
    
    # Achsen mit Beschriftungen anzeigen
    ax.set_xlabel('X', fontsize=10)
    ax.set_ylabel('Y', fontsize=10)
    ax.set_zlabel('Z', fontsize=10)
    
    # Titel vorbereiten
    title = ax.set_title('Earthquakes on the globe', fontsize=14)
    
    # Counter für die Anzahl der dargestellten Monate
    counter_text = ax.text2D(0.01, 0.01, '', transform=ax.transAxes, fontsize=10,
                           bbox=dict(facecolor='white', alpha=0.7))
    
    # Scatter-Plot erstellen (leer zu Beginn)
    scatter = ax.scatter([], [], [], c=[], s=[], alpha=0.7, edgecolor='k', 
                        linewidth=0.2, cmap='YlOrRd', depthshade=True)
    
    # Farbbalken für die Magnitude
    cbar = plt.colorbar(scatter, ax=ax, shrink=0.7, aspect=20, pad=0.1)
    cbar.set_label('Magnitude', fontsize=12)
    
    # Liste der einzigartigen Jahr-Monat-Kombinationen
    unique_periods = earthquakes_subset['year_month'].unique()
    
    # Anzahl der Frames reduzieren (jeden zweiten Monat anzeigen)
    frame_step = 1
    selected_periods = unique_periods[::frame_step]
    
    # Rotationswinkel für langsamere Rotation
    rotation_angle = 2
    
    # Initialisierung der Animation
    def init():
        scatter._offsets3d = (np.array([]), np.array([]), np.array([]))
        title.set_text('')
        counter_text.set_text('')
        return scatter, title, counter_text
    
    # Variable für die kumulierten Daten
    all_data = pd.DataFrame()
    
    # Animationsfunktion für jeden Frame
    def update(frame_idx):
        # Zugriff auf die äußere Variable
        nonlocal all_data
        
        # Index im Original-Array
        frame = frame_idx * frame_step
        if frame >= len(unique_periods):
            frame = len(unique_periods) - 1
            
        # Aktuelle Rotationsposition
        elev = 20
        azim = (frame_idx * rotation_angle) % 360
        ax.view_init(elev=elev, azim=azim)
        
        # Daten für den aktuellen Monat und alle vorherigen Monate
        current_period = unique_periods[frame]
        current_period_str = str(current_period)
        
        # Alle Daten bis zum aktuellen Frame sammeln
        all_periods = unique_periods[:frame+1]
        all_data = earthquakes_subset[earthquakes_subset['year_month'].isin(all_periods)]
        
        # Visualisiere die letzten x Monate oder alle bisherigen Daten, je nachdem was weniger ist
        display_window = 3  # Monate
        
        if frame >= display_window:
            # Letzte x Monate anzeigen
            display_periods = unique_periods[frame-display_window+1:frame+1]
            display_data = earthquakes_subset[earthquakes_subset['year_month'].isin(display_periods)]
        else:
            # Alle bisherigen Daten anzeigen
            display_data = all_data.copy()
        
        # Bei vielen Daten: Sample nehmen für bessere Performance
        max_points = 3000
        if len(display_data) > max_points:
            display_data = display_data.sample(max_points, random_state=42)
        
        # Koordinaten berechnen und auf die Visualisierungsskala skalieren
        xs, ys, zs = [], [], []
        for idx, quake in display_data.iterrows():
            x, y, z = lat_lon_to_cartesian(
                quake['Latitude'], 
                quake['Longitude'], 
                depth=quake['Depth']
            )
            # Skalieren auf Visualisierungsmaßstab
            xs.append(x * scale_factor)
            ys.append(y * scale_factor)
            zs.append(z * scale_factor)
        
        # Skalierungsfaktor für die Größe
        size_factor = max(0.5, min(2.0, 1000 / len(display_data)))
        
        # Daten aktualisieren
        scatter._offsets3d = (xs, ys, zs)
        scatter.set_array(display_data['Magnitude'].values)
        
        # Größe aktualisieren (basierend auf Magnitude)
        sizes = display_data['Magnitude'].values**1.5 * size_factor
        scatter.set_sizes(sizes)
        
        # Titel und Counter aktualisieren
        title.set_text(f'Global earthquakes above M 5.5 during 3 month up to {current_period_str}')
        counter_text.set_text(f'Number of earthquakes: {len(display_data)}')
        
        # Farbbalken-Grenzen aktualisieren
        scatter.set_clim(
            vmin=earthquakes_subset['Magnitude'].min(),
            vmax=earthquakes_subset['Magnitude'].max()
        )
        
        return scatter, title, counter_text
    
    # Animation erstellen
    anim = FuncAnimation(
        fig, update, frames=len(selected_periods),
        init_func=init, blit=False, interval=250
    )
    
    plt.tight_layout()
    
    return anim

# Vereinfachte Animation erstellen
anim_3d_simplified = create_simplified_3d_animation()

# Animation als HTML anzeigen
# HTML(anim_3d_simplified.to_jshtml())

# Optional: Animation als Datei speichern
# anim_3d_simplified.save('erdbeben_3d_animation_3_monate.mp4', writer='ffmpeg', fps=5, dpi=300)

Die Animationen der globalen Erdbebentätigkeit seit 1965 ermöglichen es uns, einen Einblick in die globale Dynamik dieser Phänomene zu bekommen. Weitere Einsichten kann man durch genauere Aufschlüsselung von zusammenhängen erreichen.

5.4 Einfache Datenanalyse¶

Nach der Visualisierung der räumlichen und zeitlichen Verteilung von Erdbeben wenden wir uns nun einigen Arten der detaillierteren Analyse unserer Daten zu. In diesem Abschnitt werden wir einige grundlegende Analysetechniken anwenden, um Muster und Zusammenhänge in den Erdbebendaten zu identifizieren, oder das zumindest zu versuchen.

5.4.1 Zusammenhang bzw. Korrelation zwischen Magnitude und Tiefe¶

Eine interessante Frage in der Seismologie ist, ob es einen Zusammenhang zwischen der Tiefe eines Erdbebens und seiner Magnitude gibt. Intuitiv könnte man vermuten, dass tiefere Erdbeben möglicherweise mit höheren Magnituden verbunden sind, da der Druck in größerer Tiefe höher ist. Andererseits könnten die Gesteinsstrukturen in tieferen Erdschichten anders auf Spannungen reagieren.

Wir werden zunächst die grundlegende Korrelation zwischen diesen Variablen untersuchen und dann verschiedene statistische Methoden anwenden, um etwaige Muster zu erkennen.

In [14]:

# Import der benötigten Bibliotheken
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from scipy import stats
from sklearn.linear_model import LinearRegression

# Für bessere Ästhetik
sns.set_theme(style="whitegrid")

# Scatterplot von Magnitude gegen Tiefe
plt.figure(figsize=(12, 6))
plt.scatter(
    earthquakes_subset['Depth'], 
    earthquakes_subset['Magnitude'],
    alpha=0.3, 
    edgecolor='none',
    c=earthquakes_subset['Magnitude'],
    cmap='viridis'
)
plt.colorbar(label='Magnitude')
plt.xlabel('Tiefe (km)')
plt.ylabel('Magnitude')
plt.title('Beziehung zwischen Erdbebenmagitude und -tiefe')
plt.grid(True, alpha=0.3)
plt.show()

# Berechnen des Pearson-Korrelationskoeffizienten
correlation, p_value = stats.pearsonr(
    earthquakes_subset['Depth'], 
    earthquakes_subset['Magnitude']
)

print(f"Pearson-Korrelationskoeffizient: {correlation:.4f}")
print(f"P-Wert: {p_value:.4e}")

# Interpretation der Korrelation
if abs(correlation) < 0.1:
    print("Interpretation: Sehr schwache oder keine Korrelation")
elif abs(correlation) < 0.3:
    print("Interpretation: Schwache Korrelation")
elif abs(correlation) < 0.5:
    print("Interpretation: Moderate Korrelation")
elif abs(correlation) < 0.7:
    print("Interpretation: Starke Korrelation")
else:
    print("Interpretation: Sehr starke Korrelation")

if p_value < 0.05:
    print("Die Korrelation ist statistisch signifikant (p < 0.05).")
else:
    print("Die Korrelation ist statistisch nicht signifikant (p ≥ 0.05).")

# Untersuchung der Beziehung mit verschiedenen Visualisierungen
plt.figure(figsize=(16, 12))

# 1. Scatterplot mit Hexbin für bessere Sichtbarkeit bei großen Datenmengen
plt.subplot(2, 2, 1)
plt.hexbin(
    earthquakes_subset['Depth'], 
    earthquakes_subset['Magnitude'],
    gridsize=40, 
    cmap='viridis', 
    mincnt=1
)
plt.colorbar(label='Anzahl der Erdbeben')
plt.xlabel('Tiefe (km)')
plt.ylabel('Magnitude')
plt.title('Hexbin-Plot: Magnitude vs. Tiefe')
plt.grid(True, alpha=0.3)

# 2. Box-Plot der Magnitude pro Tiefenbereich
plt.subplot(2, 2, 2)
# Erstellen von Tiefenkategorien
earthquakes_subset['Depth_Category'] = pd.cut(
    earthquakes_subset['Depth'],
    bins=[0, 30, 70, 150, 300, 500, 800],
    labels=['0-30', '30-70', '70-150', '150-300', '300-500', '500+']
)
sns.boxplot(x='Depth_Category', y='Magnitude', data=earthquakes_subset)
plt.xlabel('Tiefenbereich (km)')
plt.ylabel('Magnitude')
plt.title('Magnitude nach Tiefenbereich')
plt.grid(True, alpha=0.3)

# 3. Violin-Plot für detailliertere Verteilung
plt.subplot(2, 2, 3)
sns.violinplot(x='Depth_Category', y='Magnitude', data=earthquakes_subset)
plt.xlabel('Tiefenbereich (km)')
plt.ylabel('Magnitude')
plt.title('Verteilung der Magnitude nach Tiefenbereich')
plt.grid(True, alpha=0.3)

# 4. Durchschnittliche Magnitude pro Tiefenbereich
plt.subplot(2, 2, 4)
depth_mag_avg = earthquakes_subset.groupby('Depth_Category')['Magnitude'].mean().reset_index()
depth_counts = earthquakes_subset['Depth_Category'].value_counts().sort_index()
plt.bar(
    depth_mag_avg['Depth_Category'],
    depth_mag_avg['Magnitude'],
    alpha=0.7
)
plt.xlabel('Tiefenbereich (km)')
plt.ylabel('Durchschnittliche Magnitude')
plt.title('Durchschnittliche Magnitude nach Tiefenbereich')
for i, (idx, count) in enumerate(depth_counts.items()):
    plt.text(i, depth_mag_avg['Magnitude'].iloc[i] + 0.05, 
             f'n={count}', ha='center')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

# Analyse nach Magnitude-Typen
plt.figure(figsize=(14, 6))

# Korrelation für jeden Magnitude-Typ
mag_types = earthquakes_subset['Magnitude Type'].unique()
correlations = {}

plt.subplot(1, 2, 1)
for mag_type in mag_types:
    subset = earthquakes_subset[earthquakes_subset['Magnitude Type'] == mag_type]
    if len(subset) > 30:  # Mindestanzahl für signifikante Korrelation
        corr, p = stats.pearsonr(subset['Depth'], subset['Magnitude'])
        correlations[mag_type] = (corr, p, len(subset))
        
        # Separate Farbe für jeden Magnitude-Typ
        plt.scatter(
            subset['Depth'], 
            subset['Magnitude'],
            alpha=0.5,
            label=f'{mag_type} (r={corr:.2f}, n={len(subset)})'
        )

plt.xlabel('Tiefe (km)')
plt.ylabel('Magnitude')
plt.title('Magnitude vs. Tiefe nach Magnitude-Typ')
plt.legend(loc='upper left', bbox_to_anchor=(1, 1))
plt.grid(True, alpha=0.3)

# Zusammenfassung der Korrelationen
plt.subplot(1, 2, 2)
mag_types = [k for k, v in sorted(correlations.items(), key=lambda item: item[1][0])]
corr_values = [correlations[k][0] for k in mag_types]
counts = [correlations[k][2] for k in mag_types]
# Farbe basierend auf p-Wert (grün wenn stark, rot wenn nicht)
colors = ['green' if correlations[k][1] < 0.5 else 'red' for k in mag_types]

y_pos = np.arange(len(mag_types))
plt.barh(y_pos, corr_values, color=colors, alpha=0.7)
plt.yticks(y_pos, mag_types)
for i, count in enumerate(counts):
    plt.text(correlations[mag_types[i]][0] * 1.05, i, f'n={count}')
plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)
plt.xlabel('Korrelationskoeffizient')
plt.title('Korrelation zwischen Tiefe und Magnitude nach Magnitude-Typ')
plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

Pearson-Korrelationskoeffizient: 0.0235
P-Wert: 3.3131e-04
Interpretation: Sehr schwache oder keine Korrelation
Die Korrelation ist statistisch signifikant (p < 0.05).

/var/folders/3y/8zcxbyzx0g14cyfs7kqt0x680000gn/T/ipykernel_77586/984988547.py:97: FutureWarning: The default of observed=False is deprecated and will be changed to True in a future version of pandas. Pass observed=False to retain current behavior or observed=True to adopt the future default and silence this warning.
  depth_mag_avg = earthquakes_subset.groupby('Depth_Category')['Magnitude'].mean().reset_index()

Hier sieht man allerhand verschiedene Aufbereitungen der Datenpunkte in Abhängigkeit von Tiefe und Magnitude. Die resultierende generelle Korrelation und auch die $r$-Koeffizienten für verschiedene Teilmengen wie die verschiedenen Magnitude-Typen sind sehr nahe an null. Eine derart schwache bzw. nicht-Korrelation bedeutet also, dass es vermutlich keinen klaren linearen Zusammenhang zwischen der Tiefe und der Magnitude bei Erdbeben gibt.

Andererseits wird eine statistische Signifikanz über den kleinen $p$-Wert ausgegeben. Dieser kleine Wert ist jedoch durch die riesige Stichprobe bedingt, denn $p$ gibt einfach nur die Wahrscheinlichkeit dafür an, dass man die in unseren Daten gemessene Korrelation sehen würde, wenn bei keiner vorhandenen Korrelation zufällige Werte genommen würden. Je größer dabei die Stichprobe ist, desto kleiner wird diese Wahrscheinlichkeit.

Insgesamt bedeutet das also, dass wir hier keine nennenswerten Zusammenhänge finden konnten.

5.4.2 Inverser Zusammenhang der Häufigkeit in Abhängigkeit von der Magnitude¶

Eine der bemerkenswertesten Beobachtungen in der Seismologie ist die Beziehung zwischen der Häufigkeit von Erdbeben und ihrer Magnitude. Dieses Verhältnis folgt einem inversen Zusammenhang, der als Gutenberg-Richter-Gesetz bekannt ist. Es besagt, dass die Häufigkeit der Erdbeben exponentiell mit zunehmender Magnitude abnimmt. Mathematisch ausgedrückt hat man: $$\log_{10}(N) = a – b·M$$

wobei:

$N$ die Häufigkeit der Erdbeben mit einer Magnitude $\gt M$ ist
$a$ und $b$ sind Konstanten, wobei $b$ typischerweise Werte um 1 annimmt

Diese Beziehung bedeutet, dass für jede Erhöhung der Magnitude um eine Einheit die Anzahl der Erdbeben auf etwa ein Zehntel sinkt. So gibt es beispielsweise etwa zehnmal so viele Erdbeben der Magnitude 5 wie der Magnitude 6, und etwa hundertmal so viele wie der Magnitude 7.

Im Folgenden werden wir diese Beziehung in unseren Daten untersuchen und visualisieren. Wir machen das allerdings nicht für die kumulativen Anzahlen von Erdbeben $\gt M$, sondern verwenden ein einfaches Histogram. Das ist so etwas wie eine “differenzielle” Version des Gesetzes und ebenfalls exponentiell mit ähnlichen Parametern.

In [15]:

# Import der benötigten Bibliotheken
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from scipy import stats
from scipy.optimize import curve_fit

# Für bessere Ästhetik
sns.set_theme(style="whitegrid")

# Histogramm der Erdbebenmagnitude mit logarithmischer Y-Achse
plt.figure(figsize=(12, 6))

# Histogramm erstellen
bins = np.arange(4.0, 10.0, 0.1)  # Bins von 4.0 bis 10.0 in 0.1-Schritten
counts, edges = np.histogram(earthquakes_subset['Magnitude'], bins=bins)
centers = (edges[:-1] + edges[1:]) / 2

# Plot mit logarithmischer Y-Achse
plt.bar(centers, counts, width=0.08, alpha=0.7)
plt.yscale('log')
plt.xlabel('Magnitude')
plt.ylabel('Häufigkeit der Erdbeben (log-Skala)')
plt.title('Häufigkeitsverteilung der Erdbebenmagnitude')
plt.grid(True, alpha=0.3)
plt.show()

# Kumulatives Histogramm (Anzahl der Erdbeben ≥ Magnitude)
plt.figure(figsize=(12, 6))

# Sortieren der Daten nach Magnitude
sorted_magnitudes = np.sort(earthquakes_subset['Magnitude'])
# Umkehren der Sortierung (absteigend)
sorted_magnitudes = sorted_magnitudes[::-1]
# Kumulierte Anzahl (von größter zu kleinster Magnitude)
y = np.arange(1, len(sorted_magnitudes) + 1)

plt.plot(sorted_magnitudes, y, '-o', markersize=2, alpha=0.7)
plt.yscale('log')
plt.xlabel('Magnitude')
plt.ylabel('Anzahl der Erdbeben ≥ Magnitude (log-Skala)')
plt.title('Kumulatives Histogramm der Erdbebenmagnitude (Gutenberg-Richter-Gesetz)')
plt.grid(True, alpha=0.3)

# Funktion für das Gutenberg-Richter-Gesetz
def gutenberg_richter(M, a, b):
    """
    Gutenberg-Richter-Gesetz: log_{10}(N) = a - b·M
    oder N = 10^(a - b·M)
    """
    return 10**(a - b*M)

# Fitparameter für das kumulative Histogramm finden
# Wir betrachten nur Magnituden über 5.0 für einen besseren Fit
mask = sorted_magnitudes >= 5.0
p0 = [10, 1]  # Anfangsschätzung für a und b
try:
    params, covariance = curve_fit(gutenberg_richter, sorted_magnitudes[mask], y[mask], p0=p0)
    a, b = params
    
    # Fitkurve berechnen
    magnitude_range = np.linspace(5.0, sorted_magnitudes.max(), 100)
    fitted_values = gutenberg_richter(magnitude_range, a, b)
    
    # Fitkurve plotten
    plt.plot(magnitude_range, fitted_values, 'r-', linewidth=2, 
             label=r'Gutenberg-Richter: $\log_{10}(N) =$ '+f'{a:.2f} - {b:.2f}·M')
    plt.legend()
    
    print(f"Gutenberg-Richter-Parameter: a = {a:.2f}, b = {b:.2f}")
    
    # Interpretation des b-Wertes
    if b < 0.8:
        print("Interpretation: Niedriger b-Wert (< 0.8) - Relativ mehr starke Erdbeben, typisch für Gebiete mit homogenen Spannungen.")
    elif b > 1.2:
        print("Interpretation: Hoher b-Wert (> 1.2) - Relativ mehr schwache Erdbeben, typisch für Regionen mit heterogenen Spannungen oder vulkanischen Aktivitäten.")
    else:
        print("Interpretation: Durchschnittlicher b-Wert (0.8-1.2) - Typisch für die meisten tektonischen Regionen weltweit.")
    
except RuntimeError:
    print("Fehler beim Fitten der Kurve.")

plt.show()

# Analyse des Potenzgesetzes für verschiedene Regionen
plt.figure(figsize=(14, 10))

# Funktion zur Berechnung des kumulativen Histogramms
def calculate_cumulative_histogram(magnitudes):
    sorted_mags = np.sort(magnitudes)[::-1]
    y = np.arange(1, len(sorted_mags) + 1)
    return sorted_mags, y

# Funktion zum Fitten des Gutenberg-Richter-Gesetzes
def fit_gutenberg_richter(magnitudes, min_magnitude=5.0):
    sorted_mags, counts = calculate_cumulative_histogram(magnitudes)
    mask = sorted_mags >= min_magnitude
    
    if np.sum(mask) < 10:  # Mindestens 10 Datenpunkte für einen vernünftigen Fit
        return None, None, sorted_mags, counts
    
    p0 = [10, 1]  # Anfangsschätzung für a und b
    try:
        params, _ = curve_fit(gutenberg_richter, sorted_mags[mask], counts[mask], p0=p0)
        return params[0], params[1], sorted_mags, counts
    except:
        return None, None, sorted_mags, counts

# Regionen definieren und analysieren
regions = {
    'Pazifischer Feuerring': {
        'filter': ((earthquakes_subset['Longitude'] >= 120) & (earthquakes_subset['Longitude'] <= 180) & 
                  (earthquakes_subset['Latitude'] >= -60) & (earthquakes_subset['Latitude'] <= 60)) |
                 ((earthquakes_subset['Longitude'] >= -180) & (earthquakes_subset['Longitude'] <= -60) & 
                  (earthquakes_subset['Latitude'] >= -60) & (earthquakes_subset['Latitude'] <= 60)),
        'color': 'red'
    },
    'Mittelatlantischer Rücken': {
        'filter': (earthquakes_subset['Longitude'] >= -60) & (earthquakes_subset['Longitude'] <= 20) & 
                  (earthquakes_subset['Latitude'] >= -60) & (earthquakes_subset['Latitude'] <= 80),
        'color': 'blue'
    },
    'Alpen-Himalaya-Gürtel': {
        'filter': (earthquakes_subset['Longitude'] >= 20) & (earthquakes_subset['Longitude'] <= 120) & 
                  (earthquakes_subset['Latitude'] >= 0) & (earthquakes_subset['Latitude'] <= 60),
        'color': 'green'
    }
}

results = {}

for i, (region_name, region_info) in enumerate(regions.items()):
    regional_data = earthquakes_subset[region_info['filter']]
    
    # Fitten des Gutenberg-Richter-Gesetzes für diese Region
    a, b, sorted_mags, counts = fit_gutenberg_richter(regional_data['Magnitude'].values)
    results[region_name] = {'a': a, 'b': b, 'count': len(regional_data)}
    
    # Plot
    plt.subplot(2, 2, i+1)
    plt.plot(sorted_mags, counts, 'o', markersize=2, alpha=0.7, color=region_info['color'],
             label=f'{region_name} (n={len(regional_data)})')
    
    # Fitkurve, falls erfolgreich
    if a is not None and b is not None:
        magnitude_range = np.linspace(5.0, sorted_mags.max(), 100)
        fitted_values = gutenberg_richter(magnitude_range, a, b)
        plt.plot(magnitude_range, fitted_values, '-', linewidth=2, color='black',
                 label=f'a={a:.2f}, b={b:.2f}')
    
    plt.yscale('log')
    plt.xlabel('Magnitude')
    plt.ylabel('Anzahl der Erdbeben ≥ Magnitude')
    plt.title(f'Gutenberg-Richter-Gesetz: {region_name}')
    plt.legend()
    plt.grid(True, alpha=0.3)

# Vergleich der b-Werte für verschiedene Regionen
plt.subplot(2, 2, 4)
region_names = []
b_values = []
colors = []
for region_name, result in results.items():
    if result['b'] is not None:
        region_names.append(region_name)
        b_values.append(result['b'])
        colors.append(regions[region_name]['color'])

if b_values:
    plt.bar(region_names, b_values, color=colors, alpha=0.7)
    plt.axhline(y=1.0, color='k', linestyle='--', alpha=0.5, label='Globaler Durchschnitt ≈ 1.0')
    plt.ylabel('b-Wert')
    plt.title('Vergleich der b-Werte verschiedener Regionen')
    plt.xticks(rotation=45, ha='right')
    plt.legend()
    plt.grid(True, alpha=0.3)

plt.tight_layout()
plt.show()

Gutenberg-Richter-Parameter: a = 9.89, b = 1.01
Interpretation: Durchschnittlicher b-Wert (0.8-1.2) - Typisch für die meisten tektonischen Regionen weltweit.

Man sieht die erwartete Abhängigkeit sehr schön, jedenfalls für kleine $M$. Für größere $M$ wird die Häufigkeit so klein, dass statistische Fluktuationen eine immer größere Rolle spielen und manche Bins unter- bzw. überrepräsentiert sind.

5.4.3 Ein erstes einfaches Beispiel für Dimensionsreduktion¶

Dimensionsreduktion ist eine mächtige Technik in der Datenanalyse, die es uns ermöglicht, hochdimensionale Daten in einer niedrigeren Dimension zu visualisieren und zu analysieren. Sie kann dabei helfen, verborgene Strukturen und Muster in komplexen Datensätzen zu entdecken.

In unserem Fall können wir die Erdbebendaten, die mehrere Dimensionen haben (Längengrad, Breitengrad, Tiefe, Magnitude, usw.), auf weniger Dimensionen reduzieren, um möglicherweise neue Einsichten zu gewinnen.

Wir werden die Hauptkomponentenanalyse oder Principal Component Analysis (PCA) verwenden, eine der grundlegendsten und am häufigsten eingesetzten Methoden zur Dimensionsreduktion. PCA transformiert die Daten so, dass die erste Komponente die größtmögliche Varianz erfasst, die zweite Komponente die zweitgrößte Varianz und so weiter.

In [16]:

# Import der benötigten Bibliotheken
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
from sklearn.preprocessing import StandardScaler
from sklearn.decomposition import PCA
from sklearn.cluster import KMeans
from sklearn.pipeline import Pipeline

# Für bessere Ästhetik
sns.set_theme(style="whitegrid")

# Daten für die PCA vorbereiten
# Wir verwenden nur numerische Spalten
features = ['Latitude', 'Longitude', 'Depth', 'Magnitude']
X = earthquakes_subset[features].copy()

# Fehlende Werte überprüfen und behandeln
print("Fehlende Werte vor der Vorverarbeitung:")
print(X.isnull().sum())

# Transformation-Pipeline erstellen
pca_pipeline = Pipeline([
    ('scaler', StandardScaler()),  # Standardisierung (wichtig für PCA)
    ('pca', PCA(n_components=2))   # Reduktion auf 2 Dimensionen
])

# PCA anwenden
X_pca = pca_pipeline.fit_transform(X)

# PCA-Komponenten extrahieren
pca = pca_pipeline.named_steps['pca']
components = pca.components_
explained_variance = pca.explained_variance_ratio_

# Visualisierung der Ergebnisse
plt.figure(figsize=(14, 6))

# Scatterplot der ersten zwei PCA-Komponenten
plt.subplot(1, 2, 1)
scatter = plt.scatter(
    X_pca[:, 0], 
    X_pca[:, 1],
    c=earthquakes_subset['Magnitude'],
    cmap='viridis',
    alpha=0.5,
    edgecolor='none'
)
plt.colorbar(scatter, label='Magnitude')
plt.xlabel(f'Hauptkomponente 1 ({explained_variance[0]:.1%} Varianz)')
plt.ylabel(f'Hauptkomponente 2 ({explained_variance[1]:.1%} Varianz)')
plt.title('PCA der Erdbebendaten')
plt.grid(True, alpha=0.3)

# Visualisierung der Feature-Wichtigkeit (Loadings) in den ersten beiden Komponenten
plt.subplot(1, 2, 2)
loading_vectors = np.transpose(components)
n_features = len(features)

# Begrenzungen für den Plot
plt.xlim(-1, 1)
plt.ylim(-1, 1)

# Einheitskreis zeichnen
circle = plt.Circle((0, 0), 1, fill=False, color='gray', linestyle='--')
plt.gca().add_patch(circle)

# Loading-Vektoren zeichnen
for i, feature in enumerate(features):
    plt.arrow(0, 0, loading_vectors[i, 0], loading_vectors[i, 1], 
             head_width=0.05, head_length=0.05, fc='blue', ec='blue')
    plt.text(loading_vectors[i, 0] * 1.15, loading_vectors[i, 1] * 1.15, 
             feature, color='blue', ha='center', va='center')

plt.xlabel('Hauptkomponente 1')
plt.ylabel('Hauptkomponente 2')
plt.title('Feature-Loadings der ersten zwei Hauptkomponenten')
plt.grid(True, alpha=0.3)
plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)
plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)

plt.tight_layout()
plt.show()

# Einfache Clusteranalyse basierend auf den PCA-Ergebnissen
# Verwende KMeans für automatisches Clustering
n_clusters = 15  # Anzahl der Cluster
kmeans = KMeans(n_clusters=n_clusters, n_init='auto', random_state=42)
cluster_labels = kmeans.fit_predict(X_pca)

# Visualisierung der Cluster
plt.figure(figsize=(14, 10))

# 1. PCA-Raum mit Clustern
plt.subplot(2, 2, 1)
for i in range(n_clusters):
    mask = cluster_labels == i
    plt.scatter(
        X_pca[mask, 0], 
        X_pca[mask, 1],
        label=f'Cluster {i+1}',
        alpha=0.7,
        edgecolor='none'
    )
plt.xlabel(f'Hauptkomponente 1 ({explained_variance[0]:.1%} Varianz)')
plt.ylabel(f'Hauptkomponente 2 ({explained_variance[1]:.1%} Varianz)')
plt.title('Clustering der PCA-Ergebnisse')
plt.legend()
plt.grid(True, alpha=0.3)

# 2. Geografische Verteilung der Cluster
plt.subplot(2, 2, 2)
for i in range(n_clusters):
    mask = cluster_labels == i
    plt.scatter(
        earthquakes_subset[mask]['Longitude'], 
        earthquakes_subset[mask]['Latitude'],
        label=f'Cluster {i+1}',
        alpha=0.3,
        edgecolor='none'
    )
plt.xlabel('Längengrad')
plt.ylabel('Breitengrad')
plt.title('Geografische Verteilung der Cluster')
plt.legend()
plt.grid(True, alpha=0.3)

# 3. Tiefe vs. Magnitude nach Cluster
plt.subplot(2, 2, 3)
for i in range(n_clusters):
    mask = cluster_labels == i
    plt.scatter(
        earthquakes_subset[mask]['Depth'], 
        earthquakes_subset[mask]['Magnitude'],
        label=f'Cluster {i+1}',
        alpha=0.5,
        edgecolor='none'
    )
plt.xlabel('Tiefe (km)')
plt.ylabel('Magnitude')
plt.title('Tiefe vs. Magnitude nach Cluster')
plt.legend()
plt.grid(True, alpha=0.3)

# 4. Statistische Zusammenfassung der Cluster
plt.subplot(2, 2, 4)
earthquakes_subset['Cluster'] = cluster_labels
cluster_stats = earthquakes_subset.groupby('Cluster').agg({
    'Magnitude': ['mean', 'min', 'max', 'count'],
    'Depth': ['mean', 'min', 'max']
})

# Anzeigen der Statistiken als Text
plt.axis('off')
plt.text(0.05, 0.95, 'Cluster-Statistiken:', fontsize=12, fontweight='bold')
y_pos = 0.85
for i in range(n_clusters):
    stats = cluster_stats.loc[i]
    text = (
        f"Cluster {i+1} (n={stats[('Magnitude', 'count')]})\n"
        f"  Magnitude: Ø {stats[('Magnitude', 'mean')]:.2f} "
        f"(Min: {stats[('Magnitude', 'min')]:.1f}, Max: {stats[('Magnitude', 'max')]:.1f})\n"
        f"  Tiefe: Ø {stats[('Depth', 'mean')]:.2f} km "
        f"(Min: {stats[('Depth', 'min')]:.1f}, Max: {stats[('Depth', 'max')]:.1f})"
    )
    plt.text(0.05, y_pos, text, fontsize=10, va='top')
    y_pos -= 0.25

# plt.tight_layout()
plt.show()

# Interpretation der PCA-Ergebnisse
print("Interpretation der PCA-Ergebnisse:")
print("---------------------------------")
print(f"Die erste Hauptkomponente erklärt {explained_variance[0]:.1%} der Varianz.")
print(f"Die zweite Hauptkomponente erklärt {explained_variance[1]:.1%} der Varianz.")
print(f"Insgesamt werden {explained_variance[0] + explained_variance[1]:.1%} der Varianz durch die ersten beiden Komponenten erklärt.")

print("\nBeiträge der Variablen zu den Hauptkomponenten:")
for i, feature in enumerate(features):
    print(f"{feature}: PC1 = {loading_vectors[i, 0]:.3f}, PC2 = {loading_vectors[i, 1]:.3f}")

print("\nCluster-Charakteristiken:")
for i in range(n_clusters):
    stats = cluster_stats.loc[i]
    print(f"Cluster {i+1} (n={stats[('Magnitude', 'count')]})")
    print(f"  Magnitude: Durchschnitt = {stats[('Magnitude', 'mean')]:.2f}, Bereich = [{stats[('Magnitude', 'min')]:.1f}, {stats[('Magnitude', 'max')]:.1f}]")
    print(f"  Tiefe: Durchschnitt = {stats[('Depth', 'mean')]:.2f} km, Bereich = [{stats[('Depth', 'min')]:.1f}, {stats[('Depth', 'max')]:.1f}] km")

Fehlende Werte vor der Vorverarbeitung:
Latitude     0
Longitude    0
Depth        0
Magnitude    0
dtype: int64

Interpretation der PCA-Ergebnisse:
---------------------------------
Die erste Hauptkomponente erklärt 31.6% der Varianz.
Die zweite Hauptkomponente erklärt 25.5% der Varianz.
Insgesamt werden 57.1% der Varianz durch die ersten beiden Komponenten erklärt.

Beiträge der Variablen zu den Hauptkomponenten:
Latitude: PC1 = -0.639, PC2 = 0.060
Longitude: PC1 = -0.644, PC2 = 0.062
Depth: PC1 = 0.394, PC2 = 0.512
Magnitude: PC1 = -0.144, PC2 = 0.855

Cluster-Charakteristiken:
Cluster 1 (n=1662.0)
  Magnitude: Durchschnitt = 6.31, Bereich = [5.5, 6.8]
  Tiefe: Durchschnitt = 77.92 km, Bereich = [0.0, 580.2] km
Cluster 2 (n=1820.0)
  Magnitude: Durchschnitt = 5.61, Bereich = [5.5, 5.9]
  Tiefe: Durchschnitt = 25.71 km, Bereich = [1.3, 164.0] km
Cluster 3 (n=4645.0)
  Magnitude: Durchschnitt = 5.59, Bereich = [5.5, 5.8]
  Tiefe: Durchschnitt = 34.82 km, Bereich = [-1.1, 158.6] km
Cluster 4 (n=791.0)
  Magnitude: Durchschnitt = 6.19, Bereich = [5.5, 6.7]
  Tiefe: Durchschnitt = 109.30 km, Bereich = [5.0, 569.4] km
Cluster 5 (n=343.0)
  Magnitude: Durchschnitt = 7.46, Bereich = [6.1, 9.1]
  Tiefe: Durchschnitt = 131.77 km, Bereich = [4.9, 656.2] km
Cluster 6 (n=2420.0)
  Magnitude: Durchschnitt = 5.64, Bereich = [5.5, 5.9]
  Tiefe: Durchschnitt = 31.45 km, Bereich = [0.0, 171.8] km
Cluster 7 (n=2177.0)
  Magnitude: Durchschnitt = 5.58, Bereich = [5.5, 5.9]
  Tiefe: Durchschnitt = 33.14 km, Bereich = [0.0, 182.5] km
Cluster 8 (n=924.0)
  Magnitude: Durchschnitt = 6.82, Bereich = [5.8, 7.3]
  Tiefe: Durchschnitt = 60.93 km, Bereich = [-0.1, 576.4] km
Cluster 9 (n=574.0)
  Magnitude: Durchschnitt = 6.26, Bereich = [5.5, 7.4]
  Tiefe: Durchschnitt = 339.10 km, Bereich = [4.0, 691.6] km
Cluster 10 (n=1307.0)
  Magnitude: Durchschnitt = 6.15, Bereich = [5.6, 6.7]
  Tiefe: Durchschnitt = 32.58 km, Bereich = [0.0, 285.0] km
Cluster 11 (n=582.0)
  Magnitude: Durchschnitt = 5.78, Bereich = [5.5, 6.5]
  Tiefe: Durchschnitt = 548.10 km, Bereich = [215.3, 700.0] km
Cluster 12 (n=189.0)
  Magnitude: Durchschnitt = 6.96, Bereich = [6.1, 8.8]
  Tiefe: Durchschnitt = 479.00 km, Bereich = [6.0, 677.4] km
Cluster 13 (n=1592.0)
  Magnitude: Durchschnitt = 5.89, Bereich = [5.5, 6.4]
  Tiefe: Durchschnitt = 74.16 km, Bereich = [1.0, 344.3] km
Cluster 14 (n=1536.0)
  Magnitude: Durchschnitt = 5.85, Bereich = [5.5, 6.2]
  Tiefe: Durchschnitt = 62.25 km, Bereich = [0.0, 379.6] km
Cluster 15 (n=2850.0)
  Magnitude: Durchschnitt = 5.91, Bereich = [5.5, 6.2]
  Tiefe: Durchschnitt = 42.86 km, Bereich = [1.0, 284.8] km

Die PCA ist hier vielleicht etwas künstlich, aber man sieht tatsächlich auch, wie sich bestimmte Cluster (also in der PCA ähnliche Datenpunkte) in der geographischen Verteilung in lokalisierter Form wiederfinden. Man kann Daten zwar auch immer ohne vorherige PCA clustern, aber zugrundeliegende oder versteckte Strukturen findet man so eher selten.

5.4.4 Vergleich der globalen Verteilung von Atombombentests¶

Bisher haben wir uns ausschließlich mit natürlichen Erdbeben beschäftigt. Unser Datensatz enthält jedoch auch Aufzeichnungen von anthropogenen seismischen Ereignissen, insbesondere Kernwaffentests. Diese Tests erzeugen seismische Wellen, die von den globalen Messstationen ähnlich wie natürliche Erdbeben erfasst werden.

Die Analyse der Verteilung dieser Tests kann interessante historische und geopolitische Einblicke liefern. Wir werden die Daten filtern, um nur Ereignisse vom Typ “Nuclear Explosion” zu betrachten, und deren geografische Verteilung visualisieren.

Es ist wichtig zu beachten, dass unser Datensatz möglicherweise nicht alle historischen Kernwaffentests enthält, da einige Tests möglicherweise nicht als solche identifiziert oder aufgezeichnet wurden, insbesondere in den frühen Jahren der Kernwaffenentwicklung.

In [17]:

# Import der benötigten Bibliotheken
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import seaborn as sns
import matplotlib.cm as cm
from matplotlib.colors import Normalize
import matplotlib.dates as mdates

# Stil für bessere Ästhetik
sns.set_theme(style="whitegrid")

# Filtern der Daten nach Ereignistyp "Nuclear Explosion"
nuclear_tests = earthquakes_subset[earthquakes_subset['Type'] == 'Nuclear Explosion'].copy()

# Überprüfung, wie viele Nukleartests in den Daten enthalten sind
print(f"Anzahl der Nukleartests im Datensatz: {len(nuclear_tests)}")

# Übersicht über die Verteilung der Magnitude und Tiefe
if len(nuclear_tests) > 0:
    print("\nStatistiken der Nukleartests:")
    print(f"Magnitude: Min = {nuclear_tests['Magnitude'].min():.1f}, Max = {nuclear_tests['Magnitude'].max():.1f}, Durchschnitt = {nuclear_tests['Magnitude'].mean():.2f}")
    print(f"Tiefe: Min = {nuclear_tests['Depth'].min():.1f} km, Max = {nuclear_tests['Depth'].max():.1f} km, Durchschnitt = {nuclear_tests['Depth'].mean():.2f} km")
    
    # Einige Beispieldaten anzeigen
    print("\nBeispieldaten von Nukleartests:")
    display(nuclear_tests[['Date_Time', 'Latitude', 'Longitude', 'Depth', 'Magnitude']].head())

    # Geografische Verteilung der Nukleartests visualisieren
    plt.figure(figsize=(14, 8))
    
    # Hintergrund für Meer
    plt.axhspan(-90, 90, facecolor='lightblue', alpha=0.3, zorder=0)
    
    # Scatterplot der Nukleartests
    scatter = plt.scatter(
        nuclear_tests['Longitude'], 
        nuclear_tests['Latitude'],
        c=nuclear_tests['Magnitude'],
        s=nuclear_tests['Magnitude']**2 * 2,  # Größe basierend auf Magnitude
        cmap='YlOrRd',
        alpha=0.7,
        edgecolor='k',
        linewidth=0.5,
        zorder=2
    )
    
    # Colorbar für die Magnitude
    cbar = plt.colorbar(scatter, label='Magnitude')
    
    # Grenzen und Beschriftungen
    plt.xlim(-180, 180)
    plt.ylim(-90, 90)
    plt.xlabel('Längengrad', fontsize=12)
    plt.ylabel('Breitengrad', fontsize=12)
    plt.title('Geografische Verteilung von Nukleartests', fontsize=14)
    plt.grid(True, alpha=0.3, zorder=1)
    
    # Anmerkung zur Gesamtzahl der Tests
    plt.annotate(f'Gesamtzahl der Nukleartests: {len(nuclear_tests)}', 
                 xy=(0.02, 0.02), xycoords='figure fraction', fontsize=12, 
                 bbox=dict(facecolor='white', alpha=0.7))
    
    plt.tight_layout()
    plt.show()
    
    # Analyse der zeitlichen Verteilung der Nukleartests
    if 'Date_Time' in nuclear_tests.columns:
        plt.figure(figsize=(14, 6))
        
        # Zählen der Tests pro Jahr
        nuclear_tests['Year'] = nuclear_tests['Date_Time'].dt.year
        tests_per_year = nuclear_tests.groupby('Year').size()
        
        # Balkendiagramm der Tests pro Jahr
        plt.bar(tests_per_year.index, tests_per_year.values, alpha=0.7)
        plt.xlabel('Jahr', fontsize=12)
        plt.ylabel('Anzahl der Nukleartests', fontsize=12)
        plt.title('Zeitliche Verteilung von Nukleartests', fontsize=14)
        plt.grid(True, alpha=0.3, axis='y')
        
        # Beschriftung für wichtige historische Ereignisse
        historic_events = {
            1963: 'Teilweiser Teststoppvertrag',
            1996: 'Umfassender Teststoppvertrag'
        }
        
        for year, event in historic_events.items():
            if year >= tests_per_year.index.min() and year <= tests_per_year.index.max():
                plt.axvline(x=year, color='r', linestyle='--', alpha=0.7)
                plt.text(year, tests_per_year.max() * 0.9, event, rotation=90, 
                         ha='right', va='top', fontsize=10, color='r')
        
        plt.tight_layout()
        plt.show()
        
        # Analyse der Tests nach Ländern/Regionen (basierend auf geografischen Clustern)
        # Definieren bekannter Testgebiete mit ungefähren Koordinaten
        test_sites = {
            'USA (Nevada)': {'lat_range': (35, 40), 'lon_range': (-117, -112)},
            'UdSSR/Russland (Semipalatinsk)': {'lat_range': (47, 52), 'lon_range': (77, 82)},
            'UdSSR/Russland (Nowaja Semlja)': {'lat_range': (70, 77), 'lon_range': (50, 60)},
            'China (Lop Nor)': {'lat_range': (40, 43), 'lon_range': (87, 90)},
            'Frankreich (Pazifik)': {'lat_range': (-25, -20), 'lon_range': (-145, -135)},
            'Indien': {'lat_range': (25, 30), 'lon_range': (70, 75)},
            'Pakistan': {'lat_range': (25, 30), 'lon_range': (63, 68)},
            'Nordkorea': {'lat_range': (40, 42), 'lon_range': (128, 130)}
        }
        
        # Tests nach Standorten zählen
        site_counts = {}
        for site_name, coords in test_sites.items():
            mask = ((nuclear_tests['Latitude'] >= coords['lat_range'][0]) & 
                    (nuclear_tests['Latitude'] <= coords['lat_range'][1]) & 
                    (nuclear_tests['Longitude'] >= coords['lon_range'][0]) & 
                    (nuclear_tests['Longitude'] <= coords['lon_range'][1]))
            site_counts[site_name] = mask.sum()
        
        # Andere Tests (nicht in bekannten Testgebieten)
        total_matched = sum(site_counts.values())
        if total_matched < len(nuclear_tests):
            site_counts['Andere/Unbekannt'] = len(nuclear_tests) - total_matched
        
        # Balkendiagramm der Tests nach Standort
        plt.figure(figsize=(14, 6))
        sites = list(site_counts.keys())
        counts = list(site_counts.values())
        
        # Sortieren nach Anzahl der Tests (absteigend)
        sorted_indices = np.argsort(counts)[::-1]
        sorted_sites = [sites[i] for i in sorted_indices]
        sorted_counts = [counts[i] for i in sorted_indices]
        
        plt.bar(sorted_sites, sorted_counts, alpha=0.7)
        plt.xlabel('Testgebiet', fontsize=12)
        plt.ylabel('Anzahl der Nukleartests', fontsize=12)
        plt.title('Verteilung von Nukleartests nach Testgebieten', fontsize=14)
        plt.xticks(rotation=45, ha='right')
        plt.grid(True, alpha=0.3, axis='y')
        
        plt.tight_layout()
        plt.show()
else:
    print("Keine Nukleartests im Datensatz gefunden.")

Anzahl der Nukleartests im Datensatz: 175

Statistiken der Nukleartests:
Magnitude: Min = 5.5, Max = 6.9, Durchschnitt = 5.85
Tiefe: Min = 0.0 km, Max = 33.0 km, Durchschnitt = 0.30 km

Beispieldaten von Nukleartests:

	Date_Time	Latitude	Longitude	Depth	Magnitude
565	1966-12-20 15:30:01	37.302167	-116.408333	1.2	5.62
897	1968-04-26 15:00:02	37.295333	-116.455667	1.2	5.63
1129	1968-12-19 16:30:01	37.231500	-116.473667	1.4	5.52
1380	1969-09-16 14:30:01	37.314167	-116.460667	1.2	5.82
1532	1970-03-26 19:00:01	37.300500	-116.534167	1.2	5.54

Diese Daten sind, wie schon gesagt, unvollständig, aber der hier gezeigte Ansatz ist grundsätzlich interessant: Oft hat man die Möglichkeit, einfach bestimmte Ereignisse herausfiltern und nur deren Details untersuchen.

5.5 Übungsaufgabe¶

Als Übungsaufgabe möchte ich Sie zu einer Untersuchung des folgenden Datensatzes einladen: World Happiness Index and Inflation Dataset, wieder von der Kaggle-Plattform. Hier finden Sie die folgenden Daten (übernommen von der Kaggle-Beschreibung des Datensatzes):

Country: The name of the country where the data was recorded
Year: The year in which the data was collected.
Continent/Region: The continent or region in which the country is located.
Score: The World Happiness Index score, where higher values indicate greater happiness.
Headline Consumer Price Inflation: The overall inflation rate based on the Consumer Price Index.
Energy Consumer Price Inflation: The inflation rate of energy products based on the Consumer Price Index.
Food Consumer Price Inflation: The inflation rate of food products based on the Consumer Price Index.
Official Core Consumer Price Inflation: The core inflation rate excluding energy and food products.
Producer Price Inflation: The inflation rate based on the Producer Price Index.
GDP deflator Index growth rate: The growth rate of the GDP deflator, which measures price changes in the economy.

Nehmen Sie diese Daten und toben Sie sich aus, äh, finden Sie interessante Zusammenhänge oder zumindest Hinweise darauf über mögliche Korrelationen oder eigene Erkenntnisse aus Ihrer kreativen Visualisierung. Ihrer Fantasie sind keine Grenzen gesetzt.

In [18]:

# Pfad zur CSV-Datei
file_path = os.path.join('data','WHI_Inflation.csv')  # Pfad anpassen, falls nötig

# Einlesen der Daten mit Pandas 
whi_data = pd.read_csv(file_path)

# Was steht in der Datei?
print(whi_data.head())

       Country  Year  Headline Consumer Price Inflation  \
0  Afghanistan  2015                             -0.660   
1  Afghanistan  2016                              4.380   
2  Afghanistan  2017                              4.976   
3  Afghanistan  2018                              0.630   
4  Afghanistan  2019                              2.302   

   Energy Consumer Price Inflation  Food Consumer Price Inflation  \
0                        -4.250000                      -0.840000   
1                         2.070000                       5.670000   
2                         4.440000                       6.940000   
3                         1.474185                      -1.045952   
4                        -2.494359                       3.794770   

   Official Core Consumer Price Inflation  Producer Price Inflation  \
0                                0.219999                       NaN   
1                                5.192760                       NaN   
2                                5.423228                       NaN   
3                               -0.126033                       NaN   
4                                     NaN                       NaN   

   GDP deflator Index growth rate Continent/Region  Score  GDP per Capita  \
0                        2.665090       South Asia  3.575        0.319820   
1                       -2.409509       South Asia  3.360        0.382270   
2                        2.404000       South Asia  3.794        0.401477   
3                        2.071208       South Asia  3.632        0.332000   
4                        6.520928       South Asia  3.203        0.350000   

   Social support  Healthy life expectancy at birth  \
0        0.302850                          0.303350   
1        0.110370                          0.173440   
2        0.581543                          0.180747   
3        0.537000                          0.255000   
4        0.517000                          0.361000   

   Freedom to make life choices  Generosity  Perceptions of corruption  
0                       0.23414    0.365100                   0.097190  
1                       0.16430    0.312680                   0.071120  
2                       0.10618    0.311871                   0.061158  
3                       0.08500    0.191000                   0.036000  
4                       0.00000    0.158000                   0.025000

In [ ]:

5.6 Zusammenfassung der wichtigsten Punkte dieser Einheit¶

Wir haben in dieser Einheit einige Techniken im Umgang mit Daten gesehen. Insbesondere haben wir festgestellt, wie wichtig die anfängliche Kontrolle, Bereinigung und Aufbereitung der Daten vor der weiteren Analyse ist. Für die Auswertung selbst ist natürlich die Visualisierung sehr interessant, aber nicht nur.

Datenaufbereitung und -analyse: Einlesen von CSV-Dateien, Erkennen und Behandeln fehlender Werte, statistische Grundauswertungen mit Pandas und NumPy
Geografische Visualisierung: Darstellung der globalen Erdbebenverteilung im 2D- und 3D-Raum, Visualisierung seismischer Aktivität in verschiedenen tektonischen Regionen
Zeitliche Visualisierung: Erstellung von 2D- und 3D-Animationen zur Visualisierung der Erdbebentätigkeit über mehrere Jahrzehnte
Korrelationsanalyse: Untersuchung des Zusammenhangs zwischen Teilen der Daten, z.B. Erdbebenparametern wie Magnitude und Tiefe, mit statistischen Methoden
Potenzgesetze in Daten: Nachweis und Visualisierung vermuteter Abhängigkeiten in den Daten, z.B. des Gutenberg-Richter-Gesetzes (inverses Potenzgesetz der Erdbebenhäufigkeit)
Dimensionsreduktion: Anwendung der Hauptkomponentenanalyse (PCA) als typisches Beispiel für die Vereinfachung mehrdimensionaler Daten und die nachfolgende Erkennung von Mustern
Vergleichende Analyse: Untersuchung verschiedener Aspekte von Datensegmenten, wie z.B. der Vergleich natürlicher vs. anthropogener seismischer Ereignisse (Erdbeben vs. Nukleartests)
Datenvisualisierungstechniken: Einsatz verschiedener Diagrammtypen für unterschiedliche Aspekte der Datenanalyse (Streudiagramme, Heatmaps, 3D-Plots, Animationen)

FMCA-25 04: Symbolisches Rechnen mit SymPy und numerisches Rechnen mit Numpy

Inhalt des Skriptums seit dem Sommersemester 2025

Hier finden Sie die Kapitel aus den Vergangenen Jahren (legacy):

Die Jupyter-Notebooks zur Legacy-Variante der Lehrveranstaltung finden Sie im zugehörigen GitHub-Repository.

4 Differenzieren und Integrieren: Analytische und Numerische Methoden¶

Einleitung¶

In dieser Einheit beschäftigen wir uns zunächst mit dem hier vielleicht etwas unerwarteten Thema der symbolischen Manipulation von mathematischen Ausdrücken in Python. Danach gehen wir dann den eher erwarteten Schritt in Richtung Numerik und sehen uns einige weitere Funktionen in NumPy an.

Wir tun das zwar auch generell, aber konkret hauptsächlich anhand zweier grundlegender Konzepte der Analysis: Differenzieren und Integrieren. Diese beiden Operationen sind nicht nur in der theoretischen Mathematik von zentraler Bedeutung, sondern finden auch in zahlreichen praktischen Anwendungen wie der Physik, Ingenieurwissenschaften, Wirtschaft und Datenanalyse Verwendung, um nur einige zu nennen.

Nach dem Studium dieser Einheit sollten Sie zumindest folgende drei der wichtigsten Punkte hier verstehen:¶

Den Unterschied zwischen symbolischem und numerischem Rechnen – wann man welchen Ansatz verwendet und wie sie sich ergänzen
Wie man SymPy für symbolische Berechnungen verwendet – insbesondere für Differentiation und Integration, aber auch zum Umformen von Ausdrücken, zum Lösen von Gleichungen, etc.
Wie numerische Methoden zur näherungsweisen Berechnung von Ableitungen und Integralen funktionieren

Begriffliche Übersicht¶

Hier zunächst eine kurze begriffliche Übersicht zu diesen zwei grundlegenden Herangehensweisen an mathematische Berechnungen:

Symbolisches Rechnen: Hierbei arbeitet man mit symbolischen Ausdrücken und mathematischen Formeln, analog dazu, wie man es mit Papier und Bleistift (und Gehirn) täte. Die Bibliothek SymPy ermöglicht uns diese Art des Rechnens in Python.
Numerisches Rechnen: Hier approximieren wir verschiedene mathematische Operationen durch jeweils geeignete numerische Verfahren. Dies ist besonders wichtig für Probleme, die keine geschlossene analytische Lösung haben und hat genau aus diesem Grund viele Türen für die moderne Wissenschaft geöffnet. NumPy und SciPy bieten hierfür effiziente Implementierungen.

Inhaltlich werden wir beide Ansätze vor allem für Differentiation und Integration untersuchen und ihre jeweiligen Vor- und Nachteile verstehen lernen. Daher möchte ich Ihnen kurz zusammenfassen, warum diese Konzepte so wichtig sind:

Differentiation hilft uns, Veränderungsraten zu verstehen, Extremwerte zu finden und das Verhalten von Funktionen zu analysieren. Die Ableitung einer Funktion nach der Zeit gibt eine “Geschwindigkeit” für die durch die Funktion dargestellte Größe an. Die zweite Ableitung dazu beschreibt die zugehörige “Beschleunigung”. Ebenso interessant ist z.B. eine räumliche Veränderung, die durch die Ableitung(en) nach Raum-Koordinaten beschrieben wird. Und das Konzept lässt sich auf (fast) beliebige Variablen in (fast) beliebigen Räumen verallgemeinern.
Integration ermöglicht uns, Flächen und Volumina zu berechnen, Gesamteffekte zu akkumulieren und Differentialgleichungen zu lösen. Ganz allgemein beschreibt das Integral jede Art von “Inhalt”, der in einem “Raum” gilt, je nach Variablen und Raumdimensionen. Die Integration hat für die Differentiation außerdem die Rolle einer Gegenspielerin.

Lassen Sie uns nun mit dem symbolischen Rechnen beginnen, einem leistungsstarken Werkzeug für mathematische Analyse. Für die Code-Beispiele sorgt in gewohnter Manier Claude 3.7 Sonnet.

4.1 Symbolisches Rechnen mit SymPy¶

4.1.1 Einführung in SymPy: Symbolische Mathematik in Python¶

Symbolisches Rechnen ist eine Form der Berechnung, bei der wir mit mathematischen Symbolen und Formeln arbeiten, anstatt mit konkreten numerischen Werten. Dies ermöglicht uns:

Exakte Berechnungen ohne Rundungsfehler
Das Herleiten allgemeiner Formeln mit Parametern
Das Vereinfachen komplexer Ausdrücke
Das Lösen von Gleichungen in allgemeiner Form
In weiterer Folge das Berechnen von Ableitungen und je nach Lösbarkeit auch von Integralen

SymPy ist eine Python-Bibliothek für symbolische Mathematik, die diese Art des Rechnens ermöglicht. Sie ist besonders nützlich für:

Algebraische Manipulationen
Differenzieren und Integrieren
Lösen von Gleichungen und Gleichungssystemen
Arbeiten mit jeglichen Objekten auf symbolischer Ebene
Taylor- und andere Reihenentwicklungen
Grenzwertberechnungen

Lassen Sie uns zunächst die notwendigen Bibliotheken importieren:

In [1]:

import sympy as sp
import numpy as np
import matplotlib.pyplot as plt
from sympy import symbols, simplify, expand, factor, solve, diff, integrate
from sympy import sin, cos, tan, exp, log, sqrt, pi

# Für schönere Ausgabe der symbolischen Ausdrücke
from sympy.interactive import printing
printing.init_printing(use_unicode=True)

# Für numerische Berechnungen und Visualisierung der Ergebnisse
import numpy as np
import matplotlib.pyplot as plt

# Für später: Numerische Integration
from scipy import integrate as sciint

4.1.2 Definition symbolischer Variablen und Funktionen¶

Der erste Schritt beim symbolischen Rechnen ist die Definition von Symbolen, die als Platzhalter für Variablen oder Parameter dienen:

In [2]:

# Einzelne Symbole definieren
x = sp.Symbol('x')
y = sp.Symbol('y')
z = sp.Symbol('z')

# Mehrere Symbole auf einmal definieren
a, b, c = sp.symbols('a b c')

# Parameter mit Annahmen definieren (z.B., dass ein Symbol reell oder positiv ist)
t = sp.Symbol('t', real=True)
r = sp.Symbol('r', positive=True)

# Zeit- oder ortsabhängige Funktionen definieren
f = sp.Function('f')(t)
g = sp.Function('g')(x, y)  # Funktion mit zwei Variablen

print("Definierte Symbole:", x, y, z, a, b, c)
print("Symbol mit Annahmen:", r, "ist positiv:", r.is_positive)
print("Funktionssymbole:", f, g)

Definierte Symbole: x y z a b c
Symbol mit Annahmen: r ist positiv: True
Funktionssymbole: f(t) g(x, y)

Mit diesen Symbolen können wir nun mathematische Ausdrücke erstellen. Beachten Sie, dass die hier verwendeten Funktionen oben explizit aus der SymPy-Bibliothek importiert wurden. Das muss so sein, damit SymPy die funktions-spezifischen Eigenschaften etwa der Sinusfunktion kennt. Die Standardfunktion sin()in Python leistet NICHT dasselbe. Z.B. steht also sin(x) hier de facto für sp.sin(x). Konkrete Beispiele für mathematische Funktionen und Ausdrücke:

In [3]:

# Einfache algebraische Ausdrücke
expr1 = x**2 + 2*x + 1
expr2 = y**3 - 3*y + 5

# Trigonometrische Funktionen
expr3 = sin(x)**2 + cos(x)**2
expr4 = sin(2*x) - 2*sin(x)*cos(x)

# Exponential- und Logarithmusfunktionen
expr5 = exp(x) + exp(-x)
expr6 = log(x*y) - log(x) - log(y)

# Ausdrücke anzeigen
print("Quadratischer Ausdruck:", expr1)
print("Trigonometrische Identität:", expr3)
print("Logarithmus-Eigenschaft:", expr6)

Quadratischer Ausdruck: x**2 + 2*x + 1
Trigonometrische Identität: sin(x)**2 + cos(x)**2
Logarithmus-Eigenschaft: -log(x) - log(y) + log(x*y)

4.1.3 Symbolische Manipulation und Vereinfachung von Ausdrücken¶

Eine der Stärken von SymPy ist die Fähigkeit, symbolische Ausdrücke zu manipulieren und zu vereinfachen. Das ist oft hilfreich, wenn eine numerische Lösung die Hardware überfordert oder um bestimmte Grenz- oder Spezialfälle abzuklären. Hier ein paar konkrete Beispiele, was man alles tun kann:

In [4]:

# Ausdrücke vereinfachen
simple_expr = simplify(expr3)  # sin²(x) + cos²(x) sollte 1 ergeben
print("Vereinfachung von sin²(x) + cos²(x):", simple_expr)

simple_expr2 = simplify(expr4)  # sin(2x) - 2sin(x)cos(x) sollte 0 ergeben
print("Vereinfachung von sin(2x) - 2sin(x)cos(x):", simple_expr2)

# Ausdrücke ausmultiplizieren
expanded = expand((x + y)**3)
print("Ausmultiplizieren von (x + y)³:", expanded)

# Ausdrücke faktorisieren
factored = factor(x**2 + 2*x + 1)
print("Faktorisieren von x² + 2x + 1:", factored)

# Terme zusammenfassen
collected = sp.collect(x**2 + y*x + x*y + y**2, x)
print("Zusammenfassen nach x in x² + y*x + x*y + y²:", collected)

# Substitution von Werten oder Ausdrücken
expr_with_subs = (x**2 + y).subs(x, 2)
print("(x² + y) mit x=2:", expr_with_subs)

# Komplexere Substitution
expr_subs_expr = (x**2 + y).subs(x, sin(z))
print("(x² + y) mit x=sin(z):", expr_subs_expr)

Vereinfachung von sin²(x) + cos²(x): 1
Vereinfachung von sin(2x) - 2sin(x)cos(x): 0
Ausmultiplizieren von (x + y)³: x**3 + 3*x**2*y + 3*x*y**2 + y**3
Faktorisieren von x² + 2x + 1: (x + 1)**2
Zusammenfassen nach x in x² + y*x + x*y + y²: x**2 + 2*x*y + y**2
(x² + y) mit x=2: y + 4
(x² + y) mit x=sin(z): y + sin(z)**2

4.1.4 Umwandlung symbolischer Ausdrücke in numerische Funktionen¶

Obwohl es uns hier in erster Linie um die symbolische Manipulation von Ausdrücken geht, möchte man vermutlich auch irgendwann symbolische Ausdrücke in numerische Funktionen umwandeln, z.B. um sie mit konkreten Werten auszuwerten oder zu visualisieren:

In [5]:

# Einfacher symbolischer Ausdruck
expr = sin(x)**2 * exp(-x/10)

# Umwandlung in eine Python-Funktion mit lambdify
f_numpy = sp.lambdify(x, expr, "numpy")

# Numerische Auswertung
x_values = np.linspace(0, 10, 100)
y_values = f_numpy(x_values)

# Visualisierung
plt.figure(figsize=(10, 6))
plt.plot(x_values, y_values)
plt.title(rf'$f(x) = {sp.latex(expr)}$')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.grid(True)
plt.show()

# Funktion mit mehreren Variablen
expr_multi = x**2 + 2*y**2 + sin(x*y)
f_multi = sp.lambdify((x, y), expr_multi, "numpy")

# Auswertung für bestimmte Werte
print(f"f(2, 3) = {f_multi(2, 3)}")

# Auswertung über einen Bereich für 3D-Plot
x_vals = np.linspace(-3, 3, 50)
y_vals = np.linspace(-3, 3, 50)
X, Y = np.meshgrid(x_vals, y_vals)
Z = f_multi(X, Y)

# 3D-Visualisierung
fig = plt.figure(figsize=(10, 8))
ax = fig.add_subplot(111, projection='3d')
surf = ax.plot_surface(X, Y, Z, cmap='viridis', alpha=0.8)
ax.set_xlabel('x')
ax.set_ylabel('y')
ax.set_zlabel('f(x,y)')
ax.set_title(rf'$f(x,y) = {sp.latex(expr_multi)}$')
plt.show()

f(2, 3) = 21.720584501801074

4.1.5 Symbolisches und numerisches Lösen von Gleichungen in SymPy¶

Eine weitere wichtige Funktion von SymPy ist das Lösen von Gleichungen. Im Gegensatz zu numerischen Methoden, die Näherungslösungen liefern, kann SymPy oft exakte Lösungen finden:

In [6]:

# Einfache Gleichung lösen
eq1 = sp.Eq(x**2 - 4, 0)  # x² - 4 = 0
solution1 = sp.solve(eq1, x)
print(f"Lösungen von {eq1}: {solution1}")

# Gleichung direkt als Ausdruck lösen
solution2 = sp.solve(x**3 - 6*x**2 + 11*x - 6, x)
print(f"Lösungen von x³ - 6x² + 11x - 6 = 0: {solution2}")

# Gleichung mit Parametern lösen
k = sp.Symbol('k')
eq_param = sp.Eq(x**2 + k*x + 1, 0)
solution_param = sp.solve(eq_param, x)
print(f"Lösungen von {eq_param}:\n{solution_param}")

# System von Gleichungen lösen
eq_system = [sp.Eq(x + y, 2), sp.Eq(x - y, 4)]
solution_system = sp.solve(eq_system, (x, y))
print(f"Lösung des Gleichungssystems {eq_system}: {solution_system}")

# Transzendente Gleichung lösen
eq_trans = sp.Eq(sp.sin(x), sp.cos(x))
solution_trans = sp.solve(eq_trans, x)
print(f"Lösungen von {eq_trans}: {solution_trans}")

# Gleichung numerisch lösen
from sympy import nsolve
eq_numeric = sp.Eq(sp.sin(x) - x**2, 0)
solution_numeric = nsolve(eq_numeric, x, 0.5)  # Startwert 0.5
print(f"Numerische Lösung von {eq_numeric} in der Nähe von 0.5: {solution_numeric}")

# Gleichung mit Ungleichung
from sympy import symbols, solve_univariate_inequality, sin, pi
x = symbols('x')
solution_ineq = solve_univariate_inequality(sin(x) > 0.5, x)
print(f"Lösung der Ungleichung sin(x) > 0.5: {solution_ineq}")

Lösungen von Eq(x**2 - 4, 0): [-2, 2]
Lösungen von x³ - 6x² + 11x - 6 = 0: [1, 2, 3]
Lösungen von Eq(k*x + x**2 + 1, 0):
[-k/2 - sqrt(k**2 - 4)/2, -k/2 + sqrt(k**2 - 4)/2]
Lösung des Gleichungssystems [Eq(x + y, 2), Eq(x - y, 4)]: {x: 3, y: -1}
Lösungen von Eq(sin(x), cos(x)): [pi/4]
Numerische Lösung von Eq(-x**2 + sin(x), 0) in der Nähe von 0.5: 0.876726215395062
Lösung der Ungleichung sin(x) > 0.5: (0.523598775598299 < x) & (x < -0.523598775598299 + pi)

4.2 Symbolisches Differenzieren mit SymPy¶

Die Ableitung einer Funktion gibt uns Informationen über ihre Änderungsrate, in anderen Worten über die Steigung des Funktionsgraphen an jedem Punkt, an dem die Funktion differenzierbar ist. In SymPy können wir Ableitungen symbolisch berechnen, was ich mir am Anfang meines Studiums jedenfalls zunutze gemacht hätte. Man kann so etwas z.B. in folgenden Situationen und Aufgabenbereichen brauchen:

Extremwertprobleme
Analyse des Verhaltens von Funktionen
Lösen von Differentialgleichungen
Annäherung von Funktionen durch Taylor- oder andere Reihenentwicklungen

4.2.1 Berechnung von Ableitungen mit SymPy¶

SymPy bietet uns die Möglichkeit, Ableitungen auf verschiedene Weisen zu berechnen:

In [7]:

# Verschiedene Methoden zum Berechnen von Ableitungen
x, y = sp.symbols('x y')

# Methode 1: diff()-Funktion
f1 = x**3 + x**2 - 2*x + 1
df1_dx = sp.diff(f1, x)
print(f"f(x) = {f1}")
print(f"f'(x) = {df1_dx}")

# Methode 2: Diff-Operator (für mathematisch ansprechendere Darstellung)
f2 = sp.sin(x) * sp.exp(x)
df2_dx = sp.Derivative(f2, x)
print(f"Formale Darstellung der Ableitung: {df2_dx}")
print(f"Berechnete Ableitung: {df2_dx.doit()}")

# Höhere Ableitungen
f3 = sp.log(x)
df3_dx2 = sp.diff(f3, x, 2)  # Zweite Ableitung
print(f"f(x) = {f3}")
print(f"f''(x) = {df3_dx2}")

# Komplexere Funktionen
f4 = sp.sin(x**2) / x
df4_dx = sp.diff(f4, x)
print(f"f(x) = {f4}")
print(f"f'(x) = {df4_dx}")
print(f"Vereinfachte f'(x) = {sp.simplify(df4_dx)}")

# Ableitung an einer bestimmten Stelle auswerten
f5 = x**4 - 4*x**3 + 6*x**2
df5_dx = sp.diff(f5, x)
df5_at_2 = df5_dx.subs(x, 2)
print(f"f(x) = {f5}")
print(f"f'(x) = {df5_dx}")
print(f"f'(2) = {df5_at_2}")

# Ableitung implizit definierter Funktionen
# Für die implizite Funktion x²+y²=1
implicit_eq = x**2 + y**2 - 1
# Um dy/dx zu finden, verwenden wir die implizite Differentiation
# Total differential: 2x + 2y·(dy/dx) = 0
# Umstellung: dy/dx = -x/y
dy_dx = -sp.diff(implicit_eq, x) / sp.diff(implicit_eq, y)
print(f"Für die implizite Funktion {implicit_eq} = 0 ist dy/dx = {dy_dx}")

# Ableitungen von parametrischen Funktionen
t = sp.Symbol('t')
x_t = sp.cos(t)
y_t = sp.sin(t)
# Die Steigung ist dy/dx = (dy/dt)/(dx/dt)
dx_dt = sp.diff(x_t, t)
dy_dt = sp.diff(y_t, t)
slope = dy_dt / dx_dt
print(f"Für die parametrische Kurve x(t)={x_t}, y(t)={y_t} ist dy/dx = {slope}")
print(f"Vereinfacht: dy/dx = {sp.simplify(slope)}")

f(x) = x**3 + x**2 - 2*x + 1
f'(x) = 3*x**2 + 2*x - 2
Formale Darstellung der Ableitung: Derivative(exp(x)*sin(x), x)
Berechnete Ableitung: exp(x)*sin(x) + exp(x)*cos(x)
f(x) = log(x)
f''(x) = -1/x**2
f(x) = sin(x**2)/x
f'(x) = 2*cos(x**2) - sin(x**2)/x**2
Vereinfachte f'(x) = 2*cos(x**2) - sin(x**2)/x**2
f(x) = x**4 - 4*x**3 + 6*x**2
f'(x) = 4*x**3 - 12*x**2 + 12*x
f'(2) = 8
Für die implizite Funktion x**2 + y**2 - 1 = 0 ist dy/dx = -x/y
Für die parametrische Kurve x(t)=cos(t), y(t)=sin(t) ist dy/dx = -cos(t)/sin(t)
Vereinfacht: dy/dx = -1/tan(t)

4.2.2 Mehrfache Partielle Ableitungen und Gradient¶

Bei Funktionen mehrerer Variablen werden partielle Ableitungen verwendet, um die Veränderungsrate einer Variablen bei konstant gehaltenen anderen Variablen zu beschreiben. Diese sind besonders wichtig in der Vektoranalysis, Optimierung und bei partiellen Differentialgleichungen:

In [8]:

# Funktion zweier Variablen
x, y, z = sp.symbols('x y z')
f = x**2 * y + sp.sin(y) * sp.exp(x)

# Partielle Ableitung nach x
df_dx = sp.diff(f, x)
print(f"f(x,y) = {f}")
print(f"∂f/∂x = {df_dx}")

# Partielle Ableitung nach y
df_dy = sp.diff(f, y)
print(f"∂f/∂y = {df_dy}")

# Mehrfache partielle Ableitungen
d2f_dx2 = sp.diff(f, x, 2)  # Zweite Ableitung nach x
d2f_dxdy = sp.diff(df_dx, y)  # Gemischte zweite Ableitung
print(f"∂²f/∂x² = {d2f_dx2}")
print(f"∂²f/∂x∂y = {d2f_dxdy}")

# Schwarz'scher Satz: Die Reihenfolge der Differentiation ist egal
d2f_dydx = sp.diff(df_dy, x)
print(f"∂²f/∂y∂x = {d2f_dydx}")
print(f"Sind die gemischten Ableitungen gleich? {d2f_dxdy == d2f_dydx}")

# Gradient berechnen
gradient = [sp.diff(f, var) for var in (x, y)]
print(f"∇f = ({gradient[0]}, {gradient[1]})")

# Gradient als Vektor
from sympy import Matrix
grad_vector = Matrix(gradient)
print("Gradient als Vektor:")
grad_vector

# Gradient an einem bestimmten Punkt auswerten
point = {x: 1, y: 2}
grad_at_point = [expr.subs(point) for expr in gradient]
print(f"∇f an Punkt (1,2) = ({grad_at_point[0]}, {grad_at_point[1]})")

# Gradient für eine Funktion von drei Variablen
g = x**2 + y**2 + z**2 + x*y*z
grad_g = [sp.diff(g, var) for var in (x, y, z)]
print(f"g(x,y,z) = {g}")
print(f"∇g = ({grad_g[0]}, {grad_g[1]}, {grad_g[2]})")

# Anwendung: Richtungsableitung berechnen
# Die Richtungsableitung in Richtung eines Vektors v ist ∇f·v/|v|
v = Matrix([1, 1])  # Richtungsvektor
v_norm = sp.sqrt(v.dot(v))  # Normierung
dir_deriv = (Matrix(gradient).dot(v)) / v_norm
print(f"Richtungsableitung von f in Richtung {v}: {dir_deriv}")

f(x,y) = x**2*y + exp(x)*sin(y)
∂f/∂x = 2*x*y + exp(x)*sin(y)
∂f/∂y = x**2 + exp(x)*cos(y)
∂²f/∂x² = 2*y + exp(x)*sin(y)
∂²f/∂x∂y = 2*x + exp(x)*cos(y)
∂²f/∂y∂x = 2*x + exp(x)*cos(y)
Sind die gemischten Ableitungen gleich? True
∇f = (2*x*y + exp(x)*sin(y), x**2 + exp(x)*cos(y))
Gradient als Vektor:
∇f an Punkt (1,2) = (E*sin(2) + 4, E*cos(2) + 1)
g(x,y,z) = x**2 + x*y*z + y**2 + z**2
∇g = (2*x + y*z, x*z + 2*y, x*y + 2*z)
Richtungsableitung von f in Richtung Matrix([[1], [1]]): sqrt(2)*(x**2 + 2*x*y + exp(x)*sin(y) + exp(x)*cos(y))/2

4.2.3 Beispiel Kurvendiskussion: Nullstellen, Extremwerte, Wendepunkte¶

Ein klassisches Anwendungsbeispiel der Differentialrechnung ist die Kurvendiskussion, bei der wir das Verhalten einer Funktion analysieren. Mit SymPy können wir diesen Prozess systematisch und gleichzeitig automatisch und hauptsächlich symbolisch durchführen:

In [9]:

# Beispiel für eine Kurvendiskussion
x = sp.Symbol('x')
f = x**4 - 4*x**3 + 4*x**2 - 4

# 1. Definitionsbereich
# Die Funktion ist polynomiell, also ist der Definitionsbereich ℝ
print("Definitionsbereich: ℝ")

# 2. Nullstellen finden
zeros = sp.solve(f, x)
print(f"Nullstellen von f(x) = {f}:")
for i, zero in enumerate(zeros):
    print(f"x_{i+1} = {zero}")

# 3. Erste Ableitung für Extremwerte
f_prime = sp.diff(f, x)
print(f"f'(x) = {f_prime}")

# Kritische Punkte (f'(x) = 0)
critical_points = sp.solve(f_prime, x)
print("Kritische Punkte (f'(x) = 0):")
for i, cp in enumerate(critical_points):
    print(f"x_{i+1} = {cp}")

# 4. Zweite Ableitung für Minimum/Maximum-Test
f_double_prime = sp.diff(f, x, 2)
print(f"f''(x) = {f_double_prime}")

# Test der kritischen Punkte
print("\nUntersuchung der kritischen Punkte:")
for cp in critical_points:
    cp_value = float(cp)
    f_at_cp = f.subs(x, cp)
    f_double_prime_at_cp = f_double_prime.subs(x, cp)
    
    if f_double_prime_at_cp > 0:
        extremum_type = "lokales Minimum"
    elif f_double_prime_at_cp < 0:
        extremum_type = "lokales Maximum"
    else:
        extremum_type = "Wende- oder Sattelpunkt (weiterer Test nötig)"
    
    print(f"x = {cp_value:.6f}: f(x) = {float(f_at_cp):.6f}, f''(x) = {float(f_double_prime_at_cp):.6f} => {extremum_type}")

# 5. Wendepunkte (f''(x) = 0)
inflection_points = sp.solve(f_double_prime, x)
print("\nWendepunkte (f''(x) = 0):")
for ip in inflection_points:
    ip_value = float(ip)
    f_at_ip = f.subs(x, ip)
    f_triple_prime_at_ip = sp.diff(f, x, 3).subs(x, ip)
    
    if f_triple_prime_at_ip != 0:
        print(f"x = {ip_value:.6f}: f(x) = {float(f_at_ip):.6f} => Wendepunkt")
    else:
        print(f"x = {ip_value:.6f}: f(x) = {float(f_at_ip):.6f} => Kein Wendepunkt")

# 6. Verhalten im Unendlichen
print("\nVerhalten für x → ±∞:")
leading_term = sp.Poly(f, x).all_coeffs()[0] * x**sp.Poly(f, x).degree()
print(f"Dominanter Term: {leading_term}")
if leading_term.coeff(x**sp.Poly(f, x).degree()) > 0:
    print("f(x) → +∞ für x → ±∞")
else:
    print("f(x) → +∞ für x → +∞")
    print("f(x) → -∞ für x → -∞")

# 7. Grafische Darstellung
import numpy as np
import matplotlib.pyplot as plt

# Funktion in numpy-Format konvertieren
f_numpy = sp.lambdify(x, f, "numpy")
x_vals = np.linspace(-1, 5, 1000)
y_vals = f_numpy(x_vals)

plt.figure(figsize=(12, 8))
plt.plot(x_vals, y_vals, 'b-', linewidth=2, label=f'f(x) = {sp.latex(f)}')

# Nullstellen markieren
for zero in zeros:
    try:
        zero_val = float(zero)
        plt.plot(zero_val, 0, 'ro', markersize=8)
        plt.annotate(f'Nullstelle\n({zero_val:.2f}, 0)', 
                     xy=(zero_val, 0), 
                     xytext=(zero_val+0.3, -1),
                     arrowprops=dict(arrowstyle="->", color="red"))
    except:
        pass  # Für komplexe Nullstellen

# Extrempunkte markieren
for cp in critical_points:
    try:
        cp_val = float(cp)
        f_at_cp = float(f.subs(x, cp))
        
        if float(f_double_prime.subs(x, cp)) > 0:
            marker_color = 'go'  # Grün für Minima
            point_type = 'Minimum'
        else:
            marker_color = 'mo'  # Magenta für Maxima
            point_type = 'Maximum'
            
        plt.plot(cp_val, f_at_cp, marker_color, markersize=8)
        plt.annotate(f'{point_type}\n({cp_val:.2f}, {f_at_cp:.2f})', 
                     xy=(cp_val, f_at_cp), 
                     xytext=(cp_val-0.5, f_at_cp+2),
                     arrowprops=dict(arrowstyle="->"))
    except:
        pass  # Für komplexe kritische Punkte

# Wendepunkte markieren
for ip in inflection_points:
    try:
        ip_val = float(ip)
        f_at_ip = float(f.subs(x, ip))
        
        if float(sp.diff(f, x, 3).subs(x, ip)) != 0:
            plt.plot(ip_val, f_at_ip, 'ys', markersize=8)  # Gelbes Quadrat für Wendepunkte
            plt.annotate(f'Wendepunkt\n({ip_val:.2f}, {f_at_ip:.2f})', 
                        xy=(ip_val, f_at_ip), 
                        xytext=(ip_val+0.5, f_at_ip-2),
                        arrowprops=dict(arrowstyle="->", color="orange"))
    except:
        pass

plt.grid(True)
plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)
plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)
plt.legend()
plt.title('Kurvendiskussion')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.ylim(-5,1)
plt.show()

# 8. Zusammenfassung der Kurvendiskussion
print("\nZusammenfassung der Kurvendiskussion für f(x) =", f)
print(f"- Definitionsbereich: ℝ")
print(f"- Nullstellen: {zeros}")
print(f"- Extrempunkte: {critical_points}")
print(f"- Wendepunkte: {inflection_points}")

Definitionsbereich: ℝ
Nullstellen von f(x) = x**4 - 4*x**3 + 4*x**2 - 4:
x_1 = 1 - sqrt(3)
x_2 = 1 + sqrt(3)
x_3 = 1 - I
x_4 = 1 + I
f'(x) = 4*x**3 - 12*x**2 + 8*x
Kritische Punkte (f'(x) = 0):
x_1 = 0
x_2 = 1
x_3 = 2
f''(x) = 4*(3*x**2 - 6*x + 2)

Untersuchung der kritischen Punkte:
x = 0.000000: f(x) = -4.000000, f''(x) = 8.000000 => lokales Minimum
x = 1.000000: f(x) = -3.000000, f''(x) = -4.000000 => lokales Maximum
x = 2.000000: f(x) = -4.000000, f''(x) = 8.000000 => lokales Minimum

Wendepunkte (f''(x) = 0):
x = 0.422650: f(x) = -3.555556 => Wendepunkt
x = 1.577350: f(x) = -3.555556 => Wendepunkt

Verhalten für x → ±∞:
Dominanter Term: x**4
f(x) → +∞ für x → ±∞

Zusammenfassung der Kurvendiskussion für f(x) = x**4 - 4*x**3 + 4*x**2 - 4
- Definitionsbereich: ℝ
- Nullstellen: [1 - sqrt(3), 1 + sqrt(3), 1 - I, 1 + I]
- Extrempunkte: [0, 1, 2]
- Wendepunkte: [1 - sqrt(3)/3, sqrt(3)/3 + 1]

4.3 Symbolisches Integrieren mit SymPy¶

Integration ist die Umkehrung der Differentiation und ein fundamentales Konzept in der Analysis. Während die Differentiation die Steigung oder Veränderungsrate einer Funktion bestimmt, gibt die Integration die Fläche unter einer Kurve oder die Akkumulation von Veränderungen an.

4.3.1 Unbestimmte und bestimmte Integrale mit SymPy¶

In SymPy können wir sowohl unbestimmte als auch bestimmte Integrale berechnen:

Unbestimmte Integrale geben eine Stammfunktion zurück (eine Funktion, deren Ableitung die ursprüngliche Funktion ist), die eine beliebige Konstante enthält.
Bestimmte Integrale berechnen den Wert der Funktion zwischen zwei Grenzen und liefern einen konkreten Wert.

In [10]:

# Unbestimmte Integrale
x = sp.Symbol('x')
from IPython.display import display, Math

# Einfache Integrale
f1 = x**2
F1 = sp.integrate(f1, x)
display(Math(r"\int " + sp.latex(f1) + r" \, dx = " + sp.latex(F1)))
display(Math(r"\text{Überprüfung: } \frac{d}{dx}\left(" + sp.latex(F1) + r"\right) = " + sp.latex(sp.diff(F1, x))))

# Trigonometrische Funktionen
f2 = sp.sin(x)
F2 = sp.integrate(f2, x)
display(Math(r"\int " + sp.latex(f2) + r" \, dx = " + sp.latex(F2)))

# Exponentialfunktionen
f3 = sp.exp(x)
F3 = sp.integrate(f3, x)
display(Math(r"\int " + sp.latex(f3) + r" \, dx = " + sp.latex(F3)))

# Logarithmische Funktionen
f4 = 1/x
F4 = sp.integrate(f4, x)
display(Math(r"\int " + sp.latex(f4) + r" \, dx = " + sp.latex(F4)))

# Komplexere Integrale
f5 = x * sp.exp(x**2)
F5 = sp.integrate(f5, x)
display(Math(r"\int " + sp.latex(f5) + r" \, dx = " + sp.latex(F5)))
display(Math(r"\text{Überprüfung: } \frac{d}{dx}\left(" + sp.latex(F5) + r"\right) = " + sp.latex(sp.simplify(sp.diff(F5, x)))))

f6 = sp.sin(x)**2 * sp.cos(x)
F6 = sp.integrate(f6, x)
display(Math(r"\int " + sp.latex(f6) + r" \, dx = " + sp.latex(F6)))
display(Math(r"\text{Vereinfacht: } " + sp.latex(sp.simplify(F6))))

# Substitutionsmethode (automatisch von SymPy angewendet)
f7 = x / (x**2 + 1)
F7 = sp.integrate(f7, x)
display(Math(r"\int " + sp.latex(f7) + r" \, dx = " + sp.latex(F7)))

# Partielle Integration (automatisch von SymPy angewendet)
f8 = x * sp.sin(x)
F8 = sp.integrate(f8, x)
display(Math(r"\int " + sp.latex(f8) + r" \, dx = " + sp.latex(F8)))
display(Math(r"\text{Überprüfung: } \frac{d}{dx}\left(" + sp.latex(F8) + r"\right) = " + sp.latex(sp.simplify(sp.diff(F8, x)))))

# Bestimmte Integrale
a, b = sp.symbols('a b')

# Einfaches bestimmtes Integral
g1 = x**2
G1 = sp.integrate(g1, (x, 0, 1))
display(Math(r"\int_{0}^{1} " + sp.latex(g1) + r" \, dx = " + sp.latex(G1)))

# Bestimmtes Integral mit symbolischen Grenzen
G1_sym = sp.integrate(g1, (x, a, b))
display(Math(r"\int_{" + sp.latex(a) + r"}^{" + sp.latex(b) + r"} " + sp.latex(g1) + r" \, dx = " + sp.latex(G1_sym)))

# Trigonometrisches bestimmtes Integral
g2 = sp.sin(x)
G2 = sp.integrate(g2, (x, 0, sp.pi))
display(Math(r"\int_{0}^{\pi} " + sp.latex(g2) + r" \, dx = " + sp.latex(G2)))

# Andere bestimmte Integrale
g3 = 1/(1 + x**2)
G3 = sp.integrate(g3, (x, 0, 1))
display(Math(r"\int_{0}^{1} " + sp.latex(g3) + r" \, dx = " + sp.latex(G3)))
print(f"≈ {float(G3)}")

# Uneigentliches Integral (unendliche Grenze)
g4 = sp.exp(-x)
G4 = sp.integrate(g4, (x, 0, sp.oo))  # sp.oo steht für Unendlich
display(Math(r"\int_{0}^{\infty} " + sp.latex(g4) + r" \, dx = " + sp.latex(G4)))

# Gaussche Glockenkurve
g5 = sp.exp(-x**2)
G5 = sp.integrate(g5, (x, -sp.oo, sp.oo))
display(Math(r"\int_{-\infty}^{\infty} " + sp.latex(g5) + r" \, dx = " + sp.latex(G5)))

# Integration mit Parameter
t = sp.Symbol('t')
g6 = sp.exp(-t*x)
G6 = sp.integrate(g6, (x, 0, sp.oo))
display(Math(r"\int_{0}^{\infty} " + sp.latex(g6) + r" \, dx = " + sp.latex(G6) + r" \text{ (gültig für Re(t) > 0)}"))

# Piecewise-Funktionen (stückweise definierte Funktionen)
g7 = sp.Piecewise((1, x <= 0), (sp.exp(-x), x > 0))
G7 = sp.integrate(g7, (x, -1, 1))
display(Math(r"\int_{-1}^{1} " + sp.latex(g7) + r" \, dx = " + sp.latex(G7)))

$\displaystyle \int x^{2} \, dx = \frac{x^{3}}{3}$

$\displaystyle \text{Überprüfung: } \frac{d}{dx}\left(\frac{x^{3}}{3}\right) = x^{2}$

$\displaystyle \int \sin{\left(x \right)} \, dx = – \cos{\left(x \right)}$

$\displaystyle \int e^{x} \, dx = e^{x}$

$\displaystyle \int \frac{1}{x} \, dx = \log{\left(x \right)}$

$\displaystyle \int x e^{x^{2}} \, dx = \frac{e^{x^{2}}}{2}$

$\displaystyle \text{Überprüfung: } \frac{d}{dx}\left(\frac{e^{x^{2}}}{2}\right) = x e^{x^{2}}$

$\displaystyle \int \sin^{2}{\left(x \right)} \cos{\left(x \right)} \, dx = \frac{\sin^{3}{\left(x \right)}}{3}$

$\displaystyle \text{Vereinfacht: } \frac{\sin^{3}{\left(x \right)}}{3}$

$\displaystyle \int \frac{x}{x^{2} + 1} \, dx = \frac{\log{\left(x^{2} + 1 \right)}}{2}$

$\displaystyle \int x \sin{\left(x \right)} \, dx = – x \cos{\left(x \right)} + \sin{\left(x \right)}$

$\displaystyle \text{Überprüfung: } \frac{d}{dx}\left(- x \cos{\left(x \right)} + \sin{\left(x \right)}\right) = x \sin{\left(x \right)}$

$\displaystyle \int_{0}^{1} x^{2} \, dx = \frac{1}{3}$

$\displaystyle \int_{a}^{b} x^{2} \, dx = – \frac{a^{3}}{3} + \frac{b^{3}}{3}$

$\displaystyle \int_{0}^{\pi} \sin{\left(x \right)} \, dx = 2$

$\displaystyle \int_{0}^{1} \frac{1}{x^{2} + 1} \, dx = \frac{\pi}{4}$

≈ 0.7853981633974483

$\displaystyle \int_{0}^{\infty} e^{- x} \, dx = 1$

$\displaystyle \int_{-\infty}^{\infty} e^{- x^{2}} \, dx = \sqrt{\pi}$

$\displaystyle \int_{0}^{\infty} e^{- t x} \, dx = \begin{cases} \frac{1}{t} & \text{for}\: \left|{\arg{\left(t \right)}}\right| < \frac{\pi}{2} \\\int\limits_{0}^{\infty} e^{- t x}\, dx & \text{otherwise} \end{cases} \text{ (gültig für Re(t) > 0)}$

$\displaystyle \int_{-1}^{1} \begin{cases} 1 & \text{for}\: x \leq 0 \\e^{- x} & \text{otherwise} \end{cases} \, dx = 2 – e^{-1}$

4.3.2 Spezialfälle und nicht-elementare Integrale¶

Nicht alle Integrale können in Form von elementaren Funktionen (algebraische, trigonometrische, exponentielle oder logarithmische Funktionen) ausgedrückt werden. In solchen Fällen müssen spezielle Funktionen oder numerische Methoden verwendet werden:

In [11]:

# Nicht-elementare Integrale
x = sp.Symbol('x')
from IPython.display import display, Math, Markdown

# Fehler-Funktion (Error Function)
f1 = sp.exp(-x**2)
F1 = sp.integrate(f1, x)
display(Math(r"\int " + sp.latex(f1) + r" \, dx = " + sp.latex(F1)))

# Lösungen mit speziellen Funktionen
display(Markdown("**Die Fehlerfunktion erf(x) ist definiert als:**"))
display(Math(r"\text{erf}(x) = \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} \, dt"))

# Integrale, die elliptische Integrale verwenden
f2 = 1/sp.sqrt(1 - x**4)
F2 = sp.integrate(f2, x)
display(Math(r"\int " + sp.latex(f2) + r" \, dx = " + sp.latex(F2)))

# Fresnel-Integrale
f3 = sp.sin(x**2)
F3 = sp.integrate(f3, x)
display(Math(r"\int " + sp.latex(f3) + r" \, dx = " + sp.latex(F3)))

# Bessel-Funktionen
f4 = sp.sin(x)/x
F4 = sp.integrate(f4, (x, 0, sp.oo))
display(Math(r"\int_{0}^{\infty} " + sp.latex(f4) + r" \, dx = " + sp.latex(F4)))

# Liouville-Theorem: Manche elementare Funktionen haben keine
# elementaren Stammfunktionen
f5 = sp.exp(x**2)
F5 = sp.integrate(f5, x)
display(Math(r"\int " + sp.latex(f5) + r" \, dx = " + sp.latex(F5)))

# Weitere Beispiele für nicht-elementare Integrale
f6 = sp.sin(x)/x
F6 = sp.integrate(f6, x)
display(Math(r"\int " + sp.latex(f6) + r" \, dx = " + sp.latex(F6)))

f7 = 1/sp.log(x)
F7 = sp.integrate(f7, x)
display(Math(r"\int " + sp.latex(f7) + r" \, dx = " + sp.latex(F7)))

# Numerische Auswertung nicht-elementarer Integrale
from sympy.abc import z
from mpmath import quad, exp, sin, sqrt, pi

# Numerische Integration der Gaußschen Glockenkurve
def gaussian(t):
    return exp(-t**2)

numerical_result = quad(gaussian, [-sp.oo, sp.oo])
exact_result = sqrt(pi)

display(Markdown("**Numerische Integration von:**"))
display(Math(r"\int_{-\infty}^{\infty} e^{-x^2} \, dx"))
print(f"Numerisches Ergebnis: {numerical_result}")
print(f"Exaktes Ergebnis: {exact_result}")
print(f"Unterschied: {abs(numerical_result - exact_result)}")

# Beispiel für die Sinc-Funktion
def sinc(t):
    if t == 0:
        return 1
    else:
        return sin(t)/t

numerical_sinc = quad(sinc, [0, 100])  # Integration bis zu einem großen Wert statt ∞

display(Markdown("**Numerische Integration von:**"))
display(Math(r"\int_{0}^{100} \frac{\sin(x)}{x} \, dx = " + str(numerical_sinc)))

# Analytisch
display(Math(r"\text{Analytisches Ergebnis: } \int_{0}^{\infty} \frac{\sin(x)}{x} \, dx = \frac{\pi}{2} = " + str(pi/2)))

# Visualisierung nicht-elementarer Integrale
import numpy as np
import matplotlib.pyplot as plt

# Fehler-Funktion
x_vals = np.linspace(-3, 3, 1000)
erf_vals = np.array([float(sp.erf(val)) for val in x_vals])

plt.figure(figsize=(10, 6))
plt.plot(x_vals, erf_vals, 'b-', linewidth=2)
plt.title('Fehlerfunktion erf(x)')
plt.xlabel('x')
plt.ylabel('erf(x)')
plt.grid(True)
plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)
plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)
plt.show()

# Fresnel-Integral
x_vals = np.linspace(0, 10, 1000)
sin_x2_vals = np.sin(x_vals**2)
# Approximation des Integrals durch kumulative Summe
dx = x_vals[1] - x_vals[0]
fresnel_approx = np.cumsum(sin_x2_vals) * dx

plt.figure(figsize=(10, 6))
plt.plot(x_vals, sin_x2_vals, 'b-', linewidth=1, alpha=0.7, label='sin(x²)')
plt.plot(x_vals, fresnel_approx, 'r-', linewidth=2, label='∫sin(x²)dx (approximiert)')
plt.title('Fresnel-Integral S(x) = ∫₀ˣ sin(t²)dt')
plt.xlabel('x')
plt.grid(True)
plt.legend()
plt.show()

$\displaystyle \int e^{- x^{2}} \, dx = \frac{\sqrt{\pi} \operatorname{erf}{\left(x \right)}}{2}$

Die Fehlerfunktion erf(x) ist definiert als:

$\displaystyle \text{erf}(x) = \frac{2}{\sqrt{\pi}} \int_{0}^{x} e^{-t^2} \, dt$

$\displaystyle \int \frac{1}{\sqrt{1 – x^{4}}} \, dx = \frac{x \Gamma\left(\frac{1}{4}\right) {{}_{2}F_{1}\left(\begin{matrix} \frac{1}{4}, \frac{1}{2} \\ \frac{5}{4} \end{matrix}\middle| {x^{4} e^{2 i \pi}} \right)}}{4 \Gamma\left(\frac{5}{4}\right)}$

$\displaystyle \int \sin{\left(x^{2} \right)} \, dx = \frac{3 \sqrt{2} \sqrt{\pi} S\left(\frac{\sqrt{2} x}{\sqrt{\pi}}\right) \Gamma\left(\frac{3}{4}\right)}{8 \Gamma\left(\frac{7}{4}\right)}$

$\displaystyle \int_{0}^{\infty} \frac{\sin{\left(x \right)}}{x} \, dx = \frac{\pi}{2}$

$\displaystyle \int e^{x^{2}} \, dx = \frac{\sqrt{\pi} \operatorname{erfi}{\left(x \right)}}{2}$

$\displaystyle \int \frac{\sin{\left(x \right)}}{x} \, dx = \operatorname{Si}{\left(x \right)}$

$\displaystyle \int \frac{1}{\log{\left(x \right)}} \, dx = \operatorname{li}{\left(x \right)}$

Numerische Integration von:

$\displaystyle \int_{-\infty}^{\infty} e^{-x^2} \, dx$

Numerisches Ergebnis: 1.77245385090552
Exaktes Ergebnis: 1.77245385090552
Unterschied: 2.22044604925031e-16

Numerische Integration von:

$\displaystyle \int_{0}^{100} \frac{\sin(x)}{x} \, dx = 1.56222546688906$

$\displaystyle \text{Analytisches Ergebnis: } \int_{0}^{\infty} \frac{\sin(x)}{x} \, dx = \frac{\pi}{2} = 1.5707963267949$

4.3.3 Mehrfachintegrale¶

Mehrfachintegrale werden verwendet, um Funktionen über mehrdimensionale Bereiche zu integrieren. Sie sind wichtig in der Physik, Technik und Wahrscheinlichkeitstheorie. Mit SymPy können wir solche Integrale symbolisch berechnen:

In [12]:

# Mehrfachintegrale mit SymPy - Drei Grundlegende Beispiele
import sympy as sp
from IPython.display import display, Math

# Symbole definieren
x, y, z, r, theta, phi = sp.symbols('x y z r theta phi')

# 1. Einfaches Doppelintegral über ein Rechteck
# ∫₀¹∫₀² x·y dy dx
f1 = x * y
I1 = sp.integrate(f1, (y, 0, 2), (x, 0, 1))
display(Math(r"\int_0^1 \int_0^2 " + sp.latex(f1) + r" \, dy \, dx = " + sp.latex(I1)))

# 2. Doppelintegral in Polarkoordinaten (Fläche einer Kreisscheibe)
# Transformation: x = r·cos(θ), y = r·sin(θ)
# Jacobi-Determinante: r
# ∫₀²ᵖ∫₀¹ r dr dθ
f2 = 1
I2 = sp.integrate(f2 * r, (r, 0, 1), (theta, 0, 2*sp.pi))
display(Math(r"\int_0^{2\pi} \int_0^1 " + sp.latex(f2) + r" \cdot " + sp.latex(r) + r" \, dr \, d\theta = " + sp.latex(I2)))

# 3. Dreifachintegral in Kugelkoordinaten (Volumen einer Kugel)
# Transformation: x = r·sin(φ)·cos(θ), y = r·sin(φ)·sin(θ), z = r·cos(φ)
# Jacobi-Determinante: r²·sin(φ)
# ∫₀²ᵖ∫₀ᵖ∫₀ᴿ r²·sin(φ) dr dφ dθ

R = sp.Symbol('R', positive=True)  # Radius der Kugel
f3 = 1
I3 = sp.integrate(f3 * r**2 * sp.sin(phi), (r, 0, R), (phi, 0, sp.pi), (theta, 0, 2*sp.pi))
display(Math(r"\int_0^{2\pi} \int_0^{\pi} \int_0^R " + sp.latex(f3) + r" \cdot " + sp.latex(r**2 * sp.sin(phi)) + 
         r" \, dr \, d\phi \, d\theta = " + sp.latex(I3)))

# Vergleich mit der bekannten Formel V = (4/3)πR³
expected = (4/3) * sp.pi * R**3
display(Math(r"\text{Vergleich mit } \frac{4}{3}\pi R^3 = " + sp.latex(expected) + r": " + 
         sp.latex(sp.simplify(I3 - expected))))

$\displaystyle \int_0^1 \int_0^2 x y \, dy \, dx = 1$

$\displaystyle \int_0^{2\pi} \int_0^1 1 \cdot r \, dr \, d\theta = \pi$

$\displaystyle \int_0^{2\pi} \int_0^{\pi} \int_0^R 1 \cdot r^{2} \sin{\left(\phi \right)} \, dr \, d\phi \, d\theta = \frac{4 \pi R^{3}}{3}$

$\displaystyle \text{Vergleich mit } \frac{4}{3}\pi R^3 = 1.33333333333333 \pi R^{3}: 0$

4.4 Numerisches Differenzieren¶

Neben dem symbolischen Differenzieren, das wir bereits kennengelernt haben, ist das numerische Differenzieren eine wichtige Methode, die sehr oft und in verschiedenen Situationen zum Einsatz kommt. Während symbolisches Differenzieren exakte Ableitungen liefert, bietet numerisches Differenzieren Näherungslösungen für Fälle, in denen:

die Funktion nur durch diskrete Datenpunkte gegeben ist
die Ableitung symbolisch sehr komplex oder nicht berechenbar ist
eine schnelle Approximation ausreichend ist

4.4.1 Verschiedene Ansätze für numerisches Differenzieren¶

Numerische Ableitungen basieren auf der grundlegenden Definition der Ableitung als Grenzwert:

$$f'(x) = \lim_{h \to 0} \frac{f(x+h) – f(x)}{h}$$

In der Praxis können wir diesen Grenzwert nicht exakt berechnen, da wir nicht mit unendlich kleinen Werten h arbeiten können. Stattdessen verwenden wir kleine, aber endliche Werte für h, um die Ableitung zu approximieren. Diese Schrittweite h bestimmt auch den numerischen Fehler beim Differenzieren mit. Generell gilt, dass zwar der Fehler mit h im Prinzip kleiner wird, in der Praxis aber wird die Berechnung der Ableitung mit kleinerem h immer instabiler. Das hat hauptsächlich mit dem “Rauschen”, also dem Fehler, auf den bereitgestellten numerischen Daten zu tun. Zunächst der erste Teil dieses Verhaltens:

In [13]:

import numpy as np
import matplotlib.pyplot as plt
from scipy.misc import derivative

# Testfunktion definieren
def f(x):
    return np.sin(x) * np.exp(-0.1 * x)

# Exakte Ableitung (zum Vergleich)
def df_exact(x):
    return np.cos(x) * np.exp(-0.1 * x) - 0.1 * np.sin(x) * np.exp(-0.1 * x)

# 1. Vorwärtsdifferenz
def forward_diff(f, x, h=1e-5):
    return (f(x + h) - f(x)) / h

# 2. Rückwärtsdifferenz
def backward_diff(f, x, h=1e-5):
    return (f(x) - f(x - h)) / h

# 3. Zentrale Differenz
def central_diff(f, x, h=1e-5):
    return (f(x + h) - f(x - h)) / (2 * h)

# 4. Fünf-Punkte-Formel (höhere Genauigkeit)
def five_point_diff(f, x, h=1e-3):
    return (-f(x + 2*h) + 8*f(x + h) - 8*f(x - h) + f(x - 2*h)) / (12 * h)

# Berechnungen für einen einzelnen Punkt
x0 = 2.0
h_values = [1e-1, 1e-2, 1e-3, 1e-4, 1e-5, 1e-6, 1e-7, 1e-8, 1e-9, 1e-10]

# Exakter Wert
exact_derivative = df_exact(x0)
print(f"Exakte Ableitung bei x = {x0}: {exact_derivative}")

# Fehler für verschiedene Methoden und Schrittweiten berechnen
errors_forward = []
errors_backward = []
errors_central = []
errors_five_point = []

for h in h_values:
    # Numerische Ableitungen berechnen
    fd = forward_diff(f, x0, h)
    bd = backward_diff(f, x0, h)
    cd = central_diff(f, x0, h)
    fpd = five_point_diff(f, x0, h)
    
    # Absoluten Fehler berechnen
    errors_forward.append(abs(fd - exact_derivative))
    errors_backward.append(abs(bd - exact_derivative))
    errors_central.append(abs(cd - exact_derivative))
    errors_five_point.append(abs(fpd - exact_derivative))

# Vergleich der Fehler für verschiedene Schrittweiten visualisieren
plt.figure(figsize=(12, 8))
plt.loglog(h_values, errors_forward, 'o-', label='Vorwärtsdifferenz')
plt.loglog(h_values, errors_backward, 's-', label='Rückwärtsdifferenz')
plt.loglog(h_values, errors_central, '^-', label='Zentrale Differenz')
plt.loglog(h_values, errors_five_point, 'D-', label='Fünf-Punkte-Formel')
plt.grid(True, which="both", ls="--")
plt.xlabel('Schrittweite h')
plt.ylabel('Absoluter Fehler')
plt.title('Fehler der numerischen Differentiationsmethoden in Abhängigkeit von der Schrittweite')
plt.legend()
plt.show()

# Visualisierung der Funktion und ihrer Ableitung
x_values = np.linspace(0, 10, 1000)
f_values = f(x_values)
df_values = df_exact(x_values)

plt.figure(figsize=(12, 6))
plt.subplot(1, 2, 1)
plt.plot(x_values, f_values)
plt.grid(True)
plt.title('Funktion f(x) = sin(x) · e^(-0.1x)')
plt.xlabel('x')
plt.ylabel('f(x)')

plt.subplot(1, 2, 2)
plt.plot(x_values, df_values)
plt.grid(True)
plt.title('Ableitung f\'(x)')
plt.xlabel('x')
plt.ylabel('f\'(x)')
plt.tight_layout()
plt.show()

# Demonstration der numerischen Ableitung entlang der gesamten Funktion
h_demo = 1e-4  # Eine für Demonstrationszwecke geeignete Schrittweite
central_diff_values = [central_diff(f, x, h_demo) for x in x_values]
five_point_diff_values = [five_point_diff(f, x, h_demo) for x in x_values]

plt.figure(figsize=(12, 6))
plt.plot(x_values, df_values, 'k-', label='Exakte Ableitung')
plt.plot(x_values, central_diff_values, 'r--', label=f'Zentrale Differenz (h={h_demo})')
plt.plot(x_values, five_point_diff_values, 'g:', label=f'Fünf-Punkte-Formel (h={h_demo})')
plt.grid(True)
plt.title('Vergleich von exakter und numerischer Ableitung')
plt.xlabel('x')
plt.ylabel('f\'(x)')
plt.legend()
plt.show()

# Höhere Ableitungen
def second_derivative(f, x, h=1e-4):
    """Berechnet die zweite Ableitung mit der zentralen Differenzenmethode."""
    return (f(x + h) - 2 * f(x) + f(x - h)) / (h**2)

# Exakte zweite Ableitung
def d2f_exact(x):
    return (-0.1*np.cos(x) - 0.1*np.cos(x) - np.sin(x) - 0.1*(-0.1*np.sin(x))) * np.exp(-0.1*x)

# Vergleich der exakten und numerischen zweiten Ableitung
d2f_values = d2f_exact(x_values)
d2f_numerical = [second_derivative(f, x) for x in x_values]

plt.figure(figsize=(10, 6))
plt.plot(x_values, d2f_values, 'k-', label='Exakte zweite Ableitung')
plt.plot(x_values, d2f_numerical, 'r--', label='Numerische zweite Ableitung')
plt.grid(True)
plt.title('Vergleich von exakter und numerischer zweiter Ableitung')
plt.xlabel('x')
plt.ylabel('f\'\'(x)')
plt.legend()
plt.show()

Exakte Ableitung bei x = 2.0: -0.4151591895809479

Und nun zum zweiten Teil dieses Verhaltens, der numerischen Instabilität mit kleinerem h:

In [6]:

# Demonstration der numerischen Instabilität bei der Differentiation von verrauschten Daten
import numpy as np
import matplotlib.pyplot as plt
from matplotlib.gridspec import GridSpec
np.random.seed(42)  # Für Reproduzierbarkeit

# Basisfunktion: f(x) = x²
def f_exact(x):
    return x**2

# Exakte Ableitung: f'(x) = 2x
def df_exact(x):
    return 2*x

# Verrauschte Funktion erstellen
def f_noisy(x, noise_level=0.05):
    if np.isscalar(x):
        return f_exact(x) + noise_level * np.random.randn()
    else:
        return f_exact(x) + noise_level * np.random.randn(len(x))

# Numerische Ableitung mit zentraler Differenz
def numerical_derivative(x_grid, h, noise_level=0.05):
    """
    Berechnet die numerische Ableitung für ein gegebenes Gitter, indem zusätzliche 
    Punkte im Abstand h für die Differenzenbildung verwendet werden.
    
    Args:
        x_grid: Das ursprüngliche Gitter
        h: Die Schrittweite für die Differenzenbildung
        noise_level: Stärke des Rauschens
        
    Returns:
        f_grid: Funktionswerte auf dem Originalgitter (verrauscht)
        df_numerical: Numerische Ableitung auf dem Originalgitter
    """
    n = len(x_grid)
    df_numerical = np.zeros_like(x_grid)
    
    # Erzeuge verrauschte Funktionswerte für das Originalgitter
    np.random.seed(42)  # Gleicher Rauschpegel für alle Durchläufe
    f_grid = f_noisy(x_grid, noise_level)
    
    # Für jeden Punkt im Gitter
    for i in range(n):
        x = x_grid[i]
        
        # Erzeuge zusätzliche Punkte links und rechts im Abstand h
        x_minus = x - h
        x_plus = x + h
        
        # Erzeuge verrauschte Funktionswerte für diese zusätzlichen Punkte
        # Wir verwenden hierfür neue Zufallswerte für das Rauschen
        f_minus = f_noisy(x_minus, noise_level)
        f_plus = f_noisy(x_plus, noise_level)
        
        # Berechne die zentrale Differenz
        df_numerical[i] = (f_plus - f_minus) / (2 * h)
    
    return f_grid, df_numerical

# Bereich und Datenpunkte definieren
x = np.linspace(-5, 5, 200)
f_clean = f_exact(x)
df_clean = df_exact(x)

# Schrittweiten für den Vergleich
step_sizes = [1.0, 0.1, 0.01, 0.001]

# Erstellen der Figur mit 4 Subplots
fig = plt.figure(figsize=(14, 10))
gs = GridSpec(2, 2, figure=fig)

# Ergebnisse für MSE-Berechnung speichern
error_info = []

for i, h in enumerate(step_sizes):
    row, col = divmod(i, 2)
    ax = fig.add_subplot(gs[row, col])
    
    # Berechnung der numerischen Ableitung mit aktueller Schrittweite
    f_with_noise, df_numerical = numerical_derivative(x, h)
    
    # Berechnung des MSE
    mse = np.mean((df_numerical - df_clean)**2)
    error_info.append(f'h = {h}: MSE = {mse:.6f}')
    
    # Original verrauschte Funktion plotten
    ax.plot(x, f_with_noise, 'gray', alpha=0.5, linewidth=1, 
            label='Verrauschte Funktion $f(x) = x^2 + \epsilon$')
    
    # Exakte Ableitung plotten
    ax.plot(x, df_clean, 'b-', label='Exakte Ableitung $f\'(x) = 2x$')
    
    # Numerische Ableitung plotten
    ax.plot(x, df_numerical, 'r-', linewidth=1, alpha=0.8, 
            label=f'Numerische Ableitung (h = {h})')
    
    # Formatierung
    ax.set_title(f'Schrittweite h = {h}')
    ax.set_xlabel('x')
    ax.set_ylabel('y')
    ax.grid(True, linestyle='--', alpha=0.6)
    
    # Legende einfügen, wenn genug Platz
    if i == 0:
        ax.legend(loc='upper left')
    
    # Achsenbereiche anpassen
    ax.set_ylim(-12, 12)

# Gesamtbeschriftung
plt.suptitle('Numerische Ableitung von verrauschten Daten: Einfluss der Schrittweite h', fontsize=16)
plt.tight_layout(rect=[0, 0, 1, 0.96])  # Platz für den Titel oben

# Ausgabe der Fehlerinformationen
print("Mittlerer quadratischer Fehler (MSE) für verschiedene Schrittweiten:")
for info in error_info:
    print(info)

plt.show()

Mittlerer quadratischer Fehler (MSE) für verschiedene Schrittweiten:
h = 1.0: MSE = 0.001220
h = 0.1: MSE = 0.121979
h = 0.01: MSE = 12.197944
h = 0.001: MSE = 1219.794383

4.4.2 Implementierung mit NumPy¶

NumPy und SciPy bieten verschiedene Funktionen zur numerischen Differentiation. Diese sind optimiert für Effizienz und Genauigkeit und können auf Vektoren oder Matrizen angewendet werden:

In [15]:

import numpy as np
import matplotlib.pyplot as plt

# 1. Verwendung von numpy.gradient für Datensätze
# Generieren von Beispieldaten
x = np.linspace(0, 10, 100)
y = np.sin(x) * np.exp(-0.2 * x)

# Berechnung der Ableitung mit numpy.gradient
dy_dx = np.gradient(y, x)

plt.figure(figsize=(10, 6))
plt.plot(x, y, 'b-', label='f(x) = sin(x) · e^(-0.2x)')
plt.plot(x, dy_dx, 'r-', label='df/dx (numerisch)')
plt.grid(True)
plt.legend()
plt.title('Numerische Differentiation mit numpy.gradient')
plt.xlabel('x')
plt.ylabel('y')
plt.show()

# 2. Implementierung eigener numerischer Ableitungsfunktionen
def f(x):
    return np.sin(x) * np.exp(-0.2 * x)

# Exakte Ableitung zur Überprüfung
def df_exact(x):
    return np.cos(x) * np.exp(-0.2 * x) - 0.2 * np.sin(x) * np.exp(-0.2 * x)

# Eigene Implementation der zentralen Differenz
def central_diff(f, x, h=1e-6):
    return (f(x + h) - f(x - h)) / (2 * h)

# Berechnung der Ableitung an verschiedenen Punkten
x_points = np.linspace(0, 10, 20)
df_numpy = [central_diff(f, x_i) for x_i in x_points]
df_exact_values = [df_exact(x_i) for x_i in x_points]

plt.figure(figsize=(10, 6))
plt.plot(x, [df_exact(x_i) for x_i in x], 'b-', label='Exakte Ableitung')
plt.plot(x_points, df_numpy, 'ro', label='Zentrale Differenz (NumPy)')
plt.grid(True)
plt.legend()
plt.title('Vergleich von exakter und numerischer Ableitung mit zentraler Differenz')
plt.xlabel('x')
plt.ylabel('df/dx')
plt.show()

# Fehler berechnen
errors = np.abs(np.array(df_numpy) - np.array(df_exact_values))
print(f"Maximaler Fehler mit zentraler Differenz: {np.max(errors):.2e}")
print(f"Mittlerer Fehler mit zentraler Differenz: {np.mean(errors):.2e}")

# 3. Höhere Ableitungen mit NumPy
# Eigene Implementation der zentralen Differenz für zweite Ableitung
def second_derivative(f, x, h=1e-4):
    return (f(x + h) - 2 * f(x) + f(x - h)) / (h**2)

# Berechne zweite Ableitung
d2f_numpy = [second_derivative(f, x_i) for x_i in x_points]

# Exakte zweite Ableitung
def d2f_exact(x):
    return -0.2 * np.cos(x) * np.exp(-0.2 * x) - np.sin(x) * np.exp(-0.2 * x) - 0.2 * (np.cos(x) * np.exp(-0.2 * x) - 0.2 * np.sin(x) * np.exp(-0.2 * x))

d2f_exact_values = [d2f_exact(x_i) for x_i in x_points]
d2f_exact_curve = [d2f_exact(x_i) for x_i in x]

plt.figure(figsize=(10, 6))
plt.plot(x, d2f_exact_curve, 'b-', label='Exakte 2. Ableitung')
plt.plot(x_points, d2f_numpy, 'ro', label='Zweite Ableitung (NumPy)')
plt.grid(True)
plt.legend()
plt.title('Zweite Ableitung mit zentraler Differenz')
plt.xlabel('x')
plt.ylabel('d²f/dx²')
plt.show()

# 4. Numerische Differentiation für mehrdimensionale Daten
# Erstellen eines 2D-Beispieldatensatzes
x, y = np.meshgrid(np.linspace(-5, 5, 100), np.linspace(-5, 5, 100))
z = np.sin(np.sqrt(x**2 + y**2))

# Berechnung der Gradienten mit numpy.gradient
dx, dy = np.gradient(z, x[0, :], y[:, 0])

# Visualisierung der Funktion und des Gradienten
plt.figure(figsize=(16, 6))

plt.subplot(1, 3, 1)
plt.contourf(x, y, z, 50, cmap='viridis')
plt.colorbar(label='z = sin(√(x² + y²))')
plt.title('2D-Funktion')
plt.xlabel('x')
plt.ylabel('y')

plt.subplot(1, 3, 2)
plt.contourf(x, y, dx, 50, cmap='viridis')
plt.colorbar(label='∂z/∂x')
plt.title('Partielle Ableitung nach x')
plt.xlabel('x')
plt.ylabel('y')

plt.subplot(1, 3, 3)
plt.contourf(x, y, dy, 50, cmap='viridis')
plt.colorbar(label='∂z/∂y')
plt.title('Partielle Ableitung nach y')
plt.xlabel('x')
plt.ylabel('y')

plt.tight_layout()
plt.show()

# Gradientenfeld visualisieren
plt.figure(figsize=(10, 8))
# Für übersichtlichkeit nur jeden 5. Punkt darstellen
skip = 5
plt.contourf(x, y, z, 20, cmap='viridis', alpha=0.3)
plt.quiver(x[::skip, ::skip], y[::skip, ::skip], 
           dx[::skip, ::skip], dy[::skip, ::skip], 
           color='black', scale=50)
plt.title('Gradientenfeld der Funktion z = sin(√(x² + y²))')
plt.xlabel('x')
plt.ylabel('y')
plt.show()

Maximaler Fehler mit zentraler Differenz: 1.25e-10
Mittlerer Fehler mit zentraler Differenz: 4.76e-11

4.5 Numerisches Integrieren¶

Ähnlich wie beim numerischen Differenzieren gibt es auch beim Integrieren Fälle, in denen eine exakte symbolische Lösung nicht möglich oder praktisch ist. Numerische Integration bietet Näherungslösungen für bestimmte Integrale und ist besonders nützlich, wenn:

das Integral keinen geschlossenen analytischen Ausdruck hat
die zu integrierende Funktion nur als Datensatz oder Black-Box-Funktion vorliegt
das Integral sehr komplex ist und die symbolische Berechnung zu aufwändig wäre

4.5.1 Verschiedene Ansätze für numerisches Integrieren¶

Die grundlegende Idee der numerischen Integration ist, die Fläche unter einer Kurve durch geometrische Figuren zu approximieren, deren Flächen leicht zu berechnen sind. Hier wird z.B. die Anwendung der Trapezregel demonstriert:

In [16]:

import numpy as np
import matplotlib.pyplot as plt
import sympy as sp
from IPython.display import display, Math

# Funktion definieren, die wir integrieren wollen
def f(x):
    return np.sin(x)**2 * np.exp(-0.1 * x)

# Trapezmethode implementieren
def trapezoid_rule(f, a, b, n):
    """
    Numerische Integration mit der Trapezmethode
    
    Parameter:
    f: Zu integrierende Funktion
    a, b: Integrationsgrenzen
    n: Anzahl der Teilintervalle
    
    Rückgabe:
    Näherungswert des Integrals
    """
    h = (b - a) / n  # Schrittweite
    x = np.linspace(a, b, n+1)  # n+1 Punkte für n Intervalle
    y = f(x)
    
    # Trapezformel: h * [0.5*y₀ + y₁ + y₂ + ... + y_{n-1} + 0.5*y_{n}]
    return h * (0.5 * y[0] + np.sum(y[1:-1]) + 0.5 * y[-1])

# Exakten Wert mit SymPy berechnen
x_sym = sp.Symbol('x')
f_sym = sp.sin(x_sym)**2 * sp.exp(-0.1 * x_sym)
a, b = 0, 5  # Integrationsgrenzen
exact_integral = float(sp.integrate(f_sym, (x_sym, 0, 5)))

# Trapezregel mit verschiedenen Anzahlen von Teilintervallen anwenden
n_intervals = [4, 10, 20, 50]
results = []

for n in n_intervals:
    result = trapezoid_rule(f, a, b, n)
    error = abs(result - exact_integral)
    results.append((n, result, error))
    print(f"n = {n:2d}: Trapezregel = {result:.8f}, Fehler = {error:.8f}")

print(f"Exakter Wert:  {exact_integral:.8f}")

# Visualisierung
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(15, 6))

# Die Funktion und Trapeze für n=4 darstellen
n_vis = 4
x = np.linspace(a, b, n_vis+1)
y = f(x)
x_fine = np.linspace(a, b, 500)
y_fine = f(x_fine)

# Funktion plotten
ax1.plot(x_fine, y_fine, 'b-', linewidth=2, label='f(x)')
ax1.fill_between(x_fine, 0, y_fine, alpha=0.1, color='blue')
ax1.set_title(f'Trapezmethode mit n = {n_vis} Intervallen')
ax1.set_xlabel('x')
ax1.set_ylabel('f(x)')
ax1.grid(True)

# Trapeze zeichnen
for i in range(n_vis):
    x_trap = [x[i], x[i], x[i+1], x[i+1], x[i]]
    y_trap = [0, y[i], y[i+1], 0, 0]
    ax1.fill(x_trap, y_trap, 'r', alpha=0.2)
    
# Punkte der Auswertung markieren
ax1.plot(x, y, 'ro', markersize=5)

# Konvergenz der Methode zeigen
ax2.plot([r[0] for r in results], [r[2] for r in results], 'b-o', linewidth=2)
ax2.set_xscale('log')
ax2.set_yscale('log')
ax2.set_title('Konvergenz der Trapezmethode')
ax2.set_xlabel('Anzahl der Intervalle n')
ax2.set_ylabel('Fehler')
ax2.grid(True, which="both", ls="--")

# Theoretische Konvergenzrate O(h²) = O(1/n²) anzeigen
n_ref = np.array([min(n_intervals), max(n_intervals)])
err_init = results[0][2] * (n_intervals[0]**2)
err_ref = err_init / (n_ref**2)
ax2.plot(n_ref, err_ref, 'k--', label='O(1/n²)')
ax2.legend()

plt.tight_layout()
plt.show()

# Sympy-Darstellung der Trapezformel
from IPython.display import display, Math
display(Math(r"\int_a^b f(x) \, dx \approx \frac{b-a}{n} \left[ \frac{f(a)}{2} + \sum_{i=1}^{n-1} f(x_i) + \frac{f(b)}{2} \right]"))

n =  4: Trapezregel = 1.97135330, Fehler = 0.05946456
n = 10: Trapezregel = 2.02258346, Fehler = 0.00823441
n = 20: Trapezregel = 2.02879670, Fehler = 0.00202116
n = 50: Trapezregel = 2.03049611, Fehler = 0.00032176
Exakter Wert:  2.03081786

$\displaystyle \int_a^b f(x) \, dx \approx \frac{b-a}{n} \left[ \frac{f(a)}{2} + \sum_{i=1}^{n-1} f(x_i) + \frac{f(b)}{2} \right]$

4.5.2 Adaptive Quadraturverfahren¶

Die Trapezregel verwendet eine feste Anzahl von Stützstellen und eine konstante Schrittweite über das gesamte Integrationsintervall. Adaptive Verfahren sind hingegen intelligenter: Sie passen die Schrittweite automatisch an die lokale Struktur der Funktion an, indem sie in Bereichen mit starker Krümmung oder schneller Änderung feinere Unterteilungen verwenden.

Diese adaptiven Methoden verbessern die Effizienz und Genauigkeit der numerischen Integration erheblich, insbesondere bei Funktionen mit:

Steilen Gradienten oder schnell oszillierenden Bereichen
Singuläritäten oder nahezu singulären Stellen
Scharfen Übergängen oder Unstetigkeiten

Hier ist ein konkretes Beispiel:

In [17]:

import numpy as np
import matplotlib.pyplot as plt

# Eine Funktion mit einer scharfen Spitze, die adaptive Methoden herausfordert
def challenging_function(x):
    return 1 / (0.01 + (x - 0.3)**2) + np.sin(10 * x)

# Adaptive Simpson-Regel Implementierung
def adaptive_simpson(f, a, b, tol=1e-5, max_depth=20):
    """
    Adaptive Simpson-Regel für numerische Integration
    
    Parameters:
    f: Die zu integrierende Funktion
    a, b: Integrationsgrenzen
    tol: Fehlertoleranz
    max_depth: Maximale Rekursionstiefe
    
    Returns:
    integral: Numerischer Wert des Integrals
    points: Liste der verwendeten Stützstellen
    """
    points = set([a, b])  # Menge der verwendeten Stützstellen
    
    def simpson_rule(f, a, b):
        """Berechnet die Simpson-Regel für ein Intervall"""
        c = (a + b) / 2  # Mittelpunkt
        h = b - a        # Intervallbreite
        return h/6 * (f(a) + 4*f(c) + f(b))
    
    def adaptive_step(a, b, fa, fc, fb, depth):
        """Rekursiver Schritt der adaptiven Simpson-Regel"""
        c = (a + b) / 2
        d = (a + c) / 2
        e = (c + b) / 2
        fd = f(d)
        fe = f(e)
        
        # Füge neue Stützstellen hinzu
        points.add(d)
        points.add(e)
        
        # Simpson-Regel für die Teilintervalle
        left = (c - a) / 6 * (fa + 4*fd + fc)
        right = (b - c) / 6 * (fc + 4*fe + fb)
        
        # Simpson-Regel für das gesamte Intervall
        whole = (b - a) / 6 * (fa + 4*fc + fb)
        
        # Fehlerabschätzung
        error = abs(left + right - whole)
        
        if error < tol or depth >= max_depth:
            return left + right
        else:
            # Rekursive Verfeinerung
            return adaptive_step(a, c, fa, fd, fc, depth+1) + adaptive_step(c, b, fc, fe, fb, depth+1)
    
    # Startauswertungen
    c = (a + b) / 2
    fa, fc, fb = f(a), f(c), f(b)
    points.add(c)
    
    # Führe die adaptive Integration durch
    integral = adaptive_step(a, b, fa, fc, fb, 0)
    
    # Sortiere die Stützstellen für die Darstellung
    sorted_points = sorted(list(points))
    
    return integral, sorted_points

# Integrationsbereich
a, b = 0, 1

# Funktion auf einem feinen Gitter für die Darstellung
x_fine = np.linspace(a, b, 1000)
y_fine = challenging_function(x_fine)

# Führe die adaptive Integration durch
result, points = adaptive_simpson(challenging_function, a, b, tol=1e-4)

# Berechne die Funktionswerte an den adaptiven Stützstellen
y_points = [challenging_function(p) for p in points]

# Visualisierung
plt.figure(figsize=(12, 10))

# Darstellung der Funktion und Stützstellen
plt.subplot(2, 1, 1)
plt.plot(x_fine, y_fine, 'b-', linewidth=1.5, label='f(x)')
plt.scatter(points, y_points, color='red', s=30, alpha=0.8, label='Adaptive Stützstellen')
plt.title(f'Adaptive Simpson-Regel: Funktion und {len(points)} Stützstellen')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.legend()
plt.grid(True)

# Fokus auf den Bereich mit der Spitze
plt.subplot(2, 1, 2)
zoom_region = (0.2, 0.4)  # Bereich um die Spitze
plt.plot(x_fine, y_fine, 'b-', linewidth=1.5)
zoom_points = [p for p in points if zoom_region[0] <= p <= zoom_region[1]]
zoom_y = [challenging_function(p) for p in zoom_points]
plt.scatter(zoom_points, zoom_y, color='red', s=50, alpha=0.8)
plt.title(f'Zoom auf die Spitze: Erhöhte Dichte der Stützstellen')
plt.xlabel('x')
plt.ylabel('f(x)')
plt.xlim(zoom_region)
plt.grid(True)

# Histogramm der Stützstellen zur Veranschaulichung der adaptiven Verteilung
plt.figure(figsize=(10, 6))
plt.hist(points, bins=40, color='green', alpha=0.7)
plt.title('Verteilung der adaptiven Stützstellen')
plt.xlabel('x')
plt.ylabel('Häufigkeit')
plt.grid(True)

plt.tight_layout()
plt.show()

print(f"Ergebnis der adaptiven Simpson-Integration: {result:.8f}")
print(f"Anzahl der verwendeten Stützstellen: {len(points)}")
print(f"Bereich mit der höchsten Dichte: um x = 0.3 (Spitze der Funktion)")

Ergebnis der adaptiven Simpson-Integration: 26.96336120
Anzahl der verwendeten Stützstellen: 85
Bereich mit der höchsten Dichte: um x = 0.3 (Spitze der Funktion)

4.5.3 Implementierung in NumPy und SciPy¶

Kurz gesagt ist die Implementierung von numerischen Integrationsmethoden in NumPy und SciPy ausführlich und hochoptimiert enthalten. In Kombination mit einem LLM können Sie so eigentlich relativ problemlos entsprechenden Code nach Ihren Vorstellungen generieren lassen. In unklaren Situationen kann man auch sehr gut in einer kurzen Diskussion besprechen, welche Methode für eine bestimmte Situation am geeignetsten ist. Damit Sie dafür auch ein Bisschen gerüstet sind, hier ein kurzer Überblick:

4.5.4 Vergleich verschiedener Integrationsmethoden und Situationen¶

Die Auswahl einer geeigneten numerischen Integrationsmethode ist eine wesentliche Entscheidung in der wissenschaftlichen Berechnung und hängt stark von der Art des zu lösenden Problems ab. Jede Methode bietet spezifische Vor- und Nachteile in Bezug auf Genauigkeit, Effizienz und Robustheit.

Die einfachsten Methoden wie die Rechteckmethode $(O(h))$ und die Trapezmethode $(O(h^2))$ zeichnen sich durch ihre Einfachheit und niedrigen Rechenaufwand aus, leiden jedoch unter geringerer Genauigkeit für komplexere Funktionen. Sie sind optimal für schnelle Abschätzungen oder wenn die zu integrierende Funktion sehr glatt ist.

Im Gegensatz dazu bietet die Simpson-Regel mit ihrer Konvergenzrate von $O(h^4)$ eine deutlich höhere Genauigkeit bei vertretbarem Mehraufwand und stellt oft einen guten Kompromiss dar. Für höchste Präzision bei komplexen Funktionen sind adaptive Verfahren wie die adaptive Simpson-Regel oder Gauß-Quadratur optimal, da sie Berechnungspunkte intelligent dort platzieren, wo die Funktion schnell variiert oder Singularitäten aufweist.

Die Herausforderungen bei der Integration verschiedener Funktionstypen variieren erheblich: Während glatte Funktionen mit fast allen Methoden gut integrierbar sind, erfordern oszillierende Funktionen eine feinere Abtastung. Funktionen mit Spitzen oder Singularitäten profitieren besonders von adaptiven Verfahren, und bei Funktionen mit Unstetigkeiten kann eine Aufteilung des Integrationsbereichs an den Unstetigkeitsstellen sowie eine symmetrische Anordnung, z.B. um eine Singularität herum, notwendig sein.

Letztendlich sollte die Methodenwahl stets problemspezifisch erfolgen, wobei neben der gewünschten Genauigkeit auch praktische Aspekte wie Rechenressourcen, verfügbare Zeit und die besondere Struktur der zu integrierenden Funktion berücksichtigt werden müssen.

An dieser Stelle sei auch gleich erwähnt, dass sich für höherdimensionale Integrale ganz andere Integrationsmethoden anbieten, die sogenannte Monte-Carlo-Integration. Damit werden wir uns in einer späteren Einheit genauer befassen.

4.6 Übungsaufgabe: Analyse eines mathematischen Pendels mit symbolischen und numerischen Methoden¶

Im Rahmen dieser Übungsaufgabe sollen Sie symbolische und numerische Methoden kombinieren, um ein mathematisches Pendel zu analysieren. Zu diesem Zweck sollen Sie die Bewegungsgleichungen mithilfe des Lagrange-Formalismus herleiten, die üblichen Näherungslösungen für die lineare Näherung (Ersetzen des Sinus durch dessen Argument) untersuchen und schließlich numerische Integration zur Lösung der eigentlich resultierenden nichtlinearen Differentialgleichung (der exakten Bewegungsgleichung des Pendels ohne lineare Näherung) einsetzen.

Hier zunächst eine Skizze des Setups so eines Pendels:

In [18]:

import numpy as np
import matplotlib.pyplot as plt
from matplotlib.patches import Circle
import matplotlib.animation as animation
from IPython.display import HTML

# Physikalische Parameter
L = 1.0      # Pendellänge [m]
m = 0.5      # Masse [kg]
g = 9.81     # Erdbeschleunigung [m/s²]
theta0 = np.pi/4  # Anfangsauslenkung [rad]

# Position der Pendelmasse berechnen
def pendulum_position(theta):
    x = L * np.sin(theta)
    y = -L * np.cos(theta)
    return x, y

# Figur erstellen
fig, ax = plt.subplots(figsize=(10, 8))
ax.set_xlim(-1.5*L, 1.5*L)
ax.set_ylim(-1.5*L, 0.5*L)
ax.set_aspect('equal')
ax.grid(True)

# Ursprung (Aufhängepunkt)
ax.plot([0], [0], 'ko', markersize=10)
ax.text(0.1, 0.1, "Aufhängepunkt", fontsize=12)

# Position des Pendels in Ausgangsstellung
x, y = pendulum_position(theta0)

# Pendelfaden
line, = ax.plot([0, x], [0, y], 'k-', linewidth=2)
ax.text(x/2-0.3, y/2-0.1, "Länge L", fontsize=12)

# Pendelmasse
pendulum_bob = Circle((x, y), 0.1, fc='r')
ax.add_patch(pendulum_bob)
ax.text(x+0.15, y, "Masse m", fontsize=12)

# Winkel einzeichnen
arc = np.linspace(0, theta0, 100)
ax.plot(0.3*np.sin(arc), -0.3*np.cos(arc), 'b-')
ax.text(0.25, -0.15, r"$\theta$", fontsize=16)

# Kreisbogen auf Pendellänge einzeichnen
ax.plot(np.sin(arc), -np.cos(arc), 'b--')

# Koordinatenachsen
ax.axhline(y=0, color='gray', linestyle='--', alpha=0.3)
ax.axvline(x=0, color='gray', linestyle='--', alpha=0.3)

# Beschriftungen für verschiedene Kräfte und Energien
# Potentielle Energie
ax.arrow(x, 0, 0, y, color='green', width=0.01, head_width=0.04, head_length=0.08, 
         length_includes_head=True, alpha=0.7)
ax.text(x+0.1, y/2, "Pot. Energie\nmgh", color='green', fontsize=10)

# Gravitationskraft
ax.arrow(x, y, 0, -0.3, color='blue', width=0.01, head_width=0.04, head_length=0.08, 
         length_includes_head=True, alpha=0.7)
ax.text(x+0.1, y-0.2, "mg", color='blue', fontsize=10)

# Tangentialkraft
tangent_x = 0.3 * np.cos(theta0)
tangent_y = 0.3 * np.sin(theta0)
ax.arrow(x, y, tangent_x, tangent_y, color='red', width=0.01, head_width=0.04, 
         head_length=0.08, length_includes_head=True, alpha=0.7)
ax.text(x+tangent_x+0.05, y+tangent_y, "mg·sin(θ)", color='red', fontsize=10)

# Beschriftungen für die Lagrange-Funktion
ax.text(-1.2*L, 0.3*L, r"Lagrange-Funktion: $L = T - V$", fontsize=14)
ax.text(-1.2*L, 0.2*L, r"$T = \frac{1}{2}m(L\dot{\theta})^2$", fontsize=12)
ax.text(-1.2*L, 0.1*L, r"$V = mgL(1-\cos\theta)$", fontsize=12)

plt.title("Mathematisches Pendel", fontsize=16)
plt.show()

Aufgabenstellung¶

Arbeiten Sie an den folgenden Schritten und erledigen Sie diese, so weit Sie in der zur Verfügung stehenden Zeit kommen. Verwenden Sie dabei das LLM Ihrer Wahl gezielt für die Implementierung der einzelnen Schritte. Setzen Sie an geeigneten Stellen Visualisierungen ein.

Symbolische Herleitung der Bewegungsgleichung:
- Verwenden Sie den Lagrange-Formalismus, um die Bewegungsgleichung eines mathematischen Pendels herzuleiten.
- Die Lagrange-Funktion ist $L = T – V$, wobei $T$ die kinetische Energie und V die potentielle Energie ist.
- Für ein Pendel der Länge $L$ und Masse $m$ unter dem Einfluss der Schwerkraft $g$ gilt:
  - $T = (1/2)·m·(L·\dot{\theta})^2$
  - $V = m·g·L·(1-\cos(\theta))$
- Wenden Sie die Euler-Lagrange-Gleichung an: $\frac{d}{dt}(\frac{\partial L}{\partial \dot{\theta}})-\frac{\partial L}{\partial \theta}=0$
- Führen Sie die Berechnungen symbolisch mit SymPy durch.
Linearisierung der Bewegungsgleichung:
- Linearisieren Sie die resultierende nichtlineare Differentialgleichung für kleine Auslenkungen.
- Verwenden Sie dazu die Näherung $\sin(\theta)\approx\theta$ für kleine $\theta$.
- Finden Sie die allgemeine Lösung der linearisierten Differentialgleichung.
- Berechnen Sie die Schwingungsperiode für das linearisierte System.
Numerische Lösung der nichtlinearen Differentialgleichung:
- Diskutieren Sie mit Ihrem LLM, welche Möglichkeiten für eine numerische Lösung dieser Differentialgleichung in Frage kommen.
- Wählen Sie eine davon aus und lassen Sie diese implementieren.
- Lösen Sie die Gleichung für verschiedene Anfangsbedingungen.
- Vergleichen Sie die numerischen Lösungen für kleine und große Auslenkungen mit der analytischen Lösung der linearisierten Gleichung.
- Untersuchen Sie, ab welcher Auslenkung die linearisierte Näherung ungenau wird.
Analyse der Energieerhaltung:
- Berechnen Sie und plotten Sie die kinetische, potentielle und Gesamtenergie des Pendels während der Bewegung.
- Überprüfen Sie die Energieerhaltung bei der numerischen Lösung.
- Untersuchen Sie, wie sich numerische Fehler auf die Energieerhaltung auswirken.

Beispiel für LLM-Prompt zum Einstieg¶

Ich möchte die Bewegungsgleichung eines mathematischen Pendels mit dem Lagrange-Formalismus mit SymPy herleiten und anschließend, ebenfalls mit SymPy sowohl die lineare Näherung durchführen als auch die linearisierte Gleichung symbolisch mit SymPy lösen. Kannst du mir zeigen, wie ich die Lagrange-Funktion L = T - V für ein Pendel aufstellen und dann die Euler-Lagrange-Gleichung mit SymPy anwenden kann? T ist dabei die kinetische Energie (1/2)·m·(L·θ̇)² und V die potentielle Energie m·g·L·(1-cos(θ)).

Beispiel für LLM-Prompt zur numerischen Lösung¶

Nun möchte ich die ursprüngliche (nichtlineare) Bewegungsgleichung numerisch (konkret mit NumPy oder gegebenenfalls SciPy) untersuchen. Welche Methoden stehen mir da zur Verfügung? Lass uns zunächst die Möglichkeiten diskutieren und erst danach eine der Methoden mit NumPy verwenden um die Gleichung für mehrere verschiedene Anfangswerte zu lösen und die Lösungen zu Visualisieren.

In [19]:

# Hier können Sie loslegen ...

4.7 Zusammenfassung der wichtigsten Punkte dieser Einheit¶

In dieser Einheit haben wir uns mit zwei fundamentalen Konzepten der mathematischen Analysis befasst: dem Differenzieren und dem Integrieren. Wir haben sowohl symbolische als auch numerische Ansätze kennengelernt und verglichen.

Symbolisches Rechnen mit SymPy ermöglicht es, mathematische Ausdrücke exakt zu manipulieren und zu analysieren. Dies ist besonders sinnvoll für:
- Die Herleitung von analytischen Formeln und Beziehungen
- Das exakte Lösen von Gleichungen und Differentialgleichungen
- Die Vereinfachung komplexer mathematischer Ausdrücke
Symbolisches Differenzieren bietet:
- Exakte Ableitungen ohne Rundungsfehler
- Unterstützung beim Berechnen komplexer Ausdrücke und höherer Ableitungen
- Automatisierte Kurvendiskussion und ähnliche Analysen von Funktionen
Symbolisches Integrieren ermöglicht:
- Exakte Berechnung von unbestimmten und bestimmten Integralen
- Behandlung spezieller Funktionen und nicht-elementarer Integrale
- Mehrfachintegration in geschlossener Form
Numerisches Differenzieren:
- Funktioniert auch bei Funktionen, die nur als Datenpunkte oder Black-Box vorliegen
- Liefert auch hochdimensionale Gradienten auf Daten
- Die erreichte Genauigkeit hängt stark von der verwendeten Schrittweite h ab
- Kann bei verrauschten Daten komplett unverlässlich werden
Numerisches Integrieren bietet Lösungen für:
- Integrale ohne geschlossene analytische Form
- Hochdimensionale Integration
- Effiziente Approximation mit kontrollierbarer Genauigkeit

FMCA-25 03: Vektoren, Matrizen und Vektorisierung in Python

Inhalt des Skriptums seit dem Sommersemester 2025

Hier finden Sie die Kapitel aus den Vergangenen Jahren (legacy):

Die Jupyter-Notebooks zur Legacy-Variante der Lehrveranstaltung finden Sie im zugehörigen GitHub-Repository.

3 Vektoren, Matrizen und Vektorisierung in Python¶

In dieser Einheit beschäftigen wir uns mit einem der fundamentalen Werkzeuge der modernen Wissenschaft und Technik: der linearen Algebra. Die lineare Algebra bildet das mathematische Grundgerüst für zahlreiche Anwendungen in den Bereichen Datenanalyse, Machine Learning, Computergrafik, Physik und vielen weiteren Disziplinen. Python bietet uns mit der Bibliothek NumPy eine leistungsstarke Umgebung, um mit Vektoren und Matrizen effizient und direkt zu arbeiten.

Nach dem Studium dieser Einheit sollten Sie zumindest folgende drei der wichtigsten Punkte hier verstehen:

Wie man Vektoren und Matrizen sowie deren Operationen in Python mit NumPy umsetzt
Was Vektorisierung bedeutet und wie und warum wir dabei Schleifen durch effizientere vektorisierte Operationen ersetzen können
Wie Arrays in der Bildbearbeitung ganz einfach zu Einsatz kommen

3.1 Grundlagen der linearen Algebra in Python mit NumPy¶

3.1.1 Vektoren: Definition und Implementierung als 1D-NumPy-Array¶

Ein Vektor ist in der linearen Algebra eine geordnete Liste von Zahlen. Geometrisch können wir uns einen Vektor als eine Pfeildarstellung im Raum vorstellen, die eine Richtung und eine Länge besitzt. In Python repräsentieren wir Vektoren am besten mithilfe von NumPy-Arrays. Entgegen einem ersten Instinkt sind nämlich Listen in Python nicht ideal, weil sich Listen-Elemente grundsätzlich im Datentyp unterscheiden können.

Das bedeutet, dass man Strings, Integers, Tupel, und sogar weitere Listen als Elemente in die gleiche Liste schreiben darf. Das widerspricht allerdings dem Grundkonzept eines Vektors, dessen Elemente bei bestimmten Transformationen des Vektors (z.B. einer Rotation im Raum) ineinander übergehen und miteinander vermischt werden, sodass ein gleicher Datentyp für alle Elemente vorzugeben ist. Genau diese Vorgabe erfüllen Arrays in NumPy. Insbesondere werden die Datentypen von verschiedenen Listen-Elementen bei der Konversion in ein NumPy-Array vereinheitlicht, was zu unerwarteten Artefakten führen kann.

NumPy (Numerical Python) ist eine der wichtigsten Bibliotheken für wissenschaftliches Rechnen in Python. Sie bietet effiziente Datenstrukturen für mehrdimensionale Arrays und eine Vielzahl von mathematischen Funktionen, um mit diesen zu arbeiten. Diese Funktionen und Strukturen sind dabei bereits hochoptimiert und dadurch grundsätzlich auch sehr schnell in der Ausführung.

Beginnen wir mit der Erstellung von Vektoren. Die Code snippets hier und im Folgenden kommen wieder von Claude 3.7 Sonnet:

In [2]:

import numpy as np

# Einen Vektor aus einer Liste erstellen
v1 = np.array([1, 2, 3])

# Einen Vektor mit Nullen erstellen
v2 = np.zeros(5)  # [0. 0. 0. 0. 0.]

# Einen Vektor mit Einsen erstellen
v3 = np.ones(3)   # [1. 1. 1.]

# Einen Vektor mit gleichmäßig verteilten Werten
v4 = np.linspace(0, 10, 5)  # [0. 2.5 5. 7.5 10.]

# Einen Vektor mit zufälligen Werten
v5 = np.random.rand(4)  # Zufällige Werte zwischen 0 und 1

print(f"v1: {v1}, Typ: {type(v1)}, Shape (Dimensionen): {v1.shape}")

v1: [1 2 3], Typ: <class 'numpy.ndarray'>, Shape (Dimensionen): (3,)

Wichtige Eigenschaften eines NumPy-Array-Vektors:

shape: Gibt die Dimensionen des Arrays zurück, für einen Vektor ist das ein Tupel mit einem Element, z.B. (3,)
dtype: Gibt den Datentyp der Elemente an (z.B. int64, float64)
size: Gibt die Gesamtanzahl der Elemente zurück

3.1.2 Erstellen und Manipulieren von Vektoren: Addition, Skalarmultiplikation, Skalarprodukt¶

Mit NumPy können wir verschiedene Vektoroperationen einfach und effizient durchführen:

Vektoraddition: Die Addition zweier Vektoren erfolgt elementweise.

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
c = a + b  # [5, 7, 9]

Skalarmultiplikation: Ein Vektor kann mit einem Skalar (einer einzelnen Zahl) multipliziert werden.

a = np.array([1, 2, 3])
s = 2
b = s * a  # [2, 4, 6]

Skalarprodukt (auch Punktprodukt oder Inneres Produkt genannt): Die Summe der Produkte der entsprechenden Komponenten.

a = np.array([1, 2, 3])
b = np.array([4, 5, 6])
dot_product = np.dot(a, b)  # 1*4 + 2*5 + 3*6 = 32
# Alternative Schreibweise
dot_product = a.dot(b)
# Oder bei neueren NumPy-Versionen
dot_product = a @ b

Weitere wichtige Vektoroperationen:

v = np.array([1, 2, 3])

# Betrag (Länge) eines Vektors
magnitude = np.linalg.norm(v)  # sqrt(1^2 + 2^2 + 3^2) = sqrt(14)

# Elementweise Multiplikation
product = a * b  # [1*4, 2*5, 3*6] = [4, 10, 18]

# Elementweise Division
division = a / b  # [1/4, 2/5, 3/6] = [0.25, 0.4, 0.5]

# Elementweise Potenzierung
squared = v**2  # [1, 4, 9]

Hier haben wier gerade eine sehr wichtige Eigenschaft von NumPy-Arrays gesehen: Die einfachen mathematischen Operationen aber auch viele andere Funktionen werden standardmäßig elementweise ausgeführt. Diese einfache Handhabung wird uns noch gute Dientse leisten und macht NumPy-Code grundsätzlich um einiges lesbarer als vergleichsweise denselben Programminhalt, wenn er mit Listen implementiert wird.

3.1.3 Matrizen: Definition und Implementierung als 2D-NumPy-Array¶

Eine Matrix ist in der linearen Algebra eine rechteckige Anordnung von Zahlen in Zeilen und Spalten. In Python werden Matrizen als 2D-NumPy-Arrays repräsentiert.

# Eine 2x3 Matrix erstellen (2 Zeilen, 3 Spalten)
A = np.array([[1, 2, 3],
              [4, 5, 6]])

print(f"Matrix A:\n{A}")
print(f"Form: {A.shape}")  # (2, 3)

# Eine Matrix mit Nullen erstellen
B = np.zeros((3, 4))  # 3x4 Matrix mit Nullen

# Eine Matrix mit Einsen erstellen
C = np.ones((2, 2))   # 2x2 Matrix mit Einsen

# Eine Einheitsmatrix erstellen
I = np.eye(3)         # 3x3 Einheitsmatrix

# Eine Matrix mit zufälligen Werten
D = np.random.rand(2, 3)  # 2x3 Matrix mit zufälligen Werten zwischen 0 und 1

3.1.4 Erstellen und Manipulieren von Matrizen: Addition, Multiplikation, Transposition¶

Matrixaddition: Wie bei Vektoren erfolgt die Addition zweier Matrizen elementweise. Die Matrizen müssen die gleiche Form haben.

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])
C = A + B  # [[6, 8], [10, 12]]

Matrixmultiplikation: Anders als bei der Addition werden bei der Multiplikation zweier Matrizen die Zeilen der ersten Matrix mit den Spalten der zweiten Matrix multipliziert und aufsummiert.

In [3]:

A = np.array([[1, 2], [3, 4]])
B = np.array([[5, 6], [7, 8]])

# Matrixmultiplikation
C = np.dot(A, B)  
# C = A @ B  # Alternative Syntax in neueren Python-Versionen

print(f"A × B =\n{C}")

A × B =
[[19 22]
 [43 50]]

Die Matrixmultiplikation ist nur definiert, wenn die Anzahl der Spalten in der ersten Matrix gleich der Anzahl der Zeilen in der zweiten Matrix ist. Das Ergebnis hat dann die Anzahl der Zeilen der ersten Matrix und die Anzahl der Spalten der zweiten Matrix.

Transposition: Bei der Transposition einer Matrix werden die Zeilen zu Spalten und umgekehrt.

In [4]:

A = np.array([[1, 2, 3], [4, 5, 6]])
A_transposed = A.T
print(f"A =\n{A}")
print(f"A^T =\n{A_transposed}")

A =
[[1 2 3]
 [4 5 6]]
A^T =
[[1 4]
 [2 5]
 [3 6]]

Weitere wichtige Matrixoperationen:

A = np.array([[1, 2], [3, 4]])

# Determinante einer quadratischen Matrix
det_A = np.linalg.det(A)  # 1*4 - 2*3 = -2

# Inverse einer Matrix (falls sie existiert)
A_inv = np.linalg.inv(A)
print(f"A^(-1) =\n{A_inv}")

# Überprüfen: A * A^(-1) = Einheitsmatrix
print(f"A × A^(-1) =\n{np.dot(A, A_inv)}")

# Matrixrang
rank = np.linalg.matrix_rank(A)

# Eigenwerte und Eigenvektoren (nur für quadratische Matrizen)
eigenvalues, eigenvectors = np.linalg.eig(A)

In den nächsten Abschnitten werden wir sehen, wie diese grundlegenden Operationen in Python vektorisiert werden können, um code effizienter und lesbarer zu gestalten, sowie praktische Anwendungen dieser Konzepte kennenlernen.

3.2 Vektorisierung in Python¶

Nachdem wir die grundlegenden Konzepte der linearen Algebra und deren Implementierung in NumPy kennengelernt haben, wenden wir uns nun kurz einem wichtigen Konzept für effizientes wissenschaftliches Rechnen in Python zu: der Vektorisierung.

3.2.1 Das Konzept der Vektorisierung¶

Vektorisierung bezeichnet die Umwandlung von iterativen Operationen (wie Schleifen) in äquivalente Operationen auf ganzen Arrays. Statt Elemente einzeln nacheinander zu verarbeiten, werden bei der Vektorisierung Operationen auf ganze Datenblöcke gleichzeitig angewendet.

Lassen Sie uns dies an einem einfachen Beispiel verdeutlichen. Angenommen, wir möchten jeden Wert in einem Array quadrieren:

Iterativer Ansatz (mit Schleife):

In [5]:

import numpy as np
import time

# Erstelle ein großes Array
n = 1000000
arr = np.random.rand(n)

# Iterativer Ansatz mit einer Schleife
def square_loop(arr):
    result = np.zeros_like(arr)
    for i in range(len(arr)):
        result[i] = arr[i] ** 2
    return result

# Zeitmessung
start_time = time.time()
result_loop = square_loop(arr)
loop_time = time.time() - start_time
print(f"Zeit mit Schleife: {loop_time:.6f} Sekunden")

Zeit mit Schleife: 0.245403 Sekunden

Vektorisierter Ansatz:

In [6]:

# Vektorisierter Ansatz
def square_vectorized(arr):
    return arr ** 2

# Zeitmessung
start_time = time.time()
result_vectorized = square_vectorized(arr)
vectorized_time = time.time() - start_time
print(f"Zeit mit Vektorisierung: {vectorized_time:.6f} Sekunden")

# Vergleich der Geschwindigkeit
speedup = loop_time / vectorized_time
print(f"Beschleunigung durch Vektorisierung: {speedup:.2f}x")

# Überprüfung der Ergebnisse
print(f"Ergebnisse identisch: {np.allclose(result_loop, result_vectorized)}")

Zeit mit Vektorisierung: 0.002263 Sekunden
Beschleunigung durch Vektorisierung: 108.44x
Ergebnisse identisch: True

Wie wir sehen können, führt die Vektorisierung zu einer erheblichen Beschleunigung. Der Grund dafür liegt in mehreren Faktoren:

Optimierte C-Implementierungen: NumPy-Operationen sind in optimiertem C-Code implementiert.
Parallelisierung: Viele vektorisierte Operationen können auf modernen Prozessoren parallelisiert werden.
Weniger Python-Overhead: Python-Schleifen haben einen höheren Overhead als native C-Implementierungen.
Speichereffizienz: Vektorisierte Operationen können effizienter auf den Speicher zugreifen.

3.2.2 Vorteile gegenüber Schleifen: Performance und Lesbarkeit¶

Neben der deutlich besseren Performance bieten vektorisierte Operationen auch Vorteile hinsichtlich der Lesbarkeit und Wartbarkeit des Codes. Das haben wir im Beispiel gerade eben bereits relativ deutlich gesehen. Listen wir hier die wichtigsten Vorteile explizit:

Kürzerer und prägnanterer Code: Vektorisierte Operationen reduzieren die Codekomplexität.
Ausdrucksstarke mathematische Notation: Die Syntax von NumPy-Operationen ähnelt der mathematischen Notation.
Weniger Fehleranfälligkeit: Indexierungsfehler und Off-by-one-Fehler werden vermieden.
Bessere Optimierbarkeit: NumPy kann interne Optimierungen durchführen, die in handgeschriebenen Schleifen nicht möglich wären.

Und nun betrachten wir ein weiteres etwas umfangreicheres Beispiel zur Vektorisierung: Die Berechnung des euklidischen Abstands zwischen zwei Punktmengen.

In [7]:

import numpy as np
import time

# Erstelle zwei Mengen von Punkten
n_points = 1000
dim = 3
points_a = np.random.rand(n_points, dim)
points_b = np.random.rand(n_points, dim)

# Iterativer Ansatz
def pairwise_distances_loop(a, b):
    n = a.shape[0]
    distances = np.zeros(n)
    for i in range(n):
        # Euklidischer Abstand zwischen a[i] und b[i]
        distances[i] = np.sqrt(np.sum((a[i] - b[i])**2))
    return distances

# Vektorisierter Ansatz
def pairwise_distances_vectorized(a, b):
    return np.sqrt(np.sum((a - b)**2, axis=1))

# Zeitmessung
start_time = time.time()
dist_loop = pairwise_distances_loop(points_a, points_b)
loop_time = time.time() - start_time
print(f"Zeit mit Schleife: {loop_time:.6f} Sekunden")

start_time = time.time()
dist_vec = pairwise_distances_vectorized(points_a, points_b)
vec_time = time.time() - start_time
print(f"Zeit mit Vektorisierung: {vec_time:.6f} Sekunden")

speedup = loop_time / vec_time
print(f"Beschleunigung: {speedup:.2f}x")

Zeit mit Schleife: 0.005228 Sekunden
Zeit mit Vektorisierung: 0.000091 Sekunden
Beschleunigung: 57.55x

Der vektorisierte Code ist also nicht nur schneller, sondern auch viel kürzer und leichter zu verstehen, wenn man mit der NumPy-Syntax vertraut ist. Die einzige nicht-intuitive Sache in diesem konkreten Fall ist die Summierung über axis=1, bei der über die räumlichen Dimensionen (das ist der Spaltenindex in den originalen Arrays, der Zeilenindex ist Index 0) der Differenzen summiert wird. Hier wird also sehr elegant genau das hingeschrieben, was zu tun ist.

3.2.3 Wann Vektorisierung sinnvoll ist und wann nicht¶

Obwohl Vektorisierung in vielen Fällen zu erheblichen Leistungsverbesserungen führt, gibt es Situationen, in denen sie möglicherweise nicht die beste Wahl ist:

Wann ist Vektorisierung besonders sinnvoll?

Bei großen Datenmengen: Je größer die Datenmenge (nicht die Dimension der damit verbundenen Arrays, denn das kann zu Speicherproblemen führen), desto größer der Geschwindigkeitsvorteil
Bei einfachen, gleichförmigen Operationen: Elementweise Operationen, Matrixmultiplikationen, statistische Berechnungen
Wenn Speicherverbrauch kein Problem ist: Vektorisierte Operationen erstellen oft interne temporäre Arrays

Wann sollte man vorsichtig sein oder Alternativen in Betracht ziehen?

Bei komplexen, bedingten Operationen: Wenn für jedes Element unterschiedliche Entscheidungen getroffen werden müssen. Das einleuchtendste einfach Beispiel hierfür ist ein loop, der bei der Erfüllung einer index-abhängigen if-Bedingung abgebrochen wird
Bei sehr großen Datenmengen mit begrenztem Speicher: Vektorisierung kann zu höherem Speicherverbrauch führen, siehe oben
Bei sequentiellen Abhängigkeiten: Wenn jede Berechnung vom Ergebnis der vorherigen abhängt
Wenn Lesbarkeit in komplexen Situationen wichtiger ist als Performance: In manchen Fällen ist eine explizite Schleife ausnahmsweise verständlicher als die kompakte Notation mit Arrays

In solchen Fällen können Alternativen wie NumPy’s np.vectorize, Cython, Numba oder spezielle Funktionen wie np.apply_along_axis in Betracht gezogen werden.

Hier ein Beispiel für eine Situation, in der Vektorisierung schwierig ist:

# Eine Funktion mit komplexer Bedingungslogik
def complex_function(x):
    if x < 0:
        return x**2
    elif x < 1:
        return np.sin(x)
    else:
        return np.log(x)

# Anwenden auf ein Array
arr = np.array([-2, -1, 0, 0.5, 1, 2])

# Mit einer Schleife
result_loop = np.zeros_like(arr)
for i, val in enumerate(arr):
    result_loop[i] = complex_function(val)

# Mit np.vectorize (eine "Pseudovektorisierung")
vectorized_func = np.vectorize(complex_function)
result_vectorized = vectorized_func(arr)

print("Mit Schleife:", result_loop)
print("Mit np.vectorize:", result_vectorized)

Hinweis: np.vectorize bietet keine echte Vektorisierung im Sinne der Performanceoptimierung – es ist im Wesentlichen eine elegante Möglichkeit, eine Schleife zu schreiben. Für echte Performanceverbesserungen bei komplexen Funktionen sollten Bibliotheken wie Numba in Betracht gezogen werden.

Fazit zur Vektorisierung:

Vektorisierung ist ein mächtiges Konzept in Python, das die Geschwindigkeit numerischer Berechnungen erheblich verbessern und gleichzeitig zu eleganterem, lesbarerem Code führen kann. Als moderne Datenwissenschaftler und Programmierer sollten wir immer nach Möglichkeiten suchen, unseren Code zu vektorisieren, wenn es sinnvoll ist.

3.3 Beispiel-Anwendung von NumPy in der Linearen Algebra¶

Nach der Einführung in die Grundlagen der linearen Algebra und Vektorisierung in Python wenden wir uns nun zwei konkreten einfachen Anwendungen zu.

3.3.1 Numerisches Lösen linearer Gleichungssysteme¶

Ein lineares Gleichungssystem besteht aus einer Menge von linearen Gleichungen mit mehreren Unbekannten. In der Matrixschreibweise kann ein solches System als $A\mathbf{x} = \mathbf{b}$ dargestellt werden, wobei $A$ die Koeffizientenmatrix, $\mathbf{x}$ der Vektor der Unbekannten und $\mathbf{b}$ der Ergebnisvektor ist.

Beispiel eines linearen Gleichungssystems mit drei Unbekannten:

$$\begin{align*} 2x + 3y – z &= 5 \\ x – y + 2z &= -1 \\ 3x + y + z &= 2 \end{align*}$$

In Matrixform:

$$\begin{pmatrix} 2 & 3 & -1 \\ 1 & -1 & 2 \\ 3 & 1 & 1 \end{pmatrix} \begin{pmatrix} x \\ y \\ z \end{pmatrix} = \begin{pmatrix} 5 \\ -1 \\ 2 \end{pmatrix}$$

Mit NumPy können wir dieses System auf verschiedene Weise lösen:

Methode 1: Direkte Lösung mit `np.linalg.solve`¶

Die Funktion np.linalg.solve ist für das Lösen linearer Gleichungssysteme optimiert und sollte bevorzugt verwendet werden, wenn die Matrix $A$ quadratisch und invertierbar ist.

In [8]:

import numpy as np

# Koeffizientenmatrix A
A = np.array([
    [2, 3, -1],
    [1, -1, 2],
    [3, 1, 1]
])

# Rechte Seite b
b = np.array([5, -1, 2])

# Lösen des Systems Ax = b
x = np.linalg.solve(A, b)

print("Lösung des Systems:")
print(f"x = {x[0]:.4f}")
print(f"y = {x[1]:.4f}")
print(f"z = {x[2]:.4f}")

# Überprüfen der Lösung
tolerance = 1e-10
residual = np.linalg.norm(A @ x - b)
print(f"\nResiduum ||Ax - b|| = {residual:.10f}")
print(f"Lösung korrekt: {residual < tolerance}")

Lösung des Systems:
x = -0.2000
y = 2.0000
z = 0.6000

Residuum ||Ax - b|| = 0.0000000000
Lösung korrekt: True

Methode 2: Lösung über die Inverse der Matrix¶

Eine alternative Methode ist, die Inverse von $A$ zu berechnen und mit $\mathbf{b}$ zu multiplizieren: $\mathbf{x} = A^{-1}\mathbf{b}$. Diese Methode ist jedoch numerisch weniger stabil und ineffizienter als np.linalg.solve.

In [9]:

# Berechnen der Inversen von A
A_inv = np.linalg.inv(A)

# Lösung berechnen: x = A^(-1) * b
x_inv = A_inv @ b

print("\nLösung mit der Inversen:")
print(f"x = {x_inv[0]:.4f}")
print(f"y = {x_inv[1]:.4f}")
print(f"z = {x_inv[2]:.4f}")

Lösung mit der Inversen:
x = -0.2000
y = 2.0000
z = 0.6000

3.3.2 Berechnung von Matrix-Eigensystemen (Eigenwerte und Eigenvektoren) mit NumPy¶

Eigenwerte und Eigenvektoren sind fundamentale Konzepte in der linearen Algebra mit zahlreichen Anwendungen in der Physik, Statistik und im maschinellen Lernen. Ein Eigenvektor einer quadratischen Matrix $A$ ist ein Vektor $\mathbf{v}$, der bei Multiplikation mit $A$ nur seine Länge, nicht aber seine Richtung ändert. Der Faktor, um den sich die Länge ändert, ist der Eigenwert $\lambda$:

$$A\mathbf{v} = \lambda\mathbf{v}$$

NumPy bietet effiziente Funktionen zur Berechnung von Eigenwerten und Eigenvektoren:

In [10]:

import numpy as np
import matplotlib.pyplot as plt

# Beispielmatrix
A = np.array([
    [4, 2],
    [1, 3]
])

print("Matrix A:")
print(A)

# Berechnung von Eigenwerten und Eigenvektoren
eigenvalues, eigenvectors = np.linalg.eig(A)

print("\nEigenwerte:")
for i, eigenvalue in enumerate(eigenvalues):
    print(f"λ_{i+1} = {eigenvalue:.4f}")

print("\nEigenvektoren (spaltenweise):")
print(eigenvectors)

# Verifizierung der Eigenwert-Gleichung A·v = λ·v
for i in range(len(eigenvalues)):
    eigval = eigenvalues[i]
    eigvec = eigenvectors[:, i]
    
    # Berechne A·v
    Av = A @ eigvec
    
    # Berechne λ·v
    lambda_v = eigval * eigvec
    
    print(f"\nÜberprüfung für Eigenwert λ_{i+1} = {eigval:.4f}:")
    print(f"A·v_{i+1} = {Av}")
    print(f"λ_{i+1}·v_{i+1} = {lambda_v}")
    print(f"Differenz: {np.linalg.norm(Av - lambda_v):.10f}")

Matrix A:
[[4 2]
 [1 3]]

Eigenwerte:
λ_1 = 5.0000
λ_2 = 2.0000

Eigenvektoren (spaltenweise):
[[ 0.89442719 -0.70710678]
 [ 0.4472136   0.70710678]]

Überprüfung für Eigenwert λ_1 = 5.0000:
A·v_1 = [4.47213595 2.23606798]
λ_1·v_1 = [4.47213595 2.23606798]
Differenz: 0.0000000000

Überprüfung für Eigenwert λ_2 = 2.0000:
A·v_2 = [-1.41421356  1.41421356]
λ_2·v_2 = [-1.41421356  1.41421356]
Differenz: 0.0000000000

Visualisierung der Eigenvektoren einer 2×2-Matrix¶

Eine anschauliche Weise, Eigenvektoren zu verstehen, ist die Visualisierung ihrer Wirkung im 2D-Raum. Wir können zeigen, wie eine Matrix $A$ verschiedene Vektoren transformiert, und insbesondere, wie Eigenvektoren ihre Richtung beibehalten.

In [11]:

# Visualisierung von Eigenvektoren im 2D-Raum
def plot_eigenvectors(A, eigvals, eigvecs):
    plt.figure(figsize=(10, 10))
    
    # Gitterpunkte erzeugen
    x = np.linspace(-3, 3, 7)
    y = np.linspace(-3, 3, 7)
    X, Y = np.meshgrid(x, y)
    grid_points = np.column_stack([X.flatten(), Y.flatten()])
    
    # Transformierte Gitterpunkte berechnen
    transformed_points = grid_points @ A.T
    
    # Gitter vor und nach der Transformation zeichnen
    plt.scatter(grid_points[:, 0], grid_points[:, 1], c='k', s=30, alpha=0.5, label='Originales Gitter')
    plt.scatter(transformed_points[:, 0], transformed_points[:, 1], c='darkgray', s=30, alpha=0.5, label='Transformiertes Gitter')
    
    # Eigenvektoren skalieren
    scaled_eigvecs = eigvecs * 2
    
    # Eigenvektoren zeichnen
    colors = ['red', 'blue']
    for i in range(len(eigvals)):
        v = scaled_eigvecs[:, i]
        plt.arrow(0, 0, v[0], v[1], head_width=0.2, head_length=0.3, fc=colors[i], ec=colors[i], 
                  label=f'Eigenvektor zu λ={eigvals[i]:.2f}')
        
        # Transformierte Eigenvektoren
        transformed_v = A @ v
        plt.arrow(0, 0, transformed_v[0], transformed_v[1], head_width=0.2, head_length=0.3, 
                  fc=colors[i], ec=colors[i], linestyle='dashed', alpha=0.5)
    
    plt.axhline(y=0, color='k', linestyle='-', alpha=0.3)
    plt.axvline(x=0, color='k', linestyle='-', alpha=0.3)
    plt.grid(alpha=0.3)
    plt.xlim(-5, 5)
    plt.ylim(-5, 5)
    plt.xlabel('x')
    plt.ylabel('y')
    plt.title('Visualisierung der Eigenvektoren und Transformation')
    plt.legend()
    plt.axis('equal')
    plt.show()

# Visualisierung aufrufen
plot_eigenvectors(A, eigenvalues, eigenvectors)

Eigenwerte und Eigenvektoren charakterisieren das Verhalten linearer Transformationen (solche werden durch Matrizen dargestellt)
Eigenvektoren sind Vektoren, die bei der Multiplikation mit einer Matrix nur skaliert, aber nicht in ihrer Richtung verändert werden
Der Skalierungsfaktor ist der zugehörige Eigenwert
NumPy bietet mit np.linalg.eig eine effiziente Funktion zur Berechnung von Eigenwerten und Eigenvektoren
Eigenwerte und Eigenvektoren haben zahlreiche praktische Anwendungen in verschiedenen Bereichen der Wissenschaft und Technik

3.4 Praktische Anwendungen von NumPy-Arrays¶

Nachdem wir die Grundlagen der linearen Algebra, Vektorisierung und einige theoretische Anwendungen kennengelernt haben, wollen wir nun praktischere Anwendungen von NumPy-Arrays untersuchen. NumPy-Arrays sind nicht nur für mathematische Berechnungen nützlich, sondern finden Anwendung in verschiedenen Bereichen wie Bildverarbeitung, Graphentheorie, Signalverarbeitung und wissenschaftlichen Simulationen.

3.4.1 Bildverarbeitung: Transformationen und Filter¶

Bilder können in Python als mehrdimensionale NumPy-Arrays repräsentiert werden:

Graustufenbilder: 2D-Arrays, wobei jeder Wert die Intensität eines Pixels darstellt
Farbbilder (RGB): 3D-Arrays mit der Größe (Höhe, Breite, 3), wobei die dritte Dimension die Rot-, Grün- und Blau-Kanäle repräsentiert

Diese Array-Darstellung ermöglicht es uns, verschiedene Bildverarbeitungstechniken durch einfache NumPy-Operationen zu implementieren.

Grundlegende Bildoperationen¶

Laden und Anzeigen eines Bildes:

In [12]:

import numpy as np
import os
import matplotlib.pyplot as plt
from PIL import Image  # Python Imaging Library (Pillow)

# Bild laden und in NumPy-Array konvertieren
image_path = os.path.join('data', 'pinky.jpg')
img = np.array(Image.open(image_path))

# Überprüfen der Form des Arrays
print(f"Bildform: {img.shape}")  # z.B. (height, width, 3) für ein RGB-Bild

# Bild anzeigen
plt.figure(figsize=(8, 6))
plt.imshow(img)
plt.axis('off')
plt.title('Originalbild')
plt.show()

Bildform: (1512, 2016, 3)

Farbbild in Graustufen umwandeln:

In [13]:

# Methode 1: Durchschnitt der RGB-Kanäle
grayscale_avg = img.mean(axis=2).astype(np.uint8)

# Methode 2: Gewichteter Durchschnitt (der menschlichen Wahrnehmung näher)
grayscale_weighted = (0.299 * img[:,:,0] + 0.587 * img[:,:,1] + 0.114 * img[:,:,2]).astype(np.uint8)

# Anzeigen der Graustufenbilder
plt.figure(figsize=(12, 6))

plt.subplot(121)
plt.imshow(grayscale_avg, cmap='gray')
plt.axis('off')
plt.title('Graustufenbild (Durchschnitt)')

plt.subplot(122)
plt.imshow(grayscale_weighted, cmap='gray')
plt.axis('off')
plt.title('Graustufenbild (Gewichtet)')

plt.tight_layout()
plt.show()

Farbkanäle extrahieren:

In [14]:

# Alle drei Farbkanäle nebeneinander
plt.figure(figsize=(10, 5))

# Definiere alle nötigen Colormaps in einer Liste
colormaps = ["Reds", "Greens", "Blues"]

# Loop über den index der drei Farbkanäle
for ind_color in range(3):
    ax = plt.subplot(1, 3, ind_color+1)
    ax.imshow(img[:,:,ind_color], cmap=colormaps[ind_color]) 

plt.show()

Bildtransformationen¶

Spiegeln und Drehen:

In [15]:

# Horizontal spiegeln
img_flipped_h = np.fliplr(img)

# Vertikal spiegeln
img_flipped_v = np.flipud(img)

# Um 90 Grad drehen
img_rotated = np.rot90(img)

# Anzeigen der transformierten Bilder
plt.figure(figsize=(15, 10))

plt.subplot(221)
plt.imshow(img)
plt.axis('off')
plt.title('Original')

plt.subplot(222)
plt.imshow(img_flipped_h)
plt.axis('off')
plt.title('Horizontal gespiegelt')

plt.subplot(223)
plt.imshow(img_flipped_v)
plt.axis('off')
plt.title('Vertikal gespiegelt')

plt.subplot(224)
plt.imshow(img_rotated)
plt.axis('off')
plt.title('Um 90° gedreht')

plt.tight_layout()
plt.show()

Skalieren und Zuschneiden:

In [16]:

# Zuschneiden
height, width = img.shape[:2]
top, left = height // 4, width // 4
bottom, right = 3 * height // 4, 3 * width // 4
img_cropped = img[top:bottom, left:right]

# Skalieren (einfache Methode mit NumPy)
new_height, new_width = height // 20, width // 20
img_rescaled = np.array(Image.fromarray(img).resize((new_width, new_height)))

# Anzeigen
plt.figure(figsize=(12, 6))

plt.subplot(121)
plt.imshow(img_cropped)
plt.axis('off')
plt.title('Zugeschnittenes Bild')

plt.subplot(122)
plt.imshow(img_rescaled)
plt.axis('off')
plt.title('Skaliertes Bild')

plt.tight_layout()
plt.show()

Bildfilterung und Faltungsoperationen¶

Eine wichtige Operation in der Bildverarbeitung ist die Faltung (Convolution), bei der ein Filter (oder Kernel) über das Bild geschoben wird, um verschiedene Effekte zu erzielen.

Anwenden von Filtern mit NumPy:

In [17]:

def apply_kernel(image, kernel):
    """Wendet einen Faltungskernel auf ein Graustufenbild an."""
    # Kernel-Dimensionen
    k_height, k_width = kernel.shape
    
    # Padding für die Bildränder
    pad_height = k_height // 2
    pad_width = k_width // 2
    
    # Ausgabebild initialisieren
    output = np.zeros_like(image)
    
    # Faltung durchführen
    for i in range(pad_height, image.shape[0] - pad_height):
        for j in range(pad_width, image.shape[1] - pad_width):
            # Region des Bildes unter dem Kernel
            region = image[i-pad_height:i+pad_height+1, j-pad_width:j+pad_width+1]
            
            # Faltung berechnen (elementweise Multiplikation und Summierung)
            output[i, j] = np.sum(region * kernel)
    
    return output

# Beispiel-Kernel
# 1. Weichzeichner (Blur)
blur_kernel = np.ones((3, 3)) / 9

# 2. Schärfen (Sharpen)
sharpen_kernel = np.array([
    [0, -1, 0],
    [-1, 5, -1],
    [0, -1, 0]
])

# 3. Kantenerkennung (Edge Detection)
edge_kernel = np.array([
    [-1, -1, -1],
    [-1, 8, -1],
    [-1, -1, -1]
])

# Anwenden der Filter auf ein Graustufenbild
grayscale = grayscale_weighted
blurred = apply_kernel(grayscale, blur_kernel).clip(0, 255).astype(np.uint8)
sharpened = apply_kernel(grayscale, sharpen_kernel).clip(0, 255).astype(np.uint8)
edges = apply_kernel(grayscale, edge_kernel).clip(0, 255).astype(np.uint8)

# Zoom auf einen Ausschnitt zur Besseren Darstellung der Unterschiede
top, left = height // 3, width // 3
bottom, right = 2 * height // 3, 2 * width // 3
blurred_cropped = blurred[top:bottom, left:right]
sharpened_cropped = sharpened[top:bottom, left:right]


# Anzeigen der Ergebnisse
plt.figure(figsize=(15, 10))

plt.subplot(221)
plt.imshow(grayscale, cmap='gray')
plt.axis('off')
plt.title('Original (Graustufen)')

plt.subplot(222)
plt.imshow(blurred_cropped, cmap='gray')
plt.axis('off')
plt.title('Weichgezeichnet')

plt.subplot(223)
plt.imshow(sharpened_cropped, cmap='gray')
plt.axis('off')
plt.title('Geschärft')

plt.subplot(224)
plt.imshow(edges, cmap='gray')
plt.axis('off')
plt.title('Kantenerkennung')

plt.tight_layout()
plt.show()

Vektorisierte Version der Faltung:

Die oben gezeigte Implementierung der Faltung verwendet Schleifen, was in Python ineffizient ist. Hier ist eine vektorisierte Version mit scipy.signal.convolve2d, zum Code-Vergleich:

from scipy import signal

# Vektorisierte Faltung
blurred_vec = signal.convolve2d(grayscale, blur_kernel, mode='same', boundary='symm')
sharpened_vec = signal.convolve2d(grayscale, sharpen_kernel, mode='same', boundary='symm')
edges_vec = signal.convolve2d(grayscale, edge_kernel, mode='same', boundary='symm')

# Ergebnisse in gültigen Bereich bringen
blurred_vec = np.clip(blurred_vec, 0, 255).astype(np.uint8)
sharpened_vec = np.clip(sharpened_vec, 0, 255).astype(np.uint8)
edges_vec = np.clip(edges_vec, 0, 255).astype(np.uint8)

3.5 Übungsaufgabe: Anpassen der Visualisierung von Klimadaten in einem Bild¶

Im Rahmen der Aktionswoche “Open your Course 4 Climate Crisis” (OC4CC) von der Österreichischen Hochschüler_innenschaft und Fridays for Future Austria wählen wir unsere Übungsaufgabe diesmal aus diesem Themengebiet. Konkret werden wir einschlägige Daten als Bilder ins Notebook laden und dann einer Bearbeitung unterziehen.

Die Daten stammen von der EU-Mission Copernicus, konkret aus dem Datensatz “Land Surface Temperature (Synthesis and Thermal Condition Index) 2017-2021 (raster 5 km), global, 10-daily – version 1” (login erforderlich). Ich habe Ihnen von mehreren Daten aus dem Zeitraum Jänner 2017 bis Jänner 2021 Snapshots der Visualisierung der gemessenen Temperaturwerte im Datenverzeichnis abgelegt. Diese Bilder sind die Grundlage unserer Übung.

Das Laden der Bilder und Testen der Bild-Anzeige habe ich hier der Einfachheit bereits für Sie vorbereitet. Den Rest der Übung erarbeiten Sie bitte wie gewohnt in Zusammenarbeit mit dem LLM Ihrer Wahl.

In [18]:

import numpy as np
import os
import matplotlib.pyplot as plt
from PIL import Image
import cv2
from scipy import ndimage
import seaborn as sns

# Bilder laden und in NumPy-Arrays konvertieren
path_2017_01 = os.path.join('data', 'satellite-image-temperature-2017-01.jpg')
img_2017_01 = np.array(Image.open(path_2017_01))
path_2017_07 = os.path.join('data', 'satellite-image-temperature-2017-07.jpg')
img_2017_07 = np.array(Image.open(path_2017_07))
path_2018_07 = os.path.join('data', 'satellite-image-temperature-2018-07.jpg')
img_2018_07 = np.array(Image.open(path_2018_07))
path_2019_01 = os.path.join('data', 'satellite-image-temperature-2019-01.jpg')
img_2019_01 = np.array(Image.open(path_2019_01))
path_2019_07 = os.path.join('data', 'satellite-image-temperature-2019-07.jpg')
img_2019_07 = np.array(Image.open(path_2019_07))
path_2020_07 = os.path.join('data', 'satellite-image-temperature-2020-07.jpg')
img_2020_07 = np.array(Image.open(path_2020_07))
path_2021_01 = os.path.join('data', 'satellite-image-temperature-2021-01.jpg')
img_2021_01 = np.array(Image.open(path_2021_01))

# Überprüfen der Form eines dieser Arrays
print(f"Bilddimensionen: {img_2019_01.shape}")  # z.B. (height, width, 3) für ein RGB-Bild

# Bild anzeigen
plt.figure(figsize=(12, 9))
plt.imshow(img_2019_01)
plt.axis('off')
plt.title('Temperatur Jänner 2019')
plt.show()

Bilddimensionen: (1168, 3246, 3)

Diese Bilder stellen als Temperaturdatendarstellungen zu verschiedenen Zeiten im Jahr sowie aus den Julimonaten von vier aufeinanderfolgenden Jahren einen interessanten Ausgangspunkt für viele mögliche Analysen und Vergleiche dar. Ich möchte Sie ermutigen, sich einige interessante Fragestellungen zu überlegen und dann zu versuchen, diese zu beantworten.

Als erste Schritte gilt es folgendes zu beachten:

Wir üben hier den Umgang mit Bilddaten, also Farbwerten, die Pixeln zugeordnet sind.
Es gibt keinen vorgegebenen Zusammenhang zwischen Farbe und Temperatur. Einen solchen müssen Sie, falls gewünscht, selbst mit einer geeigneten Annahme herstellen. Dazu empfiehlt es sich, die Farbwerte jedes Pixels in einen “Hue”-Wert umzuwandeln.
Es gibt nicht für alle Pixel immer Farbwerte. Die Bereiche der Bilder ohne Farbwerte sowie die Meere (wir haben hier Oberflächentemperaturen über Land) sind in Graustufen dargestellt. Die Farbbereiche jedes Bildes sind grundätzlich unterschiedlich.
Für die allfällige Berechnung von Mittelwerten oder irgendwelchen Verteilungen empfiehlt es sich daher, nur die färbigen Bereiche zu verwenden. Sie können zu diesem Zweck eine Pixel-Maske in NumPy erstellen lassen, die an jedes Bild angepasst wird. Auch hier kann Ihnen der Hue-Wert über eine Grau-Schwelle helfen.

Mit so einer oder einer ähnlichen Herangehensweise sind Ihrer Fantasie keine Grenzen gesetzt. Beispiele für diese Hilfsfunktionen finden sie hier, aber Sie können und sollten das natürlich eventuell direkt mit Ihrem LLMs auf konsistente Weise erarbeiten.

In [19]:

import numpy as np
import os
import matplotlib.pyplot as plt
from PIL import Image
import cv2
from scipy import ndimage
import seaborn as sns

# Definieren verschiedener Hilfs-Funktionen
def rgb_to_hsv(rgb_img):
    """Konvertiert ein RGB-Bild in den HSV-Farbraum"""
    # Konvertieren Sie das Bild von 0-255 zu 0-1 Bereich für OpenCV
    rgb_normalized = rgb_img.astype(np.float32) / 255
    hsv_img = cv2.cvtColor(rgb_normalized, cv2.COLOR_RGB2HSV)
    return hsv_img

def extract_hue(hsv_img):
    """Extrahiert den Farbton-Kanal als relativen Temperaturindikator"""
    return hsv_img[:,:,0]  # H-Kanal (Farbton) aus HSV

def create_temperature_mask(hsv_img, saturation_threshold=0.15):
    """
    Erstellt eine binäre Maske, die Bereiche mit tatsächlichen Temperaturdaten (farbig) 
    von Bereichen ohne Daten (grau) unterscheidet.
    """
    # Extrahiere den Sättigungskanal (S)
    saturation = hsv_img[:,:,1]
    
    # Erstelle eine binäre Maske basierend auf dem Schwellenwert
    mask = saturation > saturation_threshold
    
    # Optional: Anwenden von morphologischen Operationen, um die Maske zu verbessern
    # (entfernt kleine isolierte Pixel und füllt kleine Löcher)
    mask = ndimage.binary_opening(mask, structure=np.ones((3,3)))
    
    return mask

3.6 Zusammenfassung der wichtigsten Punkte dieser Einheit¶

In dieser Einheit haben wir die Grundlagen der linearen Algebra in Python mit NumPy kennengelernt und gesehen, wie diese in verschiedenen durchaus bunten Anwendungen eingesetzt werden können.

Die wichtigsten Konzepte, die wir behandelt haben:¶

Grundlagen der linearen Algebra mit NumPy
- Vektoren und Matrizen als NumPy-Arrays
- Grundlegende Operationen wie Addition, Multiplikation und Transposition
- Fortgeschrittene Operationen wie Matrixinversion, Determinanten und Eigenwertberechnung
Vektorisierung in Python
- Das Konzept der Vektorisierung als Alternative zu Schleifen
- Signifikante Leistungsverbesserungen durch vektorisierte Operationen
- Anwendungsfälle und Grenzen der Vektorisierung
Anwendungen in der linearen Algebra
- Lösen linearer Gleichungssysteme
- Berechnung und Anwendung von Eigenwerten und Eigenvektoren
Praktische Anwendungen von NumPy-Arrays
- Bildverarbeitung
- Farbkanäle und Graustufen
- Transformationen, Filter und Kompression

FMCA-25 02: Algorithmenanalyse und Komplexitätstheorie

Inhalt des Skriptums seit dem Sommersemester 2025

Hier finden Sie die Kapitel aus den Vergangenen Jahren (legacy):

Die Jupyter-Notebooks zur Legacy-Variante der Lehrveranstaltung finden Sie im zugehörigen GitHub-Repository.

02 Algorithmenanalyse und Komplexitätstheorie¶

Willkommen zur zweiten Einheit unseres Kurses “Fortgeschrittene Mathematik und Computergestützte Algorithmen”. Nachdem wir uns in der letzten Einheit mit den Grundlagen des algorithmischen Denkens beschäftigt haben, werden wir uns heute einem zentralen Konzept im Umgang mit Algorithmen widmen: Der Analyse von Algorithmen und ihrer Komplexität. Für uns bedeutet das konkret, die Effizienz verschiedener Algorithmen und Lösungsstrategien besser bewerten und vergleichen zu können.

Nach dem Studium dieser Einheit sollten Sie zumindest folgende drei der wichtigsten Punkte hier verstehen:

Die Bedeutung der Algorithmenanalyse für praktische Anwendungen
Die asymptotische Notation (was bedeutet Big-O?)
Die Zeit- und Speicherkomplexität verschiedener Algorithmen nachvollziehen und vergleichen können

2.1 Wozu überhaupt Algorithmenanalyse betreiben?¶

2.1.1 Die Bedeutung effizienter Algorithmen in realen Anwendungen¶

Stellen Sie sich vor, Sie entwickeln eine Anwendung, die täglich von Millionen von Menschen genutzt wird – vielleicht eine Suchmaschine, eine medizinische App oder eineN persönlicheN KI-BeraterIn. Dafür implementieren Sie die nötigen Algorithmen. Jede Operation, die einer dieser Algorithmen dabei ausführt, wird millionenfach wiederholt – mindestens. In diesem Kontext ist der Unterschied zwischen einem effizienten und einem ineffizienten Algorithmus enorm:

Ressourcenverbrauch: Ein ineffizienter Algorithmus führt zu erhöhten Betriebskosten, da mehr Rechenleistung und Speicher benötigt werden.
Skalierbarkeit: Mit wachsender Datenmenge (z.B. der Anzahl der NutzerInnen und damit der verwendeten Rechnerfarm) kann ein ineffizienter Algorithmus schnell unpraktikabel werden.
Energieverbrauch: Effizientere Algorithmen benötigen durch weniger Rechenleistung auch weniger Energie.
Benutzererfahrung: Langsame Algorithmen führen zu längeren Wartezeiten für die BenutzerInnen, und das schadet dem Nutzen und der Beliebtheit Ihrer Anwendung.

2.1.2 Ressourcenbeschränkungen: Zeit und Speicher¶

Bei der Analyse von Algorithmen betrachten wir hauptsächlich zwei Ressourcen:

Zeit (Zeitkomplexität):

Wie lange dauert es, bis der Algorithmus seine Aufgabe erledigt hat?
Wie verhält sich diese Zeit, wenn die Eingabegröße wächst?

Speicher (Speicherkomplexität):

Wie viel Speicherplatz benötigt der Algorithmus während der Ausführung?
Wie wächst dieser Speicherbedarf mit zunehmender Eingabegröße?

Mit “Eingabegröße” ist hier so etwas gemeint wie die Länge $N$ der Liste, die sortiert werden soll, die Dimensionen $N\times N$ einer Matrix, die invertiert oder diagonalisiert werden soll, die Größe $N$ der Trainings-Datenmenge für ein Machine-Learning-Projekt, oder die Anzahl $N$ der geplanten Durchläufe einer Monte-Carlo-Simulation.

Beide Ressourcen, also sowohl Zeit als auch Speicher, sind in der Praxis begrenzt und meist besteht ein Trade-off zwischen ihnen: Ein schnellerer Algorithmus benötigt häufig mehr Speicher und umgekehrt. Die Kunst des Algorithmendesigns besteht also darin, den optimalen Kompromiss für den jeweiligen Anwendungsfall zu finden.

2.1.3 Warum Skalieren Algorithmen mit wachsender Datenmenge oder Dimension?¶

Ein fundamentales Konzept der Algorithmenanalyse ist das sogenannte Skalierungsverhalten: Wie verändert sich der Ressourcenbedarf eines Algorithmus, wenn die Eingabegröße $N$ wächst?

Betrachten wir dazu ein einfaches Beispiel und betrachten die Zeit, die zwei verschiedene Algorithmen für die Verarbeitung der gleichen Aufgabe brauchen:

Ein Algorithmus A benötigt 100 mal $N$ Millisekunden für die Verarbeitung.
Ein Algorithmus B benötigt 2 mal $N^2$ Millisekunden für die Verarbeitung.

Bei kleinen Werten von n mag Algorithmus B schneller erscheinen:

Für $N$ = 5: Algorithmus A benötigt 500 ms, Algorithmus B benötigt 50 ms.
Für $N$ = 10: Algorithmus A benötigt 1000 ms, Algorithmus B benötigt 200 ms.

Aber bei größeren Werten von $N$ wird der Unterschied dramatisch:

Für $N$ = 1000: Algorithmus A benötigt 100 000 ms (100 Sekunden), während Algorithmus B 2 000 000 ms (über 30 Minuten) benötigt.
Für $N$ = 100 000: Algorithmus A benötigt 10 000 000 ms (ca. 116 Tage), während Algorithmus B 20 000 000 000 ms (ca. 634 Jahre) benötigt.

Dieses Beispiel verdeutlicht, warum wir uns in der Algorithmenanalyse vor allem für das asymptotische Verhalten interessieren – also wie sich die Laufzeit oder der Speicherbedarf für sehr große Eingabemengen verhält. Ein Algorithmus, der für kleine Datenmengen optimal erscheint, kann für größere Datenmengen völlig unpraktikabel werden.

Im nächsten Abschnitt werden wir sehen, wie wir dieses Skalierungsverhalten mit Hilfe der asymptotischen Notation formal beschreiben können.

2.2 Grundlagen der asymptotischen Notation¶

2.2.1 Die Idee hinter der Analyse von Skalierung und Asymptotik¶

Um zu verstehen, warum wir so etwas wie eine asymptotische Notation überhaupt verwenden, müssen wir zunächst das Konzept der Skalierung betrachten. In der Praxis interessiert uns eigentlich meistens nicht, wie ein Algorithmus für eine spezifische Eingabegröße abschneidet, sondern wie sich seine Leistung verändert, wenn die Eingabegröße wächst.

Wenn man z.B. aus $N$ Datenpunkten $2 N$ Datenpunkte macht, was passiert dann? Und was passiert bei $1000 N$ Datenpunkten? Darum geht es hier. Wenn man so etwas weiß, kann man abgesehen von der Asymptotik auch ganz schnell einfache Laufzeit- und Speicherbedarf-Abschätzungen für den verwendeten Code machen.

Die asymptotische Analyse konzentriert sich zunächst auf das Verhalten von Funktionen, wenn die Eingabe unbegrenzt wächst. Mit anderen Worten: Wir betrachten das Verhalten, wenn $N\rightarrow\infty$. Dabei ignorieren wir konstante Faktoren und niedrigere Terme, da diese für sehr große Eingaben vernachlässigbar werden.

Warum ignorieren wir Konstanten?

Stellen Sie sich vor, wir haben zwei Algorithmen:

Algorithmus A mit Laufzeit 5$N$
Algorithmus B mit Laufzeit 2$N$ + 3000

Für kleine Werte von $N$ ($N$ < 1000) ist Algorithmus A schneller. Aber sobald $N$ viel größer wird, wird der konstante Term 3000 im Vergleich zum Term 2$N$ immer unbedeutender. Für sehr große $N$ ist Algorithmus B im Prinzip effizienter, da 2$N$ langsamer wächst als 5$N$.

In der asymptotischen Analyse würden wir aber beide als $O(N)$ betrachten, also linear wachsend, und der eigentliche Unterschied liegt im jeweiligen Faktor (5 vs. 2), der für theoretische Überlegungen allerdings oft weniger relevant ist als das grundlegende Wachstumsverhalten. Das ist wieder unmittelbar bei einem Vergleich von z.B. $N$ und 10 $N$ einsichtig: Beide Varianten brauchen im Vergleich 10-mal so viel Ressourcen, unabhängig vom Faktor.

Lassen Sie uns das kurz illustrieren:

In [5]:

# Created with Claude 3.7 Sonnet
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.style as style
import locale

# Locale auf Deutsch setzen für Dezimaltrennzeichen
locale.setlocale(locale.LC_NUMERIC, 'de_DE.UTF-8')

# Stil für schönere Visualisierung
style.use('seaborn-v0_8-pastel')
plt.rcParams['figure.figsize'] = (12, 7)
plt.rcParams['font.size'] = 12

# Definiere die Größen für n
n_values = np.linspace(0, 2000, 1000)

# Berechne die Laufzeiten für beide Algorithmen
runtime_a = 5 * n_values  # Algorithmus A: 5
runtime_b = 2 * n_values + 3000  # Algorithmus B: 2n + 3000

# Erstelle das Diagramm
fig, ax = plt.subplots()

# Zeichne die Laufzeitkurven
ax.plot(n_values, runtime_a, linewidth=3, color='#ff7f0e', label='Algorithmus A: 5N')
ax.plot(n_values, runtime_b, linewidth=3, color='#1f77b4', label='Algorithmus B: 2N + 3000')

# Finde den Schnittpunkt der beiden Kurven
intersection_x = 3000 / 3  # Löse 5n = 2n + 3000 nach n auf
intersection_y = 5 * intersection_x

# Markiere den Schnittpunkt
ax.scatter([intersection_x], [intersection_y], color='red', s=100, zorder=5)
ax.annotate(f'Schnittpunkt: N = {int(intersection_x)}',
            xy=(intersection_x, intersection_y),
            xytext=(intersection_x + 100, intersection_y - 500),
            arrowprops=dict(arrowstyle='->',
                          connectionstyle='arc3',
                          color='red',
                          lw=1.5))

# Fülle die Bereiche, in denen die Algorithmen jeweils besser sind
ax.fill_between(n_values[n_values < intersection_x], 0, runtime_a[n_values < intersection_x], 
                alpha=0.2, color='#ff7f0e')
ax.fill_between(n_values[n_values < intersection_x], 0, runtime_b[n_values < intersection_x], 
                alpha=0.2, color='#1f77b4')
ax.fill_between(n_values[n_values >= intersection_x], 0, runtime_a[n_values >= intersection_x], 
                alpha=0.2, color='#ff7f0e')
ax.fill_between(n_values[n_values >= intersection_x], 0, runtime_b[n_values >= intersection_x], 
                alpha=0.2, color='#1f77b4')

# Füge Anmerkungen hinzu
ax.text(250, 4000, "Algorithmus B ist\nhier effizienter", fontsize=12, 
        bbox=dict(boxstyle="round,pad=0.5", facecolor='white', alpha=0.8))
ax.text(1500, 8000, "Algorithmus A ist\nhier effizienter", fontsize=12, 
        bbox=dict(boxstyle="round,pad=0.5", facecolor='white', alpha=0.8))

# Achsenbeschriftungen und Titel
ax.set_xlabel('Eingabegröße (N)', fontsize=14)
ax.set_ylabel('Laufzeit (Operationen)', fontsize=14)
ax.set_title('Vergleich der Laufzeiten von zwei Algorithmen', fontsize=16, pad=20)

# Füge Raster und Legende hinzu
ax.grid(True, linestyle='--', alpha=0.7)
ax.legend(fontsize=12, frameon=True, loc='upper left')

# Füge eine Infobox hinzu
textstr = '\n'.join([
    r'$\mathbf{Algorithmus\ A:\ 5N}$',
    r'- Steigung: 5',
    r'- y-Achsenabschnitt: 0',
    r'',
    r'$\mathbf{Algorithmus\ B:\ 2N + 3000}$',
    r'- Steigung: 2',
    r'- y-Achsenabschnitt: 3000',
])
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
ax.text(1.02, 0.5, textstr, transform=ax.transAxes, fontsize=12,
        verticalalignment='center', bbox=props)

plt.tight_layout()
plt.show()

2.2.2 Die Big-O-Notation für die Asymptotik einer Funktion¶

Die Big-O-Notation ist die gebräuchlichste Methode, um die obere Schranke der Laufzeit oder des Speicherbedarfs eines Algorithmus auf einfache Weise zu beschreiben. Dabei schreibt man z.B. $O(N)$ um auszudrücken, dass die Funktion für $N\rightarrow\infty$ wie $N$ ansteigt. Die Bedeutung dieser Schreibweise ist vor allem, dass – in diesem konkreten Beispiel – im Limes gegen unendlich der am stärksten ansteigende Term linear ($N$) ist. Man schreibt in die Klammer also immer den dominanten Term im jeweiligen Grenzfall auf.

Beispiel: Die Funktion $f(N) = 3N^2 + 2N + 1$ ist $O(N^2)$, denn der quadratische Term dominiert für große $N$. Die folgende Grafik veranschaulicht dieses Konzept. Dabei wird eine zweite Funktion $g(N)$ angenommen, die im asymptotischen Fall die Funktion von oben begrenzt. Die Achsen sind in diesem Fall logarithmisch, damit man besser sieht, wie beide Funktionen asymptotisch parallel laufen.

In [8]:

# Created with Claude 3.7 Sonnet
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.style as style
import locale

# Locale auf Deutsch setzen für Dezimaltrennzeichen
locale.setlocale(locale.LC_NUMERIC, 'de_DE.UTF-8')

# Stil für schönere Visualisierung
style.use('seaborn-v0_8-pastel')
plt.rcParams['figure.figsize'] = (12, 8)
plt.rcParams['font.size'] = 12

# Definiere den Bereich für N
n_values = np.logspace(-1, 3, 1000)  # Logarithmische Skala von 10^0 bis 10^3

# Berechne die Funktionswerte
f_n = 3 * n_values**2 + 2 * n_values + 1  # f(N) = 3N² + 2N + 1

# Berechne die asymptotische Begrenzungsfunktion g(N) = 4N²
g_n = 4 * n_values**2

# Erstelle die Figur und das Diagramm
fig, ax = plt.subplots()

# Zeichne die Funktionen
ax.loglog(n_values, f_n, linewidth=3, color='#ff7f0e', label='f(N) = 3N² + 2N + 1')
ax.loglog(n_values, g_n, linewidth=3, color='#1f77b4', linestyle='--', label='g(N) = 4N² (asymptotische Obergrenze)')

# Markiere einige wichtige Punkte
highlighted_points = [10, 100, 1000]
for point in highlighted_points:
    idx = np.abs(n_values - point).argmin()
    f_val = f_n[idx]
    g_val = g_n[idx]
    ax.scatter([point], [f_val], color='#ff7f0e', s=100, zorder=5, edgecolor='black')
    ax.scatter([point], [g_val], color='#1f77b4', s=100, zorder=5, edgecolor='black')
    
    # Verbinde die Punkte mit einer gestrichelten Linie
    ax.plot([point, point], [f_val, g_val], 'k--', alpha=0.5)
    
    # Füge Texte hinzu
    ax.text(point*1.1, f_val*0.9, f'f({point}) = {int(f_val)}', fontsize=10, 
            bbox=dict(boxstyle="round,pad=0.3", facecolor='white', alpha=0.8))
    ax.text(point*1.1, g_val*1.1, f'g({point}) = {int(g_val)}', fontsize=10, 
            bbox=dict(boxstyle="round,pad=0.3", facecolor='white', alpha=0.8))

# Berechne das Verhältnis f(N)/g(N) für große N
ratio_large_n = f_n[-1] / g_n[-1]

# Achsenbeschriftungen und Titel
ax.set_xlabel('Eingabegröße (N) - logarithmische Skala', fontsize=14)
ax.set_ylabel('Funktionswert - logarithmische Skala', fontsize=14)
ax.set_title('Asymptotische Analyse von f(N) = 3N² + 2N + 1', fontsize=16, pad=20)

# Füge Raster und Legende hinzu
ax.grid(True, linestyle='--', alpha=0.7, which='both')  # both major and minor grid lines
ax.legend(fontsize=12, frameon=True, loc='lower right')

# Füge eine Infobox für die asymptotische Analyse hinzu
textstr = '\n'.join([
    r'$\mathbf{Asymptotische\ Analyse:}$',
    r'$f(N) = 3N^2 + 2N + 1$',
    r'$g(N) = 4N^2$',
    r'',
    r'$\lim_{N \to \infty} \frac{f(N)}{g(N)} = \frac{3}{4}$',
    r'',
    r'Daher ist $f(N) \in O(N^2)$',
])
props = dict(boxstyle='round', facecolor='wheat', alpha=0.5)
ax.text(0.02, 0.98, textstr, transform=ax.transAxes, fontsize=12,
        verticalalignment='top', bbox=props)

# Füge eine zweite Infobox für die Terme-Analyse hinzu
textstr2 = '\n'.join([
    r'$\mathbf{Dominanter\ Term:}$',
    r'Für große $N$ wird $3N^2$',
    r'zum dominanten Term:',
    r'',
    r'$\lim_{N \to \infty} \frac{2N}{3N^2} = 0$',
    r'$\lim_{N \to \infty} \frac{1}{3N^2} = 0$',
])
props2 = dict(boxstyle='round', facecolor='lightgreen', alpha=0.5)
ax.text(0.02, 0.65, textstr2, transform=ax.transAxes, fontsize=12,
        verticalalignment='top', bbox=props2)

# Hervorhebe den Bereich für große N
large_n_start = 500
ax.axvspan(large_n_start, n_values[-1], alpha=0.2, color='green')
ax.text(large_n_start*1.1, f_n[np.abs(n_values - large_n_start).argmin()]*0.5, 
        "Für große N nähert sich\nf(N)/g(N) dem Wert 3/4", 
        fontsize=10, bbox=dict(boxstyle="round,pad=0.3", facecolor='white', alpha=0.8))

# Füge X- und Y-Achsenbeschriftungen für spezifische Werte hinzu
ax.set_xticks([0.1, 1, 10, 100, 1000])
ax.set_xticklabels(['0.1', '1', '10', '100', '1000'])

plt.tight_layout()
plt.show()

Damit haben wir nun das grundlegende Verständnis für die Notation verschiedener Arten der Zeitkomplexität:

Einige Arten von Zeitkomplexität in dieser Notation (von effizient zu ineffizient):

$O(1)$: Konstante Zeit als Funktion von $N$ (z.B. Berechnung von $(-1)^N$)
$O(log N)$: Logarithmische Zeit (z.B. Binäre Suche – finden der Position eines bestimmten Werts in einem sortierten Array der Länge $N$)
$O(N)$: Lineare Zeit (z.B. finden des Maximums eines unsortierten Arrays der Länge $N$)
$O(N \log^k N)$: Quasilineare Zeit, $k$ ist eine positive Konstante (z.B. verschiedene Sortierungsalgorithmen von Arrays der Länge $N$)
$O(N^2)$: Quadratische Zeit (z.B. weitere Sortierungsalgorithmen)
$O(N^3)$: Kubische Zeit (z.B. normale Multiplikation von zwei $N\times N$-Matrizen)
$O(poly(N))$: Polynomiale Zeit (z.B. lineare Optimierung)
$2^{O(poly(N))}$: Exponentielle Zeit, der allgemeine Exponent ist im Prinzip auch hier ein Polynom in $N$ (z.B. brute-force Analyse der Matrix-Ketten-Multiplikation für $N$ Matrizen)
$2^{O(N \log N)}$: Faktorielle Zeit, das entspricht der Asymptotik von $N!$ (z.B. brute-force Lösung des Traveling-Salesman-Problems für $N$ Orte)

Sie müssen sich hier nicht unbedingt die einzelnen Beispiele merken, aber Sie sollten diese Arten von Zeitkomplexität kennen und ein paar davon im Gedächtnis behalten.

2.2.3 Best-Case, Average-Case und Worst-Case-Analyse¶

Grundsätzlich unterscheidet man bei der Analyse von Algorithmen verschiedene Szenarien, die ich hier nur kurz und der Vollständigkeit halber erwähne:

Best-Case:

Das günstigste Szenario für den Algorithmus.
Beispiel: Bei der linearen Suche ist der Best-Case, wenn das gesuchte Element an erster Stelle steht ($O(1)$).
In der Praxis ist das aber selten relevant, da man nicht davon ausgehen kann, dass das gesuchte Element tatsächlich immer an der ersten Stelle steht.

Average-Case:

Die durchschnittliche Leistung über alle möglichen Eingaben.
Da hier ein echtes Durchprobieren auch schon einer brute-force-Lösung gleichkommt, basieren diese Einschätzungen oft auf probabilistischen Annahmen.
Beispiel: Bei der linearen Suche ist der Average-Case, dass man im Durchschnitt die Hälfte der Elemente durchsuchen muss ($O(N/2) = O(N)$).

Worst-Case:

Das ungünstigste Szenario für den Algorithmus, und für uns das interessanteste.
Beispiel: Bei der linearen Suche ist der Worst-Case, wenn das gesuchte Element an der letzter Stelle steht, an der man sucht, oder nicht vorhanden ist ($O(N)$).
In der Praxis ist das vor allem deshalb am relevantesten, da dieser Fall eine Art Garantie für eine gute Abschätzung der maximalen Ressourcennutzung gibt.

In den meisten Fällen konzentrieren wir uns also auf die Worst-Case-Analyse, da sie eine obere Schranke für die Leistung des Algorithmus garantiert. Die Average-Case-Analysen kann in einigen speziellen Fällen, insbesondere bei randomisierten Algorithmen, ebenfalls interessant sein.

2.3 Kurze Einführung in die Zeitkomplexität¶

2.3.1 Bestimmung der dominanten Terme für den Zeitbedarf eines Algorithmus¶

Um die Zeitkomplexität eines Algorithmus zu bestimmen, muss man also die dominanten Terme identifizieren, die das Wachstumsverhalten bestimmen. Im Allgemeinen gehen Sie dabei wie folgt vor:

Identifizieren Sie die grundlegenden Operationen im Algorithmus (z.B. Vergleiche, arithmetische Operationen).
Zählen Sie, wie oft diese Operationen ausgeführt werden, abhängig von der Eingabegröße $N$.
Drücken Sie die Gesamtanzahl der Operationen als Funktion von $N$ aus.
Behalten Sie nur den Term mit dem höchsten Wachstum (also den dominanten Term) und ignorieren Sie Konstanten.

Ein Beispiel dafür, den dominanten Term in einem Polynom zu finden, haben wir bereits weiter oben gesehen. Im Folgenden betrachten wir nun ein paar typische Algorithmen-Strukturen.

2.3.2 Analyse von Schleifen und verschachtelten Schleifen¶

Schleifen sind oft die Hauptursache für die Zeitkomplexität eines Algorithmus. Zugleich sind sie außerdem recht geradlinig und direkt einzuschätzen. Hier folgen die wichtigsten Beispiele, als Python-Snippets dargestellt von Claude 3.7 Sonnet:

Einfache Schleife:

for i in range(n):
    # Konstante Zeit Operation

Diese Schleife hat eine Zeitkomplexität von $O(N)$, da die innere Operation $N$-mal ausgeführt wird.

Verschachtelte Schleifen:

for i in range(n):
    for j in range(n):
        # Konstante Zeit Operation

Diese verschachtelten Schleifen haben eine Zeitkomplexität von $O(N^2)$, da die innere Operation $N \times N = N^2$ mal ausgeführt wird.

Verschachtelte Schleifen mit unterschiedlichen Grenzen:

for i in range(n):
    for j in range(i):
        # Konstante Zeit Operation

In diesem Fall wird die innere Schleife 0 + 1 + 2 + … + $(N-1) = N(N-1)/2$ mal durchlaufen, was ebenfalls zu einer Zeitkomplexität von $O(N^2)$ führt.

Logarithmische Schleifen:

i = 1
while i < n:
    # Konstante Zeit Operation
    i = i * 2

Hier verdoppelt sich $i$ in jedem Schritt, sodass die Schleife $\log_2(N)$ mal durchlaufen wird, was zu einer Zeitkomplexität von $O(\log N)$ führt.

2.3.3 Visualisierung verschiedener Zeitkomplexitäten¶

In [16]:

# Created with Claude 3.7 Sonnet
import numpy as np
import matplotlib.pyplot as plt
import math
import locale

# Locale auf Deutsch setzen für Dezimaltrennzeichen
locale.setlocale(locale.LC_NUMERIC, 'de_DE.UTF-8')

# Definiere Bereich für n
n = np.linspace(1, 100, 1000)

# Definiere verschiedene Komplexitätsfunktionen
constant = np.ones_like(n)  # O(1)
logarithmic = np.log2(n)  # O(log n)
linear = n  # O(n)
linearithmic = n * np.log2(n)  # O(n log n)
quadratic = n**2  # O(n²)
cubic = n**3  # O(n³)

# Für exponentielle und faktorielle Funktionen verwenden wir einen kleineren Bereich
n_small = np.linspace(1, 10, 100)
exponential = 2**n_small  # O(2^n)

# Erstelle eine Figure mit zwei Subplots
fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(18, 8))

# Erste Grafik: Übliche Komplexitätsklassen
ax1.plot(n, constant, label='O(1) - Konstant', linewidth=2)
ax1.plot(n, logarithmic, label='O(log N) - Logarithmisch', linewidth=2)
ax1.plot(n, linear, label='O(N) - Linear', linewidth=2)
ax1.plot(n, linearithmic, label='O(N log N) - Linearithmisch', linewidth=2)
ax1.plot(n, quadratic, label='O(N²) - Quadratisch', linewidth=2, c='k')

# Achsenbeschriftungen und Titel
ax1.set_xlabel('Eingabegröße (N)')
ax1.set_ylabel('Anzahl der Operationen')
ax1.set_title('Vergleich der gängigen Arten der Zeitkomplexität')
ax1.legend()
ax1.grid(True)
ax1.set_xscale('log')  # Logarithmische x-Achse für bessere Sichtbarkeit
ax1.set_yscale('log')  # Logarithmische y-Achse für bessere Sichtbarkeit

# Zweite Grafik: Höhere Komplexitätsklassen
ax2.plot(n_small, n_small, label='O(N) - Linear', linewidth=2)
ax2.plot(n_small, n_small**2, label='O(N²) - Quadratisch', linewidth=2)
ax2.plot(n_small, n_small**3, label='O(N³) - Kubisch', linewidth=2)
ax2.plot(n_small, exponential, label='O(2ⁿ) - Exponentiell', linewidth=2, c='k')

# Für O(n!) ist eine spezielle Handhabung erforderlich, da es sehr schnell wächst
factorial_vals = []
for i in n_small:
    if i <= 10:  # Begrenze auf n <= 10, da n! sehr schnell wächst
        factorial_vals.append(math.factorial(int(i)))
    else:
        factorial_vals.append(math.factorial(10))  # Begrenze auf 10! für höhere Werte

ax2.plot(n_small[:len(factorial_vals)], factorial_vals, label='O(N!) - Faktoriell', linewidth=2)

# Achsenbeschriftungen und Titel
ax2.set_xlabel('Eingabegröße (N)')
ax2.set_ylabel('Anzahl der Operationen (logarithmische Skala)')
ax2.set_title('Vergleich höherer Zeitkomplexität')
ax2.legend()
ax2.grid(True)
ax2.set_yscale('log')  # Logarithmische y-Achse für bessere Sichtbarkeit

plt.tight_layout()
plt.show()

Die obige Visualisierung zeigt deutlich, wie unterschiedlich diese Arten der Zeitkomplexität skalieren. Während Algorithmen mit konstanter, logarithmischer oder linearer Laufzeit auch für große Eingaben praktikabel bleiben, werden Algorithmen mit quadratischer, kubischer oder gar exponentieller Laufzeit schnell unpraktikabel.

2.3.5 Einfache Beispiele für solche Arten von Zeitkomplexität¶

Lassen Sie uns für jede Zeitkomplexität ein konkretes Beispiel betrachten. Sie finden hier jeweils kurze Programm-Vorschläge von Claude 3.7 Sonnet:

$O(1)$ – Konstante Zeit:

def get_first_element(array):
    """Gibt das erste Element eines Arrays zurück."""
    if len(array) > 0:
        return array[0]
    else:
        return None

Die Laufzeit ist unabhängig von der Größe des Arrays, da wir immer nur auf das erste Element zugreifen.

$O(\log N)$ – Logarithmische Zeit:

def binary_search(sorted_array, target):
    """Binäre Suche nach einem Element in einem sortierten Array."""
    left, right = 0, len(sorted_array) - 1
    
    while left <= right:
        mid = (left + right) // 2
        if sorted_array[mid] == target:
            return mid
        elif sorted_array[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
            
    return -1  # Element nicht gefunden

Bei jedem Schritt halbieren wir den Suchbereich, was zu einer logarithmischen Laufzeit führt.

$O(N)$ – Lineare Zeit:

def linear_search(array, target):
    """Lineare Suche nach einem Element in einem Array."""
    for i, element in enumerate(array):
        if element == target:
            return i
    return -1  # Element nicht gefunden

Im schlimmsten Fall müssen wir das gesamte Array durchlaufen, was zu einer linearen Laufzeit führt.

$O(N \log N)$ – Quasilineare Zeit:

def merge_sort(array):
    """Sortiert ein Array mit dem Mergesort-Algorithmus."""
    if len(array) <= 1:
        return array
        
    # Teilen
    mid = len(array) // 2
    left_half = merge_sort(array[:mid])
    right_half = merge_sort(array[mid:])
    
    # Zusammenführen
    return merge(left_half, right_half)

def merge(left, right):
    """Führt zwei sortierte Arrays zusammen."""
    result = []
    i = j = 0
    
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    
    result.extend(left[i:])
    result.extend(right[j:])
    return result

Mergesort teilt das Array rekursiv in Hälften ($O(\log N)$ Ebenen) und führt auf jeder Ebene $O(N)$ Arbeit durch, was zu einer Gesamtkomplexität von $O(N \log N)$ führt.

$O(N^2)$ – Quadratische Zeit:

def bubble_sort(array):
    """Sortiert ein Array mit dem Bubblesort-Algorithmus."""
    n = len(array)
    for i in range(n):
        for j in range(0, n - i - 1):
            if array[j] > array[j + 1]:
                array[j], array[j + 1] = array[j + 1], array[j]
    return array

Bubblesort verwendet zwei verschachtelte Schleifen, was zu einer quadratischen Laufzeit führt.

$O(N^3)$ – Kubische Zeit:

def naive_matrix_multiply(A, B):
    """Multipliziert zwei n×n-Matrizen A und B mit dem naiven Algorithmus."""
    n = len(A)
    C = [[0 for _ in range(n)] for _ in range(n)]
    
    for i in range(n):
        for j in range(n):
            for k in range(n):
                C[i][j] += A[i][k] * B[k][j]
                
    return C

Die naive Matrixmultiplikation verwendet drei verschachtelte Schleifen, was zu einer kubischen Laufzeit führt.

$O(2^N)$ – Exponentielle Zeit:

def fibonacci_recursive(n):
    """Berechnet die n-te Fibonacci-Zahl rekursiv."""
    if n <= 1:
        return n
    return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)

Diese naive rekursive Implementation der Fibonacci-Folge hat eine exponentielle Laufzeit, da jeder Aufruf zu zwei weiteren Aufrufen führt (ohne Memoization).

$O(N!)$ – Faktorielle Zeit:

def generate_all_permutations(elements):
    """Generiert alle Permutationen einer Liste von Elementen."""
    if len(elements) <= 1:
        return [elements]
    
    all_permutations = []
    for i in range(len(elements)):
        # Wähle ein Element als erstes Element
        current = elements[i]
        # Erstelle Liste der verbleibenden Elemente
        remaining = elements[:i] + elements[i+1:]
        
        # Generiere alle Permutationen der verbleibenden Elemente
        for p in generate_all_permutations(remaining):
            # Füge das aktuelle Element am Anfang hinzu
            all_permutations.append([current] + p)
            
    return all_permutations

Für jedes der n Elemente generieren wir alle Permutationen der verbleibenden n-1 Elemente, was zu einer faktoriellen Laufzeit führt.

2.4 Kurze Einführung in die Speicherkomplexität¶

Während die Zeitkomplexität angibt, wie lange ein Algorithmus benötigt, beschreibt die Speicherkomplexität, wie viel Speicherplatz er während der Ausführung in Anspruch nimmt. Dein Einfluss von oder Probleme mit der Speicherkomplexität merkt man beim Behandeln von einfachen Beispielen oder Aufgaben meist überhaupt nicht. Das liegt daran, dass moderne Computer für egal welche Implementierung einfacher Problemstellungen jedenfalls genügend Arbeitsspeicher haben, um mit der Ausführung des Programms ohne weiteres klarzukommen.

Während man zunächst also nicht über Speicher nachdenkt, geht einem eine längere Laufzeit viel eher auf die Nerven, und man beginnt, über Laufzeitoptimierung nachzudenken. Dabei kommt es dann allerdings recht schnell zu einer Verlagerung von wiederholten Ausführungen bestimmter Operationen zum Speichern und wieder-Abrufen bereits berechneter Resultate, was den Speicherbedarf erhöht. Ein anderer Grund für Speicherbedarf ist die Verwendung optimierter Programmbibliotheken wie z.B. Numpy, die bereits auf Laufzeit optimierte Funktionen und Klassen zur Verfügung stellen, die dann aber auch erhöhten Speicherbedarf haben.

Sehen wir uns nun also auch den benötigten Speicher genauer an. Wir verwenden wieder die Big-O-Notation zur Beschreibung.

2.4.1 Analyse des Speicherbedarfs eines Algorithmus¶

Bei der Analyse des Speicherbedarfs berücksichtigen wir:

Eingabegröße: Wie viel Speicher wird für die Eingabedaten benötigt?
Hilfsvariablen: Welche zusätzlichen Datenstrukturen werden während der Ausführung verwendet?
Rekursionstiefe: Bei rekursiven Algorithmen müssen wir den Stapelspeicher (Stack) berücksichtigen.

Betrachten wir einige Beispiele (nochmals), wieder gecodet von Claude 3.7 Sonnet:

Beispiel 1: In-Place-Sortieralgorithmus (Bubble Sort)

def bubble_sort(array):
    n = len(array)
    for i in range(n):
        for j in range(0, n - i - 1):
            if array[j] > array[j + 1]:
                array[j], array[j + 1] = array[j + 1], array[j]
    return array

Bubble Sort verändert das Array direkt (in-place) und benötigt nur konstanten zusätzlichen Speicher für die Schleifenvariablen und den temporären Austausch. Die Speicherkomplexität ist daher $O(1)$, wenn wir den Speicher für die Eingabe nicht berücksichtigen.

Beispiel 2: Merge Sort

def merge_sort(array):
    if len(array) <= 1:
        return array
        
    mid = len(array) // 2
    left_half = merge_sort(array[:mid])
    right_half = merge_sort(array[mid:])
    
    return merge(left_half, right_half)

Merge Sort erstellt bei jedem rekursiven Aufruf neue Teilarrays und benötigt zusätzlichen Speicher für die Zusammenführung. Die Speicherkomplexität ist $O(N)$, da wir im schlimmsten Fall $O(N)$ zusätzlichen Speicher benötigen. Durch die Rekursion hat Merge Sort auch eine Stapeltiefe von $O(\log N)$.

Beispiel 3: Erstellen einer Adjazenzmatrix für einen Graphen

def create_adjacency_matrix(n, edges):
    """
    Erstellt eine Adjazenzmatrix für einen Graphen mit n Knoten und den gegebenen Kanten.
    
    Args:
        n: Anzahl der Knoten im Graphen
        edges: Liste von Tupeln (u, v), die Kanten zwischen Knoten u und v darstellen
        
    Returns:
        Eine n x n Adjazenzmatrix
    """
    matrix = [[0 for _ in range(n)] for _ in range(n)]
    
    for u, v in edges:
        matrix[u][v] = 1
        matrix[v][u] = 1  # Für einen ungerichteten Graphen
        
    return matrix

Die Adjazenzmatrix benötigt $O(N^2)$ Speicher, da wir eine $N\times N$-Matrix erstellen müssen, unabhängig von der Anzahl der Kanten.

2.4.2 Zusammenhang zwischen Zeit- und Speicherkomplexität¶

Zeit- und Speicherkomplexität sind oft, aber nicht immer, miteinander verbunden. Einige Beobachtungen:

Datenstrukturen beeinflussen beide Komplexitäten:
- Eine geschickte Wahl der Datenstruktur kann sowohl die Zeit- als auch die Speicherkomplexität verbessern.
- Beispiel: Hashtabellen bieten $O(1)$-Zeit Zugriff auf Kosten eines höheren Speicherbedarfs. Die konstante Zeitkomplexität ergibt sich aus der konstanten Zeit, in der die Hash-Funktion aus der Eingabe jenen Index erzeugt, unter dem die gesuchte Information in einer Tabelle gespeichert ist. Auch der Index-gesteuerte Zugriff auf die Tabelle dauert $O(1)$. Der damit verbundene Speicherbedarf ist proportional zur Größe der Tabelle.
Vorberechnung und Zwischenspeicherung:
- Durch das Speichern von Zwischenergebnissen (Memoisation) können wir die Zeitkomplexität auf Kosten der Speicherkomplexität reduzieren.
- Beispiel: Beim nach-und-nach-Berechnen aller Primzahlen kann man als mögliche Faktoren anstatt aller Zahlen, die kleiner als die zu überprüfende Zahl sind, nur bereits gefundene Primzahlen in Betracht ziehen.
Rekursive vs. iterative Implementierungen:
- Rekursive Algorithmen können eleganter sein, benötigen aber mehr Stapelspeicher.
- Iterative Algorithmen haben eine bessere Speicherkomplexität.

2.4.3 Trade-offs zwischen Zeit und Speicher¶

In der Praxis müssen wir oft Kompromisse zwischen Zeit- und Speicherkomplexität eingehen. Hier sind zwei typische Beispiele, gecodet von Claude 3.7 Sonnet:

Beispiel 1: Fibonacci-Zahlen

In der Folge der Fibonacci-Zahlen erhält man die nächste Zahl, indem man die beiden vorangegangenen Zahlen addiert. Die Folge beginnt mit 1, 1, 2, 3, 5, … Hier sehen wir uns drei verschiedene Ansätze an, um diese Zahlen zu berechnen.

Rekursive Implementierung (schlechte Zeit, guter Speicher):

def fibonacci_recursive(n):
    if n <= 1:
        return n
    return fibonacci_recursive(n - 1) + fibonacci_recursive(n - 2)

Zeitkomplexität: $O(2^N)$ (exponentiell):
- Für jede Berechnung von fibonacci_recursive(n) werden zwei weitere rekursive Aufrufe getätigt (n-1 und n-2)
- Dies führt zu einem rekursiven Aufrufbaum mit annähernd $2^N$ Knoten
- Das exponentielle Wachstum wird also durch viele redundante Berechnungen verursacht (z.B. wird fibonacci_recursive(3) mehrfach berechnet)
Speicherkomplexität: $O(N)$ (für den Rekursionsstack):
- Die maximale Tiefe der Rekursion beträgt $N$, da wir immer bis zu fibonacci_recursive(0) heruntersteigen
- Dabei wird der gesamte Baum der nötigen Berechnungen in der Rekursion der Reihe nach abgearbeitet, allerdings immer eine Verzweigung bis ganz zum Ende (fibonacci_recursive(0))
- Daher bleibt die Speicherkomplexität linear mit $O(N)$, weil der längste Verzweigungspfad die Länge $N$ hat.

Dynamische Programmierung mit Memoisation (gute Zeit, mittlerer Speicher):

def fibonacci_memoized(n, memo=None):
    if memo is None:
        memo = {}  # benützt ein Dictionary
    if n in memo:
        return memo[n]
    if n <= 1:
        return n
    memo[n] = fibonacci_memoized(n - 1, memo) + fibonacci_memoized(n - 2, memo)
    return memo[n]

Zeitkomplexität: $O(N)$:
- Jede Fibonacci-Zahl von 0 bis $N$ wird exakt einmal berechnet und im memo-Dictionary gespeichert
- Alle nachfolgenden Anfragen für diesen Wert werden einfach aus dem Dictionary abgerufen (das sind jeweils $O(1)$ Operation)
- Die Berechnung jeder Fibonacci-Zahl erfordert eine konstante Anzahl von Operationen plus zwei Rekursionsaufrufe
- Da jeder rekursive Aufruf für einen bestimmten Wert von $N$ durch die Memoization nur einmal tatsächlich ausgeführt wird, beträgt die Gesamtzahl der Operationen $O(N)$
Speicherkomplexität: $O(N)$:
- Das memo-Dictionary speichert bis zu $N+1$ Schlüssel-Wert-Paare (für alle Fibonacci-Zahlen von 0 bis $N$)
- Durch die Rekursion muss man im schlimmsten Fall immer noch bis zu $N$ Schritte tief gehen
- Daher ist die Gesamtspeicherkomplexität $O(N)$ für die Memoisation plus $O(N)$ für den Rekursionspfad, insgesamt also $O(N)$

Dynamische Programmierung mit Tabulation (gute Zeit, guter Speicher):

def fibonacci_tabulation(n):
    if n <= 1:
        return n
    a, b = 0, 1
    for _ in range(2, n + 1):
        a, b = b, a + b
    return b

Zeitkomplexität: $O(N)$:
- Der Algorithmus verwendet eine einzelne Schleife, die $N-1$ mal durchlaufen wird (von 2 bis $N$)
- Jede Iteration führt eine konstante Anzahl von Operationen durch (Zuweisung und Addition)
- Daher beträgt die Gesamtzeitkomplexität $O(N)$
Speicherkomplexität: $O(1)$:
- Unabhängig von der Größe von $N$ werden nur zwei Variablen (a und b) verwendet, um die letzten beiden Fibonacci-Zahlen zu speichern
- Es gibt keinen Rekursionspfad und keine Datenstruktur, die mit $N$ wächst, obwohl man auch hier alle in der Schleife berechneten Zahlen speichern könnte. Die Tabelle hätte dann die Länge $N$, wobei sie in dieser optimierten Implementierung nur die Länge 2 hat (a und b).
- Daher bleibt der Speicherbedarf konstant bei $O(1)$
- Dies macht diesen Ansatz besonders speichereffizient für große Werte von $N$

Beispiel 2: Suchalgorithmen

Die Suche nach einem bestimmten Element in einer Menge oder in einer ähnlichen Datenstruktur ist eins der zentralen Probleme in der Informatik. Daher tauchen Suchalgorithmen immer wieder als Beispiele auf, nicht zuletzt deshalb, weils sie im Laufe der Zeit sehr gründlich untersucht und optimiert worden sind. Hier noch eine kurze Gegenüberstellung zweier typischer Varianten, gecodet von Claude 3.7 Sonnet.

Lineare Suche (schlechte Zeit, kein zusätzlicher Speicher):

def linear_search(array, target):
    for i, element in enumerate(array):
        if element == target:
            return i
    return -1

Zeitkomplexität: $O(N)$:
- Im schlimmsten Fall müssen wir jeden einzelnen Eintrag im Array überprüfen, bis wir das Zielelement finden oder das Ende des Arrays erreichen
- Die Anzahl der Vergleiche ist direkt proportional zur Größe des Arrays ($N$)
- Durchschnittlich müssen wir $N/2$ Elemente überprüfen, wenn das gesuchte Element zufällig im Array verteilt ist
- Im besten Fall (Element ist am Anfang) benötigen wir nur einen Vergleich: $O(1)$
- Da wir bei der Big-O-Notation den schlimmsten Fall betrachten, ist die Zeitkomplexität $O(N)$
Speicherkomplexität: $O(1)$:
- Wir benötigen nur konstanten zusätzlichen Speicher unabhängig von der Eingabegröße
- Es werden nur die Laufvariablen i und element während der Iteration verwendet
- Keine zusätzlichen Datenstrukturen werden erstellt oder erweitert
- Der Speicherverbrauch – abgesehen vom Array selbst – bleibt konstant, egal wie groß das Array ist

Hashmap-basierte Suche (hervorragende Zeit, zusätzlicher Speicher):

def hashmap_search(array, target):
    # Vorverarbeitung
    hashmap = {element: i for i, element in enumerate(array)}
    
    # Suche
    if target in hashmap:
        return hashmap[target]
    else:
        return -1

Zeitkomplexität: $O(1)$ für die Suche (nach $O(N)$ Vorverarbeitung):
- Die Vorverarbeitung erfordert $O(N)$ Zeit, da wir jedes Element im Array durchlaufen müssen, um die Hashmap zu erstellen
- Die Dictionary-Comprehension {element: i for i, element in enumerate(array)} benötigt $N$ Operationen
- Das Einfügen in die Hashmap hat eine durchschnittliche Zeitkomplexität von $O(1)$ pro Element
- Die anschließende Suche nach dem target-Element in der Hashmap ist eine $O(1)$-Operation im Durchschnittsfall
- Der Ausdruck target in hashmap nutzt den Hash-Wert des Zielobjekts, um direkt auf den entsprechenden Index in der Hashmap zuzugreifen
Speicherkomplexität: $O(N)$:
Wir erstellen eine Hashmap, die jeden Wert aus dem ursprünglichen Array als Schlüssel enthält
- Die Hashmap speichert $N$ Schlüssel-Wert-Paare (jedes Element und seinen Index)
- Der Speicherverbrauch wächst linear mit der Größe des Eingabe-Arrays
- In Python-Dictionaries wird etwas zusätzlicher Speicher für die Hash-Tabellen-Infrastruktur benötigt

Diese Beispiele zeigen, dass wir oft zwischen Zeit und Speicher abwägen müssen. Die optimale Wahl hängt von den spezifischen Anforderungen der Anwendung ab:

In speicherbeschränkten Umgebungen (z.B. eingebettete Systeme) können wir Zeit für Speicher opfern.
In Anwendungen, die schnell reagieren müssen (z.B. Echtzeitsysteme), können wir Speicher für Zeit opfern.
In Anwendungen mit sehr großen Datenmengen müssen wir möglicherweise beides optimieren.

2.5 Benchmarking und empirische Analyse¶

Die theoretische Komplexitätsanalyse ist ein mächtiges Werkzeug, um das asymptotische Verhalten von Algorithmen zu verstehen. In der Praxis ist es allerdings wesentlich wichtiger, die tatsächliche Laufzeit und den Speicherbedarf der Algorithmen einfach zu messen. Dafür verwenden wir verschiedene Benchmarking-Techniken.

2.5.1 Laufzeitmessung in Python¶

Python bietet verschiedene Möglichkeiten zur Laufzeitmessung, hier sind Beispiel-Code-Snippets von Claude 3.7 Sonnet:

Das time-Modul für einfache Zeitmessungen:

import time

start_time = time.time()
# Code, dessen Laufzeit gemessen werden soll
result = some_algorithm(data)
end_time = time.time()

print(f"Laufzeit: {end_time - start_time:.6f} Sekunden")

Das timeit-Modul für präzisere Messungen:

import timeit

# Code wird als String vorbereitet
code_to_measure = """
result = some_algorithm(data)
"""

# Setup-Code (wird nachher ausgeführt, aber nicht gemessen), ein extra String
setup_code = """
from my_module import some_algorithm
data = [i for i in range(1000)]
"""

# Führe den Code mehrmals aus und nimm den Durchschnitt
execution_time = timeit.timeit(code_to_measure, setup=setup_code, number=100)
print(f"Durchschnittliche Laufzeit über 100 Durchläufe: {execution_time / 100:.6f} Sekunden")

Das cProfile-Modul für detaillierte Profiling-Informationen:

import cProfile

# Profiling eines Funktionsaufrufs
cProfile.run('some_algorithm(data)')

Zeitdekoratoren für wiederholte Messungen:

In [19]:

# Code von Claude 3.7 Sonnet
import time
import functools

def measure_time(func):
    """
    Ein Dekorator, der die Ausführungszeit einer Funktion misst.

    Args:
        func: Die zu messende Funktion

    Returns:
        Eine dekorierte Funktion, die die Ausführungszeit ausgibt
    """
    @functools.wraps(func)
    def wrapper(*args, **kwargs):
        start_time = time.time()
        result = func(*args, **kwargs)
        end_time = time.time()
        print(f"Funktion {func.__name__} wurde in {end_time - start_time:.6f} Sekunden ausgeführt")
        return result
    return wrapper

# Beispiel für die Verwendung des Dekorators
@measure_time
def bubble_sort(arr):
    n = len(arr)
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr[j] > arr[j + 1]:
                arr[j], arr[j + 1] = arr[j + 1], arr[j]
    return arr

@measure_time
def quick_sort(arr):
    if len(arr) <= 1:
        return arr
    pivot = arr[len(arr) // 2]
    left = [x for x in arr if x < pivot]
    middle = [x for x in arr if x == pivot]
    right = [x for x in arr if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

# Test der dekorierten Funktionen mit verschiedenen Arraygrößen
import random

# Mittlere Arraygröße
medium_array = random.sample(range(10000), 10)
bubble_sort(medium_array.copy())
quick_sort(medium_array.copy())

Funktion bubble_sort wurde in 0.000014 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000002 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000001 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000061 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000000 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000152 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000108 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000001 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000142 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000014 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000192 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000001 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000243 Sekunden ausgeführt
Funktion quick_sort wurde in 0.000454 Sekunden ausgeführt

Out[19]:

[623, 977, 2599, 2886, 3363, 4330, 5032, 6558, 8622, 9802]

Die vorangegangenen Code-Beispiele demonstrieren, wie wir die Laufzeit von Algorithmen in Python messen und können. Diese empirischen Messungen sind ein wichtiger Bestandteil der Algorithmenanalyse, denn sie ermöglichen es uns, die theoretischen Vorhersagen der asymptotischen Analyse zu überprüfen und zu validieren.

2.5.2 Visualisierung empirischer Performancedaten¶

Die Visualisierung von Performancedaten hilft dabei, ganz einfach Trends und Muster in den Laufzeiten zu erkennen. In den Code-Beispielen haben wir verschiedene Sortieralgorithmen theoretisch verglichen; jetzt ist es Zeit, konkrete Laufzeiten in Abhängigkeit von der Eingabegröße zu visualisieren. Dabei achten wir auf folgende Aspekte:

Das tatsächliche Wachstumsverhalten eines Algorithmus
Algorithmen miteinander zu vergleichen
Schwellenwerte zu identifizieren, ab denen ein Algorithmus einem anderen überlegen ist
Unerwartete Effekte und Fluktuationen, die eine genauere Untersuchung nahelegen

Typische Visualisierungen in der Algorithmenanalyse sind z.B.

Liniendiagramme: Sehen wir gleich. Sie zeigen die Laufzeit oder den Speicherbedarf in Abhängigkeit von der Eingabegröße
Log-Log-Plots: Sehen wir auch gleich. Besonders nützlich für die Visualisierung von Potenzgesetzen (z.B. $O(N^2)$ entspricht im Log-Log-Plot einer Geraden mit Steigung 2) und asymptotischem Verhalten
Heatmaps: Eine Art, mehrdimensionale Plots zu erzeugen. Nützlich zum Vergleich mehrerer Algorithmen über verschiedene Eingabegrößen oder Datenverteilungen

In [23]:

# Code von Claude 3.7 Sonnet
import time
import random
import numpy as np
import matplotlib.pyplot as plt
import locale

# Locale auf Deutsch setzen für Dezimaltrennzeichen
locale.setlocale(locale.LC_NUMERIC, 'de_DE.UTF-8')

# Implementierung verschiedener Sortieralgorithmen

def bubble_sort(arr):
    """Bubble Sort mit O(n²) Zeitkomplexität."""
    n = len(arr)
    arr_copy = arr.copy()  # Kopie erstellen, um das Original nicht zu verändern
    for i in range(n):
        for j in range(0, n - i - 1):
            if arr_copy[j] > arr_copy[j + 1]:
                arr_copy[j], arr_copy[j + 1] = arr_copy[j + 1], arr_copy[j]
    return arr_copy

def insertion_sort(arr):
    """Insertion Sort mit O(n²) Zeitkomplexität."""
    arr_copy = arr.copy()
    for i in range(1, len(arr_copy)):
        key = arr_copy[i]
        j = i - 1
        while j >= 0 and arr_copy[j] > key:
            arr_copy[j + 1] = arr_copy[j]
            j -= 1
        arr_copy[j + 1] = key
    return arr_copy

def merge_sort(arr):
    """Merge Sort mit O(n log n) Zeitkomplexität."""
    arr_copy = arr.copy()
    if len(arr_copy) <= 1:
        return arr_copy
        
    mid = len(arr_copy) // 2
    left_half = merge_sort(arr_copy[:mid])
    right_half = merge_sort(arr_copy[mid:])
    
    return merge(left_half, right_half)

def merge(left, right):
    """Hilfsfunktion für Merge Sort."""
    result = []
    i = j = 0
    
    while i < len(left) and j < len(right):
        if left[i] <= right[j]:
            result.append(left[i])
            i += 1
        else:
            result.append(right[j])
            j += 1
    
    result.extend(left[i:])
    result.extend(right[j:])
    return result

def quick_sort(arr):
    """Quick Sort mit O(n log n) durchschnittlicher Zeitkomplexität."""
    arr_copy = arr.copy()
    if len(arr_copy) <= 1:
        return arr_copy
    pivot = arr_copy[len(arr_copy) // 2]
    left = [x for x in arr_copy if x < pivot]
    middle = [x for x in arr_copy if x == pivot]
    right = [x for x in arr_copy if x > pivot]
    return quick_sort(left) + middle + quick_sort(right)

def python_sort(arr):
    """Python's integrierte Sortierung (Timsort) mit O(n log n) Zeitkomplexität."""
    arr_copy = arr.copy()
    arr_copy.sort()
    return arr_copy

# Funktion zum Benchmark der Sortieralgorithmen
def benchmark_sorting_algorithms(sizes, algorithms, num_runs=3):
    """
    Misst die Laufzeit verschiedener Sortieralgorithmen für verschiedene Arraygrößen.
    
    Args:
        sizes: Liste der zu testenden Arraygrößen
        algorithms: Dictionary mit Algorithmusnamen als Schlüssel und Funktionen als Werte
        num_runs: Anzahl der Durchläufe für jede Größe (für stabilere Ergebnisse)
        
    Returns:
        Ein Dictionary mit den durchschnittlichen Laufzeiten für jeden Algorithmus und jede Größe
    """
    results = {name: [] for name in algorithms}
    
    for size in sizes:
        print(f"Benchmarking für Arraygröße {size}...")
        
        # Generiere zufällige Arrays für jeden Durchlauf
        arrays = [random.sample(range(100000), size) for _ in range(num_runs)]
        
        for name, algorithm in algorithms.items():
            total_time = 0
            
            for arr in arrays:
                start_time = time.time()
                algorithm(arr)
                end_time = time.time()
                total_time += (end_time - start_time)
            
            average_time = total_time / num_runs
            results[name].append(average_time)
            print(f"  {name}: {average_time:.6f} Sekunden")
    
    return results

# Hauptfunktion für das Benchmarking und die Visualisierung
def run_benchmark_visualization():
    # Definiere die zu testenden Arraygrößen
    sizes = [100, 500, 1000, 2000, 3000, 4000, 5000]
    
    # Dictionary mit den zu testenden Algorithmen
    algorithms = {
        "Bubble Sort": bubble_sort,
        "Insertion Sort": insertion_sort,
        "Merge Sort": merge_sort,
        "Quick Sort": quick_sort,
        "Python's Timsort": python_sort
    }
    
    # Führe das Benchmarking durch
    results = benchmark_sorting_algorithms(sizes, algorithms)
    
    # Visualisiere die Ergebnisse
    plt.figure(figsize=(12, 8))
    
    for name, times in results.items():
        plt.plot(sizes, times, marker='o', linestyle='-', linewidth=2, label=name)
    
    plt.xlabel('Arraygröße (N) - logarithmische Skala')
    plt.ylabel('Durchschnittliche Laufzeit (Sekunden) - logarithmische Skala')
    plt.title('Laufzeitvergleich verschiedener Sortieralgorithmen (log-log)')
    plt.legend()
    plt.grid(True)
    plt.xscale('log')
    plt.yscale('log')
    plt.tight_layout()
    
    # Erstelle einen zweiten Plot mit logarithmischer y-Achse für bessere Sichtbarkeit
    plt.figure(figsize=(12, 8))
    
    for name, times in results.items():
        plt.plot(sizes, times, marker='o', linestyle='-', linewidth=2, label=name)
    
    plt.xlabel('Arraygröße (N)')
    plt.ylabel('Durchschnittliche Laufzeit (Sekunden) - logarithmische Skala')
    plt.title('Laufzeitvergleich verschiedener Sortieralgorithmen (lin-log)')
    plt.legend()
    plt.grid(True)
    plt.yscale('log')
    plt.tight_layout()
    
    # Zeige die Plots
    plt.show()
    
    # Erstelle eine Tabelle mit den theoretischen vs. gemessenen Komplexitäten
    print("\nVergleich von theoretischer und gemessener Komplexität:")
    print("-" * 80)
    print(f"{'Algorithmus':<20} {'Theoretische Komplexität':<30} {'Gemessenes Verhalten':<30}")
    print("-" * 80)
    
    for name in results:
        theoretical = ""
        if name == "Bubble Sort" or name == "Insertion Sort":
            theoretical = "O(N²)"
        elif name == "Merge Sort" or name == "Quick Sort" or name == "Python's Timsort":
            theoretical = "O(N log N)"
        
        # Einfache lineare Regression für das gemessene Verhalten
        x = np.array(sizes)
        y = np.array(results[name])
        
        # Für O(n²)
        coef_n2 = np.polyfit(x**2, y, 1)[0]
        r2_n2 = np.corrcoef(x**2, y)[0, 1]**2
        
        # Für O(n log n)
        coef_nlogn = np.polyfit(x * np.log(x), y, 1)[0]
        r2_nlogn = np.corrcoef(x * np.log(x), y)[0, 1]**2
        
        # Für O(n)
        coef_n = np.polyfit(x, y, 1)[0]
        r2_n = np.corrcoef(x, y)[0, 1]**2
        
        # Bestimme das am besten passende Modell
        best_fit = ""
        if r2_n2 > max(r2_nlogn, r2_n) and r2_n2 > 0.9:
            best_fit = f"O(N²) (R² = {r2_n2:.4f})"
        elif r2_nlogn > max(r2_n2, r2_n) and r2_nlogn > 0.9:
            best_fit = f"O(N log N) (R² = {r2_nlogn:.4f})"
        elif r2_n > max(r2_n2, r2_nlogn) and r2_n > 0.9:
            best_fit = f"O(N) (R² = {r2_n:.4f})"
        else:
            best_fit = "Unklar"
        
        print(f"{name:<20} {theoretical:<30} {best_fit:<30}")

# Führe das Benchmarking und die Visualisierung aus
# Achtung: Dies kann je nach Rechenleistung einige Zeit dauern!
# Für eine schnellere Ausführung können kleinere Arraygrößen gewählt werden
if __name__ == "__main__":
    run_benchmark_visualization()

Benchmarking für Arraygröße 100...
  Bubble Sort: 0.000488 Sekunden
  Insertion Sort: 0.000232 Sekunden
  Merge Sort: 0.000185 Sekunden
  Quick Sort: 0.000143 Sekunden
  Python's Timsort: 0.000007 Sekunden
Benchmarking für Arraygröße 500...
  Bubble Sort: 0.012702 Sekunden
  Insertion Sort: 0.006452 Sekunden
  Merge Sort: 0.001074 Sekunden
  Quick Sort: 0.000867 Sekunden
  Python's Timsort: 0.000038 Sekunden
Benchmarking für Arraygröße 1000...
  Bubble Sort: 0.058723 Sekunden
  Insertion Sort: 0.027257 Sekunden
  Merge Sort: 0.002170 Sekunden
  Quick Sort: 0.001946 Sekunden
  Python's Timsort: 0.000075 Sekunden
Benchmarking für Arraygröße 2000...
  Bubble Sort: 0.226140 Sekunden
  Insertion Sort: 0.109615 Sekunden
  Merge Sort: 0.005097 Sekunden
  Quick Sort: 0.003666 Sekunden
  Python's Timsort: 0.000167 Sekunden
Benchmarking für Arraygröße 3000...
  Bubble Sort: 0.523304 Sekunden
  Insertion Sort: 0.262960 Sekunden
  Merge Sort: 0.007571 Sekunden
  Quick Sort: 0.005717 Sekunden
  Python's Timsort: 0.000261 Sekunden
Benchmarking für Arraygröße 4000...
  Bubble Sort: 0.908470 Sekunden
  Insertion Sort: 0.423092 Sekunden
  Merge Sort: 0.010068 Sekunden
  Quick Sort: 0.007705 Sekunden
  Python's Timsort: 0.000371 Sekunden
Benchmarking für Arraygröße 5000...
  Bubble Sort: 1.485927 Sekunden
  Insertion Sort: 0.695088 Sekunden
  Merge Sort: 0.013534 Sekunden
  Quick Sort: 0.010774 Sekunden
  Python's Timsort: 0.000468 Sekunden

Vergleich von theoretischer und gemessener Komplexität:
--------------------------------------------------------------------------------
Algorithmus          Theoretische Komplexität       Gemessenes Verhalten          
--------------------------------------------------------------------------------
Bubble Sort          O(N²)                          O(N²) (R² = 0.9993)           
Insertion Sort       O(N²)                          O(N²) (R² = 0.9986)           
Merge Sort           O(N log N)                     O(N log N) (R² = 0.9984)      
Quick Sort           O(N log N)                     O(N log N) (R² = 0.9957)      
Python's Timsort     O(N log N)                     O(N log N) (R² = 0.9997)

2.5.3 Vergleich theoretischer und praktischer Performance¶

Die theoretische Analyse gibt uns Einblick in das asymptotische Verhalten eines Algorithmus, aber in der Praxis können andere Faktoren eine wichtige Rolle spielen. Wie schon angedeutet, kann es sein, dass man z.B. in den Messergebnissen irgendwelche unerwarteten oder seltsamen Dinge sieht. Andererseits gibt es auch vorhersehbare Faktoren, die Unterschiede von erwarteten zu tatsächlichen Werten verursachen. Hier folgt eine Liste der typischen Dinge, die man im Kopf behalten sollte:

Konstante Faktoren: In der Big-O-Notation ignorieren wir konstante Faktoren, aber in der Praxis können sie einen erheblichen Unterschied machen.
- Beispiel: So einen Unterschied haben wir bereits ganz am Anfang gesehen, wo zwei linear skalierende Zeit-Abhängigkeiten sehr verschieden waren.
Overhead: Die theoretische Analyse berücksichtigt oft nicht den Overhead für die Initialisierung von Datenstrukturen oder für Funktionsaufrufe.
- Beispiel: Rekursive Implementierungen haben durch den Funktionsaufruf-Overhead oft eine schlechtere praktische Performance als ihre iterativen Gegenstücke.
Cacheverhalten: Moderne CPUs verwenden Caches, um häufig genutzte Daten schnell verfügbar zu haben. Algorithmen, die eine gute Cache-Nutzung aufweisen, können in der Praxis viel schneller sein.
- Beispiel: Arrays (Stichwort Numpy) bieten bessere Cache-Nutzung als verknüpfte Listen, was zu besserer Performance führen kann, selbst wenn die theoretische Komplexität gleich ist.
Optimierungen durch den Compiler/Interpreter: Moderne Compiler und Interpreter führen viele Optimierungen durch, die das Laufzeitverhalten verbessern können.
- Beispiel: Pythons Timsort-Algorithmus passt sich an Muster in den Daten an und kann in bestimmten Fällen besser abschneiden als seine theoretische $O(N \log N)$ Komplexität vermuten lässt.

2.5.4 Verschiedene Implementierungen desselben Algorithmus¶

Oft gibt es mehrere Möglichkeiten, einen Algorithmus zu implementieren, und diese können sich erheblich in ihrer Performance unterscheiden. In der Praxis geht man oft nach dem Prinzip des “Rapid Prototypings” vor, indem man zunächst einfach irgendeine Implementierung des Algorithmus programmiert – die Hauptsache dabei ist, dass das Programm korrekt läuft und das Problem im Prinzip gelöst wird. Erst danach geht man Schritt für Schritt durch mögliche Optimierungen und verbessert die Performance durch bessere Implementierungen immer weiter.

Hier sind die wichtigsten Aspekte solch verschiedener Implementierungen:

Rekursiv vs. Iterativ: Rekursive Implementierungen sind oft eleganter und leichter zu verstehen, während iterative Implementierungen effizienter sein können.
Verschiedene Datenstrukturen: Die Wahl der Datenstruktur kann einen erheblichen Einfluss auf die Performance haben.
Inplace vs. Out-of-place: Algorithmen, die ihre Eingabe direkt modifizieren (inplace), benötigen oft weniger Speicher, können aber in manchen Situationen auch weniger flexibel sein.
Andere Herangehensweise: Manchmal hat eine neue Implementierung eines Algorithmus eine komplett neue und bessere Herangehensweise an das Problem als Grundlage. Praktisch für jedes Problem kann man sich z.B. eine brute-force Lösungsstrategie ausdenken. In der Praxis ist das aber von vornherein auch die am wenigsten optimierte Variante für einen Lösungsalgorithmus, und eine gute Idee kann eine Lösung (oder zumindest eine Näherungslösung, dazu gleich noch mehr) in greifbare Nähe rücken.

2.5.5 Optimierung von Code mithilfe von Komplexitätsanalyse¶

Die Komplexitätsanalyse kann natürlich auch dabei helfen, Engpässe im verwendeten Code zu identifizieren und zu optimieren, zum Beispiel:

Identifizierung von Bottlenecks: Durch die Analyse der Komplexität verschiedener Teile eines Algorithmus können wir die teuersten Operationen identifizieren. Diese werden “Bottlenecks”, also “Flaschenhals” genannt, weil sie diejenigen Teile des Programms sind, die den Datendurchsatz am stärktsten bremsen.
Algorithmische Verbesserungen: Wenn sich herausstellt, dass Teile des Codes auf ineffiziente Weise umgesetzt sind, dann kann man natürlich solche Blöcke durch effizientere Versionen ersetzen.
Datenstruktur-Optimierungen: Das gleiche gilt für die verwendeten Datenstrukturen. Wenn es auf Optimierung ankommt, dann lohnt es sich, die verwendeten Datenstrukturen der Reihe nach in Frage zu stellen und gegebenenfalls zu ersetzen.
Speicher-Zeit-Tradeoffs: Je nach Situation und verewendeter Hardware sollte man die Möglichkeit im Hinterkopf behalten, die Optimierung von Laufzeit auf Speicher zu verlagern oder umgekehrt.

2.5.6 Approximationsalgorithmen für schwierige Probleme¶

Zum Schluss möchte ich noch auf eine mir sehr wichtige Sache hinweisen: Gerade bei sehr schwierig zu Lösenden Problemen ist es in der Praxis unerlässlich, über seinen theoretischen Schatten zu springen und eine Näherungslösung statt der echten absolut besten Lösung zu suchen. Das Gute dabei ist, dass das sehr oft für die praktische Anwendung, um die es geht, völlig ausreichend ist.

Für einige Probleme sind gar keine effizienten Algorithmen bekannt, die eine exakte Lösung liefern. In solchen Fällen muss man de facto auf Näherungen zurückgreifen. Es ist auch interessant zu wissen, dass es bei sehr komplexen Problemen (z.B. dem Training von LLMs) sehr viele Lösungen gibt, die “beinahe optimal” sind, d.h. der tatsächlich optimalen Lösung fast beliebig nahe kommen. So eine beinahe optimale Lösung bereits zu finden ist oft viel einfacher als nach der tatsächlich optimalen Lösung überhaupt erst zu suchen.

Hier sind die wichtigsten Varianten im Überblick:

Approximationsalgorithmen: Diese Algorithmen finden eine Lösung, die garantiert innerhalb eines bestimmten Faktors vom Optimum liegt.
- Beispiel: Für das Travelling Salesman Problem gibt es einen 2-Approximationsalgorithmus, der eine Tour findet, die höchstens doppelt so lang ist wie die optimale Tour.
Heuristiken: Diese Algorithmen finden oft gute Lösungen, bieten aber keine formalen Garantien für die Qualität der Lösung.
- Beispiel: Genetische Algorithmen oder Simulated Annealing können gute Lösungen für Optimierungsprobleme finden, garantieren aber nicht, dass das globale Optimum gefunden wird.
Randomisierte Algorithmen: Diese Algorithmen treffen zufällige Entscheidungen und können mit hoher Wahrscheinlichkeit gute Lösungen finden.
- Beispiel: Der Randomized Quicksort wählt das Pivotelement (an dem die zu sortierende Liste rekursiv geteilt wird) zufällig, was zu einer erwarteten Laufzeit von $O(N \log N)$ führt.

Die empirische Analyse solcher Algorithmen ist besonders wichtig, da ihre theoretischen Garantien oft nur Worst-Case-Szenarien abdecken, während sie in der Praxis oft viel besser abschneiden.

2.6 Übungsaufgabe: Möglichkeiten für die Berechnung von Pi¶

Da wir diese Woche “Pi-day” feiern (den 14.3., also 03/14), ist es unsere moralische Pflicht, verschiedene Möglichkeiten zur Berechnung dieser berühmten Zahl zu erkunden. Sie können das ganz für sich oder in Zusammenarbeit mit dem LLM Ihrer Wahl tun. Ich schlage folgende Schritte vor:

Diskutieren/Erfahren Sie, welche Verfahren man verwenden kann, um Pi zu berechnen
Wählen Sie davon zwei Verfahren aus, die Sie interessant finden
Implementieren Sie beide (jeweils separat) in Python
Testen Sie die Effizienz Ihrer beiden Implementationen in Abhängigkeit von der Anzahl der gewünschten Nachkommastellen von Pi als Eingabegröße
Visualisieren Sie Ihre Testergebnisse
Interpretieren Sie die Resultate und Visualisierung. Was stellen Sie fest?

Viel Vergnügen!

In [ ]:

# Dies ist ein erster Arbeitsbereich, in dem Sie Ihren Code hereinkopieren und testen können. 
# Erstellen Sie je nach Bedarf weitere Jupyter-Zellen

2.7 Zusammenfassung der wichtigsten Punkte dieser Einheit¶

In dieser Einheit haben wir uns mit einem der fundamentalsten Konzepte der Informatik beschäftigt: der Analyse von Algorithmen und ihrer Komplexität. Wir haben gelernt, wie wir die Effizienz eines Algorithmus sowohl theoretisch als auch empirisch, also in der Praxis, testen und bewerten können.

Was wir diesmal diskutiert haben, ist in erster Linie grundlegend für die Beschäftigung mit Algorithmen per se. Ich möchte diese Denkansätze und Inhalte aber insbesondere als Horizont-Erweiterung für Sie verstanden wissen. Das bedeutet, Sie sollten nicht komplett plan- und ahnungslos sein, wenn es um die theoretische Komplexitätsanalyse von Algorithmen und deren Implementierungen geht. Das ist allerdings nicht das Hauptthema bei der Beschäftigung mit Algorithmen in unserer Lehrveranstaltung, sondern es geht mir hauptsächlich darum, wie Sie in Zukunft konkrete Probleme mit Computerunterstützung lösen können.

Daher nehmen Sie bitte vor allem die folgenden Dinge aus dieser Einheit mit:

Die Bedeutung der Algorithmenanalyse
- Effiziente Algorithmen sparen Ressourcen (Zeit, Speicher, Energie, Nerven)
- Mit den wachsenden Datenmengen unserer Zeit wird diese Effizienz immer wichtiger
- Die Algorithmenanalyse hilft uns, fundierte Entscheidungen bei der Auswahl von Algorithmen zu treffen, aber auch dabei, Schwachstellen zu finden und auszumerzen/zu optimieren
Asymptotische Notation
- Die Big-O-Notation beschreibt eine obere Schranke für das Wachstum eines Algorithmus bei wachsender Eingabegröße
- Wir konzentrieren uns auf das Verhalten für große Eingabegrößen und ignorieren konstante Faktoren und nicht-dominante Terme
- Diese Notation erlaubt es, im betrachteten Grenzfall verschiedene Algorithmen und deren Implementationen einfach zu vergleichen
Zeitkomplexität
- Hier gibt es verschiedenste Verhalten, die wir uns beispielhaft angesehen haben
- Merken Sie sich ein paar der genannten Fälle, z.B. $O(1)$ , $O(\log N)$, $O(N)$, etc., sowie die dazu gehörenden Bezeichnungen
- Besonders wichtig für die Bestimmung der Zeitkomplexität ist die Analyse von Schleifen und rekursiven Aufrufen
Speicherkomplexität
- Die zentrale Frage lautet: Wie viel zusätzlichen Speicher (zusätzlich zur Eingabegröße) benötigt ein Algorithmus?
- Oft gibt es Trade-offs zwischen Zeit- und Speicherkomplexität
- Wir verwenden die gleichen Komplexitäts-Bezeichnungen wie bei der Zeitkomplexität
- Z.B. In-Place-Algorithmen oder clevere Konstrukte minimieren den zusätzlichen Speicherbedarf
Empirische Analyse
- Die tatsächliche Leistung kann durch Faktoren beeinflusst werden, die in der theoretischen Analyse nicht berücksichtigt werden
- Benchmarking und Visualisierung helfen, die praktische Leistung zu verstehen
- Theoretische und empirische Analyse ergänzen sich also

FMCA-25: 01 Einführung in algorithmisches Denken & LLMs

1 Einführung in algorithmisches Denken & LLMs¶

Willkommen zu “Fortgeschrittene Mathematik und Computergestützte Algorithmen”! In diesem Kurs werden wir gemeinsam einige fortgeschrittene mathematische Konzepte und algorithmische Ansätze zur Lösung komplexer Probleme erkunden.

Nach dem Studium dieser Einheit sollten Sie zumindest folgende drei der wichtigsten Punkte hier verstehen:

Was ein Algorithmus ist
Was Large-Language Models (LLMs) sind und was man derzeit von ihnen erwarten kann
Wie Sie ein LLM einsetzen, um Algorithmen zu implementieren und damit konkrete Probleme zu lösen

1.1 Was ist ein Algorithmus?¶

Algorithmen sind etwas, das wir ständig verwenden. Ob im täglichen Leben oder in speziellen Situationen wie z.B. beim Lösen konkreter Probleme.

1.1.1 Leicht verständliche Beispiele für Algorithmen:¶

Simple Beispiele für Algorithmen sind

Wie man zwei Zahlen miteinander multipliziert
Wie man eine Tasse Tee trinkt
Ein Kochrezept
Eine Montageanleitung für Möbel
Eine Wegbeschreibung von Punkt A nach Punkt B
Wie Sie ein Jupyter notebook aus unserem Moodle-Kurs herunterladen können
Wie Sie Ihr Studium beenden können/werden

1.1.2 Wesentliche Eigenschaften von Algorithmen:¶

Was alle Algorithmen gemeinsam haben, sind folgende Eigenschaften:

Endlichkeit: Ein Algorithmus muss nach einer endlichen Anzahl von Schritten terminieren
Bestimmtheit: Jeder Schritt muss präzise definiert sein, damit man in der Lage ist, alles genau nachzuvollziehen bzw. richtig zu implementieren
Eingabe: Ein Algorithmus nimmt null oder mehr Eingaben entgegen
Ausgabe: Er produziert eine oder mehrere Ausgaben
Effektivität: Wie vollständig, korrekt, präzise und robust ein Algorithmus ein Problem löst, und wie gut er generell für solche Probleme anwendbar ist
Effizienz: Wie gut oder schnell ein Algorithmus ein Problem lösen kann, z.B. einen bestimmten Grad an Komplexität

Im Folgenden werden wir uns ein einfaches Beispiel ansehen (und gleichzeitig den diesbezüglichen Umgang mit LLMs üben). Sie sollen dabei unter anderem ein Gefühl dafür bekommen, was mit dem Begriff “Algorithmus” gemeint ist und wie er mit einem Computerprogramm zusammenhängt.

1.1.3 Möglichkeiten, Algorithmen zu formulieren bzw. aufzuschreiben:¶

Einen Algorithmus zu formulieren kann man sich einfach machen, aber auch komplizierter. Wichtig dabei ist, dass die verwendete Methode für die Anfordernisse der Situation ausreichen. Was man hier verwenden kann ist z.B.:

Natürliche Sprache, so wie Sie jemandem erklären würden, was zu tun ist
Pseudocode
Flussdiagramme (Flowcharts)
Computer-Code über die Verwendung von Programmiersprachen wie z.B. Python

1.1.4. Iterative vs. Direkte Algorithmen¶

Algorithmen können nach ihrer Herangehensweise grob in zwei Kategorien eingeteilt werden: iterative und direkte Algorithmen. Diese Unterscheidung ist fundamental für das Verständnis algorithmischer Problemlösungsstrategien.

Direkte Algorithmen (auch als “Closed-Form” oder “Analytical Solutions” bezeichnet) berechnen das Ergebnis in einem einzigen Durchlauf ohne Wiederholungen oder Annäherungen. Sie liefern das exakte Ergebnis direkt durch eine mathematische Formel oder einen definierten Ablauf.

Haupteigenschaften direkter Algorithmen:

Sie erfordern eine vollständige Problemanalyse vor der Implementierung
Sie liefern das Ergebnis in einer vorherbestimmbaren, konstanten Anzahl von Schritten, vielleicht sogar in einem einzigen Schritt
Man benötigt allerdings typischerweise ein tieferes mathematisches Verständnis des Problems, um eine direkte Lösung zu finden oder zu implementieren

Beispiele für direkte Algorithmen:

Berechnung der Lösungen einer quadratischen Gleichung mit der bekannten Formel
Matrixinversion für ein lineares Gleichungssystem mit der Cramer’schen Regel
Berechnung der Signumfunktion von $(-1)^N$

Iterative Algorithmen

Iterative Algorithmen nähern sich der Lösung schrittweise durch wiederholte Berechnungen an. Sie führen eine Folge von Operationen aus, wobei jeder Schritt auf den Ergebnissen des vorherigen aufbaut, bis eine Abbruchbedingung erreicht ist.

Eigenschaften iterativer Algorithmen:

Sie lösen das Problem durch wiederholte Anwendung einer Regel oder Transformation
Sie benötigen grundsätzlich eine Abbruchbedingung (meist ein Konvergenzkriterium)
Sie sind für komplexe Probleme meist wesentlich einfacher zu implementieren
Und sie eignen sich naturgemäß insbesondere für Probleme, bei denen keine direkten Lösungsformeln bekannt sind

Beispiele für iterative Algorithmen:

Newton-Raphson-Verfahren zur Nullstellenberechnung einer Funktion
Die iterative Berechnung der Fibonacci-Zahlen $F_{(i+1)}=F_i+F_{(i-1)}$

Hybride Ansätze

In der Praxis verwenden viele moderne Algorithmen hybride Ansätze, die Elemente beider Kategorien kombinieren. Die Unterscheidung zwischen iterativen und direkten Algorithmen bietet also in erster Linie eine nützliche konzeptuelle Grundlage für die Analyse und Entwicklung von Problemlösungsstrategien. Letztlich ist die Wahl des geeigneten Ansatzes aber stark problemabhängig und berücksichtigt Faktoren wie Genauigkeitsanforderungen, Berechnungsressourcen, Problemgröße und Komplexität.

1.2 Problemlösungsparadigmen¶

Es gibt mehrere gängige Ansätze zum Entwerfen von Algorithmen:

Brute Force: Alle möglichen Lösungen werden ausprobiert, bis eine passende gefunden wird
- Einfach, aber meist ineffizient, oft (öfter als einem lieb ist) praktisch unmöglich durchführbar
- Beispiel: Überprüfen aller möglichen Kombinationen bei einem Zahlenschloss
Teile und Herrsche (Divide and Conquer):
- Ein Problem wird in kleinere Teilprobleme zerlegt
- Jedes Teilproblem wird dann unabhängig von den anderen Teilen gelöst
- Die Lösungen werden anschließend, wenn nötig, wieder kombiniert
- Beispiel: Binäre Suche nach der Position einer bestimmten Zahl in einer geordneten Liste von Zahlen
Greedy-Ansatz:
- Bei jedem Schritt wird die lokal optimale Wahl getroffen, das heißt, man tut so, als ob man sich bereits in der Nähe der tatsächlichen Lösung befände
- Die Hoffnung dabei ist, damit das globale Optimum zu finden (den Unterschied sehen wir später, wenn es um Optimierung geht)
- Beispiel: Eine bestimmte Summe Wechselgeld aus möglichst wenigen Münzen mit bestimmten Werten zusammensetzen
Dynamische Programmierung:
- Ein Problem wird in überlappende Teilprobleme zerlegt
- Jedes Teilproblem wird separat und einmal gelöst und alle Teillösungen werden gespeichert
- Beispiel: Finden des kürzesten Pfades zwischen zwei Knotenpunkten in einem Graphen

1.2.1 Visualisierung von Divide and Conquer¶

In [1]:

# Implementiert mit Claude 3.7 Sonnet
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.patches import Rectangle, FancyArrowPatch
from matplotlib.animation import FuncAnimation
import matplotlib.gridspec as gridspec
import time

def binary_search(arr, target):
    """
    Implementiert die binäre Suche als Divide-and-Conquer Algorithmus.
    
    Args:
        arr: Sortierte Liste von Elementen
        target: Gesuchter Wert
        
    Returns:
        int: Index des gesuchten Werts oder -1, wenn nicht gefunden
        list: Schritte der Suche für Visualisierung
    """
    schritte = []
    
    def binary_search_recursive(links, rechts):
        # Basis-Fall: Leerer Suchbereich
        if links > rechts:
            schritte.append({'links': links, 'rechts': rechts, 'mitte': None, 'gefunden': False})
            return -1
        
        # Berechne die Mitte des aktuellen Suchbereichs (Divide)
        mitte = (links + rechts) // 2
        schritte.append({'links': links, 'rechts': rechts, 'mitte': mitte, 'gefunden': False})
        
        # Prüfe, ob der gesuchte Wert in der Mitte liegt
        if arr[mitte] == target:
            schritte[-1]['gefunden'] = True
            return mitte
        
        # Wenn der gesuchte Wert kleiner ist, suche in der linken Hälfte (Conquer)
        elif arr[mitte] > target:
            return binary_search_recursive(links, mitte - 1)
        
        # Wenn der gesuchte Wert größer ist, suche in der rechten Hälfte (Conquer)
        else:
            return binary_search_recursive(mitte + 1, rechts)
    
    # Starte die rekursive Suche
    result = binary_search_recursive(0, len(arr) - 1)
    return result, schritte

def binary_search_iterative(arr, target):
    """
    Implementiert die binäre Suche iterativ für den Vergleich.
    
    Args:
        arr: Sortierte Liste von Elementen
        target: Gesuchter Wert
        
    Returns:
        int: Index des gesuchten Werts oder -1, wenn nicht gefunden
        list: Schritte der Suche für Visualisierung
    """
    schritte = []
    links, rechts = 0, len(arr) - 1
    
    while links <= rechts:
        mitte = (links + rechts) // 2
        schritte.append({'links': links, 'rechts': rechts, 'mitte': mitte, 'gefunden': False})
        
        if arr[mitte] == target:
            schritte[-1]['gefunden'] = True
            return mitte, schritte
        
        if arr[mitte] > target:
            rechts = mitte - 1
        else:
            links = mitte + 1
    
    schritte.append({'links': links, 'rechts': rechts, 'mitte': None, 'gefunden': False})
    return -1, schritte

def visualisiere_array(schritte, schritt_idx, arr, target, ax):
    """Visualisiert das Array und den aktuellen Suchbereich."""
    ax.clear()
    ax.set_title(f"Binäre Suche für Zielwert {target}")
    ax.set_yticks([])
    
    # Aktueller Schritt
    schritt = schritte[schritt_idx] if schritt_idx < len(schritte) else schritte[-1]
    
    # Zeichne alle Elemente des Arrays
    for i, wert in enumerate(arr):
        farbe = 'white'
        
        # Markiere den Suchbereich
        if schritt['links'] <= i <= schritt['rechts']:
            farbe = 'lightskyblue'
        
        # Markiere die aktuelle Mitte
        if schritt['mitte'] is not None and i == schritt['mitte']:
            farbe = 'yellow' if not schritt['gefunden'] else 'lightgreen'
        
        # Zeichne ein Rechteck für das Element
        rect = Rectangle((i-0.4, 0), 0.8, 0.8, color=farbe, ec='black')
        ax.add_patch(rect)
        
        # Füge den Wert hinzu
        ax.text(i, 0.4, str(wert), ha='center', va='center')
    
    # Setze die Achsenbegrenzungen
    ax.set_xlim(-0.5, len(arr) - 0.5)
    ax.set_ylim(0, 1)
    
    # Beschriftungen für die Indizes
    ax.set_xticks(range(len(arr)))
    ax.set_xticklabels(range(len(arr)))
    
    # Status-Text
    status_text = ""
    if schritt['mitte'] is not None:
        if schritt['gefunden']:
            status_text = f"Gefunden an Position {schritt['mitte']}!"
        else:
            vergleich = ">" if arr[schritt['mitte']] > target else "<"
            status_text = f"Mitte ({schritt['mitte']}): {arr[schritt['mitte']]} {vergleich} {target}"
            if schritt_idx + 1 < len(schritte):
                naechster_schritt = schritte[schritt_idx + 1]
                if naechster_schritt['links'] > naechster_schritt['rechts']:
                    status_text += "\nElement nicht im Array"
                elif naechster_schritt['links'] > schritt['links']:
                    status_text += f"\nSuche in rechter Hälfte [{schritt['mitte'] + 1}, {schritt['rechts']}]"
                else:
                    status_text += f"\nSuche in linker Hälfte [{schritt['links']}, {schritt['mitte'] - 1}]"
    else:
        status_text = "Element nicht im Array gefunden"
    
    ax.text(len(arr) / 2, -0.2, status_text, ha='center', va='top')

def visualisiere_binaere_suche(arr, target):
    """Visualisiert den Ablauf der binären Suche als Divide-and-Conquer."""
    # Führe die binäre Suche durch und sammle die Schritte
    ergebnis, schritte = binary_search(arr, target)
    
    # Erstelle die Figur und Subplots
    fig = plt.figure(figsize=(12, 8))
    gs = gridspec.GridSpec(2, 1, height_ratios=[1, 2])
    
    ax_array = plt.subplot(gs[0])
    # ax_baum = plt.subplot(gs[1])
    
    # Initialisiere die Visualisierung
    schritt_idx = 0
    visualisiere_array(schritte, schritt_idx, arr, target, ax_array)
    
    plt.tight_layout()
    
    # Funktion für die Animation
    def update(frame):
        nonlocal schritt_idx
        schritt_idx = min(frame, len(schritte) - 1)
        visualisiere_array(schritte, schritt_idx, arr, target, ax_array)
    
    # Erstelle die Animation und speichere sie in einer Variable
    ani = FuncAnimation(fig, update, frames=len(schritte) + 2, interval=1000, repeat=False)
    
    # Füge Titel und Informationen hinzu
    plt.suptitle(f"Binäre Suche als Divide-and-Conquer für {target} in {arr}", fontsize=14)
     
    plt.tight_layout()
    plt.subplots_adjust(top=0.9, bottom=0.1)
    # plt.show()
    
    # Alternative: Animation als GIF speichern
    ani.save('binary_search_animation.gif', writer='pillow', fps=1)    
    
    # Gib das Ergebnis, die Schritte und die Animation zurück
    return ergebnis, schritte, ani

# Beispiel: Visualisiere die binäre Suche
if __name__ == "__main__":
    # Beispiel-Array und Zielwert
    arr = [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29]
    target = 3  # Element an Index 2
    
    print(f"Binäre Suche für {target} in {arr}:")
    ergebnis, schritte, animation = visualisiere_binaere_suche(arr, target)
    print(f"Ergebnis: {ergebnis} (gefunden an Index {ergebnis})")
    print(f"Benötigte Schritte: {len(schritte)}")
    
    # Speichere die Animation in einer Variable im globalen Scope,
    # um zu verhindern, dass sie vom Garbage Collector gelöscht wird
    _animation_reference = animation

Binäre Suche für 3 in [1, 3, 5, 7, 9, 11, 13, 15, 17, 19, 21, 23, 25, 27, 29]:
Ergebnis: 1 (gefunden an Index 1)
Benötigte Schritte: 3

1.2.2 Implementierung und Visualisierung eines Greedy-Ansatzes¶

Wir sehen uns hier das obige Beispiel des Wechselgeldes mit möglichst wenigen Münzen an.

Problemstellung: Gegeben ist ein Betrag X und eine Menge von Münzwerten (z.B. 1, 2, 5, 10, 20, 50 Cent, 1 Euro, 2 Euro). Ziel ist es, den Betrag X mit möglichst wenigen Münzen zurückzugeben. Gesucht ist also eine mathematische Lösung, die abzählt, wie oft welche Münze herausgegeben werden muss.

Greedy-Strategie:

Beginne mit der größtmöglichen Münze, die nicht größer als der verbleibende Betrag ist
Füge diese Münze zur Lösung hinzu (die Anzahl dieses Münzwertes wird um 1 erhöht)
Reduziere den verbleibenden Betrag entsprechend um den verwendeten Münzwert
Wiederhole diese Schritte, bis der verbleibende Betrag 0 ist (das ist also ein iterativer Algorithmus)

Beispiel: Für einen Betrag von 3,67€ mit dem Euro-Münzsystem:

Wähle 2€ (Rest: 1,67€) Wähle 1€ (Rest: 0,67€) Wähle 50 Cent (Rest: 0,17€) Wähle 10 Cent (Rest: 0,07€) Wähle 5 Cent (Rest: 0,02€) Wähle 2 Cent (Rest: 0€)

Das sind insgesamt 6 Münzen.

Sehen wir uns nun nochmal an, warum dieser Algorithmus “greedy” ist:

Lokale Optimierung: In jedem Schritt wird die aktuell bestmögliche Entscheidung getroffen (größtmögliche Münze)
Keine Rücknahme: Einmal getroffene Entscheidungen werden nicht revidiert
Keine Vorausschau: Der Algorithmus berücksichtigt nur den aktuellen Zustand

Interessant ist hier folgendes: Für das europäische und US-amerikanische Münzsystem führt der Greedy-Algorithmus tatsächlich zur optimalen Lösung. Dies liegt an der speziellen Eigenschaft dieser Münzsysteme, und zwar dass jede Münze mindestens doppelt so viel wert ist wie die Summe aller kleineren Münzen (kanonisches Münzsystem). Bei anderen Münzsystemen (z.B. mit Münzwerten 1, 3, 4) führt der Greedy-Ansatz nicht immer zur optimalen Lösung. Für 6 Geldeinheiten würde der Greedy-Algorithmus 4+1+1 (3 Münzen) wählen, während 3+3 (2 Münzen) optimal wäre.

In [2]:

# Implementiert mit Claude 3.7 Sonnet
import matplotlib.pyplot as plt
import numpy as np
from matplotlib.patches import Circle
import matplotlib.colors as mcolors

def greedy_change(betrag, muenzen):
    """
    Implementiert den Greedy-Algorithmus für das Wechselgeld-Problem.
    
    Args:
        betrag: Zu wechselnder Betrag (in Cent)
        muenzen: Liste der verfügbaren Münzwerte (in Cent), absteigend sortiert
        
    Returns:
        verwendete_muenzen: Liste der verwendeten Münzen
    """
    # Sortiere Münzen in absteigender Reihenfolge
    muenzen = sorted(muenzen, reverse=True)
    
    verwendete_muenzen = []
    rest = betrag
    
    # Greedy-Algorithmus
    for muenze in muenzen:
        while rest >= muenze:
            verwendete_muenzen.append(muenze)
            rest -= muenze
    
    return verwendete_muenzen

def optimal_change(betrag, muenzen):
    """
    Implementiert einen dynamischen Programmieransatz für das Wechselgeld-Problem.
    
    Args:
        betrag: Zu wechselnder Betrag (in Cent)
        muenzen: Liste der verfügbaren Münzwerte (in Cent)
        
    Returns:
        min_muenzen: Minimale Anzahl der Münzen
        verwendete_muenzen: Liste der verwendeten Münzen
    """
    # Initialisiere die dynamische Programmierung Tabelle
    # dp[i] = minimale Anzahl Münzen für Betrag i
    dp = [float('inf')] * (betrag + 1)
    dp[0] = 0
    
    # Speichere für jeden Betrag, welche Münze als letztes verwendet wurde
    letzte_muenze = [0] * (betrag + 1)
    
    # Berechne die minimale Anzahl Münzen für jeden Teilbetrag
    for i in range(1, betrag + 1):
        for muenze in muenzen:
            if muenze <= i and dp[i - muenze] + 1 < dp[i]:
                dp[i] = dp[i - muenze] + 1
                letzte_muenze[i] = muenze
    
    # Rekonstruiere die verwendeten Münzen
    verwendete_muenzen = []
    rest = betrag
    while rest > 0:
        muenze = letzte_muenze[rest]
        verwendete_muenzen.append(muenze)
        rest -= muenze
    
    return dp[betrag], verwendete_muenzen

def visualisiere_muenzen(betrag, muenzen_system1, muenzen_system2):
    """
    Visualisiert die Ergebnisse des Greedy- und des optimalen Algorithmus für zwei Münzsysteme.
    
    Args:
        betrag: Zu wechselnder Betrag
        muenzen_system1: Erstes Münzsystem (z.B. Euro)
        muenzen_system2: Zweites Münzsystem (alternatives System)
    """
    # Berechne Wechselgeld für System 1 (Euro-System)
    greedy_muenzen_system1 = greedy_change(betrag, muenzen_system1)
    opt_anzahl_system1, opt_muenzen_system1 = optimal_change(betrag, muenzen_system1)
    
    # Berechne Wechselgeld für System 2 (alternatives System)
    greedy_muenzen_system2 = greedy_change(betrag, muenzen_system2)
    opt_anzahl_system2, opt_muenzen_system2 = optimal_change(betrag, muenzen_system2)
    
    # Erstelle die Visualisierung
    fig, axs = plt.subplots(2, 2, figsize=(14, 8))
    fig.suptitle(f'Wechselgeld für {betrag/100:.2f} Geldeinheiten', fontsize=16)
    
    # Definiere Farben für die Münzen basierend auf ihrem Wert
    farben = list(mcolors.TABLEAU_COLORS)
    muenzfarben1 = {muenze: farben[i % len(farben)] for i, muenze in enumerate(set(muenzen_system1))}
    muenzfarben2 = {muenze: farben[i % len(farben)] for i, muenze in enumerate(set(muenzen_system2))}
    
    # System 1 - Greedy
    visualisiere_muenzen_set(axs[0, 0], greedy_muenzen_system1, muenzfarben1)
    axs[0, 0].set_title(f'System 1 - Greedy: {len(greedy_muenzen_system1)} Münzen')
    
    # System 1 - Optimal
    visualisiere_muenzen_set(axs[0, 1], opt_muenzen_system1, muenzfarben1)
    axs[0, 1].set_title(f'System 1 - Optimal: {opt_anzahl_system1} Münzen')
    
    # System 2 - Greedy
    visualisiere_muenzen_set(axs[1, 0], greedy_muenzen_system2, muenzfarben2)
    axs[1, 0].set_title(f'System 2 - Greedy: {len(greedy_muenzen_system2)} Münzen')
    
    # System 2 - Optimal
    visualisiere_muenzen_set(axs[1, 1], opt_muenzen_system2, muenzfarben2)
    axs[1, 1].set_title(f'System 2 - Optimal: {opt_anzahl_system2} Münzen')
    
    # Füge Legenden hinzu
    for i, (muenzfarben, system) in enumerate([(muenzfarben1, muenzen_system1), (muenzfarben2, muenzen_system2)]):
        handles = []
        labels = []
        for muenze in sorted(set(system), reverse=True):
            circle = Circle((0, 0), 0.4, color=muenzfarben[muenze])
            handles.append(circle)
            labels.append(f'{muenze/100:.2f}')
        
        fig.legend(handles, labels, loc=f'upper right', bbox_to_anchor=(0.25+i*.5, 0.9), 
                  title=f'System {i+1} Münzwerte')
    
    plt.tight_layout(rect=[0, 0, 0.85, 0.9])
    plt.show()

def visualisiere_muenzen_set(ax, muenzen, muenzfarben):
    """Visualisiert einen Satz von Münzen in einem Subplot."""
    # Sortiere Münzen absteigend
    muenzen = sorted(muenzen, reverse=True)
    
    # Bestimme maximale Anzahl von Münzen pro Zeile
    max_pro_zeile = 10
    
    # Größe der Münzen
    radius = 0.4
    
    # Zeichne jede Münze
    for i, muenze in enumerate(muenzen):
        zeile = i // max_pro_zeile
        spalte = i % max_pro_zeile
        x = spalte * 2 * radius * 1.1 + radius
        y = -zeile * 2 * radius * 1.1 - radius
        
        circle = Circle((x, y), radius, color=muenzfarben[muenze])
        ax.add_patch(circle)
        
        # Füge Wert als Text hinzu
        ax.text(x, y, f"{muenze/100:.2f}", ha='center', va='center', fontsize=9)
    
    # Setze Achsenbegrenzungen
    zeilen = (len(muenzen) - 1) // max_pro_zeile + 1
    ax.set_xlim(0, max_pro_zeile * 2 * radius * 1.1)
    ax.set_ylim(-zeilen * 2 * radius * 1.1, 0)
    
    # Entferne Achsenticks
    ax.set_xticks([])
    ax.set_yticks([])
    ax.set_aspect('equal')

# Beispiel: Vergleich zweier Münzsysteme
if __name__ == "__main__":
    # System 1: Euro-System (in Cent)
    euro_system = [200, 100, 50, 20, 10, 5, 2, 1]
    
    # System 2: Alternatives System (in Cent)
    alternatives_system = [400, 300, 100, 50, 10, 1]
    
    # Betrag zum Wechseln (in Cent)
    betrag = 600  # 6,00 Geldeinheiten
    
    # Visualisiere die Ergebnisse
    visualisiere_muenzen(betrag, euro_system, alternatives_system)
    
    # Zeige textuelle Zusammenfassung für beide Systeme
    print("System 1 (Euro-System):")
    greedy_euro = greedy_change(betrag, euro_system)
    print(f"  Greedy-Lösung: {len(greedy_euro)} Münzen: {[m/100 for m in greedy_euro]}")
    
    opt_anzahl_euro, opt_euro = optimal_change(betrag, euro_system)
    print(f"  Optimale Lösung: {opt_anzahl_euro} Münzen: {[m/100 for m in opt_euro]}")
    
    print("\nSystem 2 (Alternatives System):")
    greedy_alt = greedy_change(betrag, alternatives_system)
    print(f"  Greedy-Lösung: {len(greedy_alt)} Münzen: {[m/100 for m in greedy_alt]}")
    
    opt_anzahl_alt, opt_alt = optimal_change(betrag, alternatives_system)
    print(f"  Optimale Lösung: {opt_anzahl_alt} Münzen: {[m/100 for m in opt_alt]}")

System 1 (Euro-System):
  Greedy-Lösung: 3 Münzen: [2.0, 2.0, 2.0]
  Optimale Lösung: 3 Münzen: [2.0, 2.0, 2.0]

System 2 (Alternatives System):
  Greedy-Lösung: 3 Münzen: [4.0, 1.0, 1.0]
  Optimale Lösung: 2 Münzen: [3.0, 3.0]

1.3. Kritische Beurteilung von Algorithmen¶

Bei der Untersuchung von Algorithmen sollten wir immer Folgendes berücksichtigen:

Korrektheit des Algorithmus: Produziert er für alle gültigen Eingaben die richtige Ausgabe?
Effizienz des Algorithmus: Wie gut nutzt er die Rechenressourcen? Insbesondere interessant sind hier die
- Zeitkomplexität: Wie lange dauert die Ausführung?
- Raumkomplexität: Wie viel Speicher wird benötigt?
Eleganz des Algorithmus: Ist die Lösung klar implementierbar und einfach wartbar?
Robustheit des Algorithmus: Wie geht er mit unerwarteten Eingaben oder Grenzfällen um? Leidet in solchen Fällen die Effizienz?

Wir werden uns in der nächsten Einheit intensiver mit diesen Eigenschaften und Themen beschäftigen. Für den Moment halten wir einfach die Augen offen und sind achtsam, falls etwas Unerwartetes oder Ungeheures passiert.

1.4 Einführung in die Verwendung von Large Language Models (LLMs) zur algorithmischen Lösung von Problemen¶

In diesem Kurs werden wir grundsätzlich Large Language Models (LLMs) als Werkzeuge zur Implementierung von Algorithmen, verstehen der Details, und zum Schreiben von Python-Code verwenden. Dieser Abschnitt ist ein ultra-Crash-Course, der Ihnen unmittelbar die nötigen Werkzeuge in die Hand geben soll, um erfolgreich Code zu generieren, aber auch sinnvoll damit zu arbeiten.

1.4.1 Was sind LLMs?¶

LLMs sind moderne KI-Systeme, die auf enormen Mengen von Textdaten trainiert wurden. Bei den Trainingsdaten handelt es sich z.B. um verschiedene Inhalte aus dem Internet, ganze Sammlungen von Codebeispielen (GitHub), Diskussionsforen (Reddit), und andere Quellen, in denen Konversationen vorkommen. Der Grund dafür ist, dass diese Modelle trainiert wurden, auf einen User-Input, den sogenannten Prompt, den bestmöglichen Output zu erzeugen. Oder, noch konkreter: Ein LLM will mit Ihnen die Konversation führen, die Sie sich höchstwahrscheinlich wünschen.

Lassen Sie diesen Gedanken einmal kurz sacken, denn dieses Verständnis wird Ihnen im Umgang mit LLMs viel Unverständnis ersparen. Je genauer Sie sich darauf einstellen, einen Gesprächspartner zu haben (und nicht ein allwissendes Dingsbums), desto bessere Resultate werden Sie erzielen.

LLMs können, ganz kurz gesagt und für unsere Zwecke:

Menschliche Sprache verarbeiten und erzeugen
Code basierend auf Beschreibungen schreiben
Konzepte und Algorithmen erklären
Code debuggen und optimieren
Sich auf Englisch oder Deutsch (oder auch in anderen Sprachen) mit Ihnen unterhalten

LLMs können nicht, wieder ganz kurz gesagt und für unsere Zwecke:

Wissen, was Sie denken, wenn Sie das nicht klar formulieren oder formuliert haben
Logisch denken (das funktioniert nur mit zusätzlichen Schichten im Modell, wie sie seit Ende 2024 angeboten werden)

1.4.2 Wie wir LLMs in diesem Kurs nutzen werden:¶

Die Nutzung von LLMs ist inzwischen sehr einfach geworden. Bei allen Anbietern gibt es einen kostenlosen Zugang zu grundlegenden Funktionen, der allerdings meist eine Registrierung voraussetzt. Andererseits gibt Ihnen eine Registrierung auch die Möglichkeit, Ihre Chats mit dem LLM zu organisieren und auf früher geführte Konversationen zurückzugreifen. Im Prinzip reicht inzwischen ein kostenloser Zugang jedenfalls aus, um gut mit dem LLM Ihrer Wahl an den Kursaufgaben und -Inhalten arbeiten zu können.

Wir werden mit Hilfe der LLMs:

Den Hintergrund und die Details der präsentierten Probleme verstehen lernen
Algorithmen basierend auf unseren Beschreibungen implementieren
Verschiedene Implementierungsansätze erkunden und vergleichen
Code und Algorithmen erklären lassen und deren Details und Möglichkeiten unter die Lupe nehmen, wenn wir das wollen
Lösungen optimieren und Code debuggen
Ergebnisse visualisieren und analysieren

Dieser Ansatz ermöglicht es uns hauptsächlich, uns auf das Verständnis algorithmischer Prinzipien und deren Lösungspotential zu konzentrieren anstatt mit Syntaxdetails oder dem zeilenweisen Schreiben von Code zu kämpfen.

1.4.3 Konkrete Vorteile und Einschränkungen von LLMs für die Algorithmenimplementierung¶

Hier kurz die wichtigsten Vorteile und Einschränkungen in der Arbeit mit LLMs bei der Implementierung von Algorithmen. Sie werden allerdings bereits nach kurzer Zeit selbst ein ziemlich gutes Gefühl dafür haben, was besser funktioniert und was nicht so gut.

Vorteile:

Schnelle Implementierung komplexer Algorithmen
Mehrere Implementierungsansätze zum Vergleichen
Fokus auf Konzepte statt Syntax
Kennenlernen verschiedener Programmierstile und -techniken (optional)

Einschränkungen:

Liefern nicht immer optimale Lösungen
Können Fehler im logischen Denken machen
Können “halluzinieren” oder nicht existierende Funktionen erfinden
Begrenzt auf Wissen aus ihren Trainingsdaten

Grundlegende Interaktionsrichtlinien:

Seien Sie klar und spezifisch in Ihren Beschreibungen
Liefern Sie wenn möglich den Kontext zu dem Problem, das Sie lösen wollen
Geben Sie, soweit bekannt, Eingabe- und Ausgabeformate und gegebenenfalls auch Einschränkungen an
Fragen Sie bei Bedarf nach Erklärungen zur Implementierung
Überprüfen Sie die Korrektheit der Lösungen durch gezieltes Testen, Ausprobieren und den Einsatz bekannter Grenz- oder Spezialfälle
Iterieren und verfeinern Sie Ihre Prompts, bis Sie zufrieden sind

1.5 Arbeiten mit LLMs beim Lösen algorithmischer Probleme und beim Schreiben von Code¶

Hier folgen jetzt einige Muster für das Schreiben von Prompts, die Sie höchstwahrscheinlich im Verlauf des Kurses gut brauchen können. Zuvor nur noch ein paar kurze Hinweise:

Dokumentieren Sie grundsätzlich, welches LLM Sie an welcher Stelle eingesetzt haben (z.B. in Kommentaren im Code oder in Markdown-Zellen). Damit stellen Sie sicher, dass Sie oder ich sich in Ihrem Code zurechtfinden bzw. orientieren könnten, was dessen Herkunft betrifft (und zwar auch noch nach Wochen oder Monaten).
Sollten Sie außer den Prompts noch andere Einstellungen am LLM vorgenommen haben oder Materialien zugrunde gelegt haben (z.B. über eine Projektumgebung), dann dokumentieren Sie auch das ausreichend.
Versuchen Sie immer wieder, die Implementierungen und Code-Erklärungen bis ins Detail zu verstehen. Das ist zwar nicht der primäre Fokus der Lehrveranstaltung, aber es hilft Ihnen auf dem Weg zu einem tiefen Verständnis, und das lohnt sich!
Bleiben Sie kritisch, was die Antworten Ihres LLMs betrifft. Auch wenn die Erklärungen ausführlich und solide klingen, müssen sie nicht im Detail korrekt sein. Nutzen Sie im Zweifelsfall einen Dienst wie z.B. Perplexity oder ein LLM mit Internet-Zugang für einen gründlichen Fact-Check.

1.5.1 Wie Sie mehr über ein bestimmtes mathematisches Problem oder einen Algorithmus lernen¶

Verwenden Sie das folgende Promptmuster und setzen Sie geeignete Textbausteine für Ihren Anwendungsfall ein. Verändern Sie auch den Prompt, wenn Ihnen gute Modifikationen einfallen, die bessere Outputs versprechen. Ich habe den Prompt in eine separate Jupyter-Zelle gesetzt, damit Sie in einfacher kopieren können. Diese Vorgehensweise gilt auch für die nachfolgenden Prompt-Muster.

Ich möchte mehr über [Name des Algorithmus/mathematischen Problems] lernen. Bitte erkläre:
- Die grundlegende Idee und den Zweck
- Die mathematischen Grundlagen und Voraussetzungen
- Die wichtigsten Anwendungsfälle
- Die Stärken und Einschränkungen
- Die Komplexität (Zeit und Speicher)
- Wie sich dieser Algorithmus von ähnlichen Ansätzen unterscheidet

Bitte erkläre die Konzepte so, dass sie ich als UniversitätsstsudentIn im zweiten Jahr mit grundlegenden Mathematikkenntnissen und einem breit gefächerten naturwissenschaftlichen Basishintergrund gut verstehen kann.

1.5.2 Wie Sie herausfinden, welche Algorithmen sich zur Lösung eines bestimmten Problems eignen¶

Ich arbeite an folgendem Problem:
[Detaillierte Problembeschreibung]

Meine Eingabedaten haben folgende Eigenschaften:
- [Größe, Format, Struktur]
- [Besondere Merkmale oder Einschränkungen]

Mein Ziel ist:
[Beschreibung des gewünschten Ergebnisses]

Welche Algorithmen oder Verfahren würdest du für die Lösung dieses Problems empfehlen? Bitte erkläre bei jedem Vorschlag:
- Warum er für dieses Problem geeignet ist
- Wie die Umsetzung grob aussehen würde
- Vor- und Nachteile gegenüber anderen möglichen Ansätzen
- Gegebenenfalls notwendige Datenstrukturen

1.5.3 Wie Sie Python-Code schreiben lassen, der eine bestimmte Lösungsstrategie für ein Problem implementiert¶

Ich möchte [Name des Algorithmus] implementieren, um folgendes Problem zu lösen:
[Problembeschreibung]

Die Eingabe hat folgendes Format:
[Beschreibung des Eingabeformats]

Die Ausgabe sollte folgendes Format haben:
[Beschreibung des Ausgabeformats]

Bitte schreibe Python-Code für diese Implementierung mit:
- Ausführlichen Kommentaren zur Erklärung der einzelnen Schritte
- Effizienter Implementierung unter Berücksichtigung der Komplexität
- Klarer Struktur und verständlichen Variablennamen
- Verwendung geeigneter Python-Bibliotheken wie NumPy, wenn sinnvoll

1.5.4 Wie Sie nach Möglichkeiten fragen, den gerade erzeugten Code zu testen¶

Ich habe den von Dir generierten Python-Code nun zur verfügung und er läuft. Wie kann ich diesen Code gründlich testen? Bitte schlage vor:

- Verschiedene Testfälle (normale Fälle, Grenzfälle, Sonderfälle)
- Wie ich die Korrektheit des Ergebnisses verifizieren kann
- Mögliche Unit-Tests oder Testfunktionen
- Wie ich die Leistung und Effizienz messen könnte
- Ideen für visuelle Verifikation der Ergebnisse, falls anwendbar

1.5.5 Wie Sie Hilfe bei der Interpretation von Lösungen oder Visualisierungen bekommen, die Ihr Code erzeugt¶

Ich habe folgendes Ergebnis/folgende Visualisierung durch Ausführung meines Codes erhalten:
[Ergebnis/Visualisierung beschreiben oder einfügen]

Ich bin mir nicht sicher, wie ich die Ergebnisse interpretieren soll. Insbesondere:

[Spezifische Frage zur Interpretation]
[Auffälligkeiten oder unerwartete Muster]
[Unklarheiten bei der Visualisierung]

Kannst du mir helfen, diese Ausgabe zu verstehen und daraus sinnvolle Schlüsse zu ziehen?

1.5.6 Wie Sie Ideen für die nächsten Schritte sammeln, entweder für ähnliche Probleme, weitere Lösungswege oder offene Fragen¶

Ich habe erfolgreich [Beschreibung des gelösten Problems] mit [verwendeter Algorithmus/Methode] mit Hilfe Deines Python Codes umgesetzt.

Was könnte ich als Nächstes tun, um mein Verständnis zu vertiefen oder die Lösung zu erweitern? Ich bin interessiert an:

- Ähnlichen, aber komplexeren Problemen, die ich versuchen könnte
- Alternative Lösungsansätze für das gleiche Problem
- Mögliche Optimierungen oder Erweiterungen
- Interessante offene Forschungsfragen in diesem Bereich
- Praktische Anwendungen dieses Algorithmus in der realen Welt

1.6 Demo: Einfache Algorithmenimplementierung mit einem LLM¶

Hier möchte ich Ihnen demonstrieren, wie man ein LLM zur Lösung eines konkreten Problems einsetzen kann. Konkret verwende ich dafür Claude 3.7 Sonnet, aber man würde auch mit ChatGPT (derzeit o3-mini-high) oder Gemini (derzeit 2.0 Flash) ähnliche Outputs erhalten.

Ich möchte gerne das automatische Gruppieren von zweidimensionalen Daten mit Hilfe von Hierarchischem Clustering besser verstehen. Bitte erkläre kurz:
- Die grundlegende Idee und den Zweck dieses Algorithmus
- Die mathematischen Grundlagen und Voraussetzungen
- Die wichtigsten Anwendungsfälle
- Die Stärken und Einschränkungen
- Die Komplexität (Zeit und Speicher)
- Wie sich dieser Algorithmus von ähnlichen Ansätzen unterscheidet

Bitte erkläre die Konzepte so, dass sie ich als Universitätsstsudent im zweiten Jahr mit grundlegenden Mathematikkenntnissen und einem breit gefächerten naturwissenschaftlichen Basishintergrund gut verstehen kann.

Antwort von Claude 3.7 Sonnet: Hierarchisches Clustering für zweidimensionale Daten¶

Grundlegende Idee und Zweck¶

Hierarchisches Clustering ist ein Algorithmus, der Datenpunkte in Gruppen (Cluster) organisiert, wobei die Ähnlichkeit zwischen Punkten innerhalb eines Clusters maximiert und zwischen verschiedenen Clustern minimiert wird. Anders als bei anderen Clustering-Verfahren entsteht eine Baumstruktur (Dendrogramm), die verschiedene Gruppierungsebenen zeigt.

Es gibt zwei Hauptansätze:

Agglomerativ (bottom-up): Startet mit einzelnen Punkten als eigene Cluster und verschmilzt schrittweise die ähnlichsten.
Divisiv (top-down): Beginnt mit allen Punkten in einem Cluster und teilt diesen rekursiv.

Mathematische Grundlagen¶

Distanzmatrix: Zu Beginn wird die Ähnlichkeit zwischen allen Datenpunkten berechnet. Für zweidimensionale Daten ist die euklidische Distanz üblich:
d(p, q) = √[(x₂ – x₁)² + (y₂ – y₁)²]
Linkage-Kriterien: Diese bestimmen, wie die Distanz zwischen Clustern berechnet wird:
- Single-Linkage: kürzeste Distanz zwischen zwei Punkten aus verschiedenen Clustern
- Complete-Linkage: größte Distanz zwischen zwei Punkten
- Average-Linkage: Durchschnittsdistanz zwischen allen Punktpaaren
- Ward-Methode: minimiert die Varianz innerhalb der Cluster
Dendrogramm: Die Baumstruktur visualisiert, in welcher Reihenfolge und bei welchen Distanzen Cluster zusammengeführt wurden.

Wichtigste Anwendungsfälle¶

Bioinformatik: Gruppierung von Genen mit ähnlichen Expressionsmustern
Marktforschung: Kundensegmentierung nach Kaufverhalten
Bilderkennung: Identifikation ähnlicher Bildbereiche
Geographie: Identifikation ähnlicher Regionen basierend auf Merkmalen
Dokumentenanalyse: Gruppierung von Texten mit ähnlichem Inhalt

Stärken und Einschränkungen¶

Stärken:¶

Benötigt keine Vorgabe der Cluster-Anzahl (im Gegensatz zu k-Means)
Liefert eine interpretierbare hierarchische Struktur
Funktioniert mit beliebigen Distanzmaßen
Kann Cluster unterschiedlicher Größe und Form erkennen

Einschränkungen:¶

Hoher Rechenaufwand für große Datensätze
Einmal getroffene Entscheidungen sind nicht revidierbar
Anfällig für Rauschen und Ausreißer
Die Wahl des Linkage-Kriteriums beeinflusst stark das Ergebnis
Keine klare Regel, wo der Baum “geschnitten” werden sollte

Komplexität¶

Zeitkomplexität: O(n³) für naive Implementierungen, wobei n die Anzahl der Datenpunkte ist. Optimierte Versionen erreichen O(n² log n).
Speicherkomplexität: O(n²) für die Distanzmatrix.

Diese hohe Komplexität macht den Algorithmus für sehr große Datensätze (>10.000 Punkte) unpraktisch.

Unterschiede zu ähnlichen Ansätzen¶

Im Vergleich zu k-Means:

K-Means benötigt die Vorgabe der Cluster-Anzahl, hierarchisches Clustering nicht
K-Means findet nur kugelförmige Cluster, hierarchisches Clustering erkennt beliebige Formen
K-Means ist schneller (O(k·n·t) wobei k = Anzahl Cluster, t = Iterationen)

Im Vergleich zu DBSCAN:

DBSCAN erkennt Cluster basierend auf Dichte, nicht auf hierarchischer Struktur
DBSCAN kann Rauschen explizit identifizieren
DBSCAN ist besser für große Datensätze geeignet (O(n log n))

Im Vergleich zu Gaussian Mixture Models:

GMMs sind probabilistisch, hierarchisches Clustering deterministisch
GMMs können überlappende Cluster modellieren
GMMs treffen Annahmen über die Verteilung der Daten (Normalverteilung)

Zusammenfassend ist hierarchisches Clustering besonders nützlich, wenn Sie die Beziehungen zwischen Datenpunkten auf verschiedenen Ähnlichkeitsebenen verstehen möchten und keine Vorannahmen über die Anzahl der Cluster treffen können oder wollen.

Ich möchte Hierarchisches Agglomeratives Clustering implementieren, um folgendes Problem zu lösen:
Die automatische Gruppierung von 2D-Datenpunkten

Die Eingabe hat folgendes Format:
Eine Liste oder ein Array von N 2D-Punkten, wobei der Input-Parameter N=10000 sein oder einen geeigneten Wert haben soll. Der Code soll zu Demonstrationszwecken geeignete synthetische Daten erzeugen und verwenden. 

Die Ausgabe sollte folgendes Format haben:
Visualisierung der Datenpunkte und Einfärben nach zugeordneten Clustern.
Außerdem grafische Darstellung des zugehörigen Dendrogramms

Bitte schreibe Python-Code für eine einfache Implementierung mit:
- Ausführlichen Kommentaren zur Erklärung der einzelnen Schritte
- Klarer Struktur und verständlichen Variablennamen
- Verwendung geeigneter Python-Bibliotheken wie NumPy oder scikit-learn

In [3]:

# Antwort von Claude 3.7 Sonnet:

# Hierarchisches Agglomeratives Clustering von 2D-Daten
# ---------------------------------------------------------

import numpy as np
import matplotlib.pyplot as plt
from sklearn.datasets import make_blobs
from scipy.cluster.hierarchy import dendrogram, linkage
from sklearn.cluster import AgglomerativeClustering
import time

# -----------------------------------------------
# 1. Generierung synthetischer 2D-Daten für das Clustering
# -----------------------------------------------

def generate_synthetic_data(n_samples=10000, n_centers=6, random_state=42):
    """
    Erzeugt synthetische 2D-Datenpunkte mit mehreren Clustern.
    
    Parameter:
    - n_samples: Anzahl der zu generierenden Datenpunkte
    - n_centers: Anzahl der Cluster-Zentren
    - random_state: Seed für die Reproduzierbarkeit
    
    Rückgabe:
    - X: Array der Datenpunkte (n_samples, 2)
    - y_true: Wahre Cluster-Labels
    """
    print(f"Erzeuge {n_samples} synthetische Datenpunkte mit {n_centers} Clustern...")
    
    # make_blobs erzeugt gaußförmige Cluster
    X, y_true = make_blobs(
        n_samples=n_samples,
        centers=n_centers,
        cluster_std=[1.0, 1.5, 0.8, 1.2, 1.3, 0.9],  # Unterschiedliche Streuungen
        random_state=random_state
    )
    
    # Optional: Skalieren und Verschieben einiger Cluster für interessantere Muster
    X[:n_samples//3, 0] = X[:n_samples//3, 0] * 1.5  # Erste 1/3 der Punkte in x-Richtung strecken
    X[n_samples//3:2*n_samples//3, 1] = X[n_samples//3:2*n_samples//3, 1] * 0.8  # Mittlere 1/3 in y-Richtung stauchen
    
    return X, y_true

# -----------------------------------------------
# 2. Durchführung des hierarchischen Clusterings
# -----------------------------------------------

def perform_hierarchical_clustering(X, n_clusters=6, linkage_method='ward'):
    """
    Führt hierarchisches agglomeratives Clustering auf den Daten durch.
    
    Parameter:
    - X: 2D-Datenarray der Form (n_samples, 2)
    - n_clusters: Anzahl der zu bildenden Cluster
    - linkage_method: Methode für die Berechnung der Cluster-Distanzen
      ('ward', 'complete', 'average', 'single')
    
    Rückgabe:
    - labels: Cluster-Labels für jeden Datenpunkt
    - Z: Hierarchische Clustering-Matrix (für Dendrogramm)
    """
    print(f"Starte hierarchisches Clustering mit {linkage_method}-Linkage...")
    start_time = time.time()
    
    # Hierarchisches Clustering mit scikit-learn
    model = AgglomerativeClustering(
        n_clusters=n_clusters,
        linkage=linkage_method,
    )
    
    # Berechne die Cluster-Zuordnungen
    labels = model.fit_predict(X)
    
    # Berechne die Linkage-Matrix für das Dendrogramm
    # Hinweis: Dies ist rechenintensiv für große Datensätze
    Z = linkage(X, method=linkage_method)
    
    elapsed_time = time.time() - start_time
    print(f"Clustering abgeschlossen in {elapsed_time:.2f} Sekunden")
    
    return labels, Z

# -----------------------------------------------
# 3. Visualisierung der Ergebnisse
# -----------------------------------------------

def plot_clusters(X, labels, title="Hierarchisches Clustering - Ergebnis"):
    """
    Visualisiert die Datenpunkte, eingefärbt nach Cluster-Zugehörigkeit.
    
    Parameter:
    - X: 2D-Datenarray der Form (n_samples, 2)
    - labels: Cluster-Labels für jeden Datenpunkt
    - title: Titel für den Plot
    """
    plt.figure(figsize=(10, 8))
    
    # Jeder Cluster bekommt eine andere Farbe
    unique_labels = np.unique(labels)
    colors = plt.cm.rainbow(np.linspace(0, 1, len(unique_labels)))
    
    # Plotte jeden Cluster in seiner eigenen Farbe
    for label, color in zip(unique_labels, colors):
        mask = labels == label
        plt.scatter(
            X[mask, 0],
            X[mask, 1],
            c=[color],
            s=30,  # Punktgröße
            alpha=0.7,  # Transparenz
            label=f'Cluster {label}'
        )
    
    plt.title(title, fontsize=14)
    plt.xlabel("X-Koordinate", fontsize=12)
    plt.ylabel("Y-Koordinate", fontsize=12)
    plt.legend(loc='upper right')
    plt.grid(True, linestyle='--', alpha=0.7)
    plt.tight_layout()

def plot_dendrogram(Z, title="Hierarchisches Clustering - Dendrogramm", max_samples=100):
    """
    Visualisiert das Dendrogramm des hierarchischen Clusterings.
    
    Parameter:
    - Z: Linkage-Matrix aus der hierarchischen Clustering-Berechnung
    - title: Titel für den Plot
    - max_samples: Maximale Anzahl der im Dendrogramm gezeigten Samples (für Übersichtlichkeit)
    """
    plt.figure(figsize=(14, 8))
    
    # Wenn es zu viele Datenpunkte sind, begrenzen wir die Anzeige
    if len(Z) + 1 > max_samples:
        plt.title(f"{title} (gekürzt auf {max_samples} Samples)", fontsize=14)
        truncate_mode = 'lastp'
    else:
        plt.title(title, fontsize=14)
        truncate_mode = None
    
    # Erzeuge das Dendrogramm
    dendrogram(
        Z,
        truncate_mode=truncate_mode,
        p=max_samples,
        leaf_font_size=10,
        orientation='top',
    )
    
    plt.xlabel("Datenpunkt-Index oder Cluster", fontsize=12)
    plt.ylabel("Distanz", fontsize=12)
    plt.grid(True, linestyle='--', alpha=0.7)
    plt.tight_layout()

# -----------------------------------------------
# 4. Hauptfunktion
# -----------------------------------------------

def main():
    """
    Hauptfunktion: Führt den gesamten Clustering-Prozess durch.
    """
    # Parameter für die Datengenerierung und das Clustering
    n_samples = 5000  # 10000 kann für manche Systeme zu rechenintensiv sein
    n_clusters = 6
    linkage_method = 'ward'  # Alternativen: 'complete', 'average', 'single'
    
    # 1. Generiere synthetische Daten
    X, y_true = generate_synthetic_data(n_samples=n_samples, n_centers=n_clusters)
    
    # 2. Führe hierarchisches Clustering durch
    labels, Z = perform_hierarchical_clustering(X, n_clusters=n_clusters, linkage_method=linkage_method)
    
    # 3. Visualisiere die Ergebnisse
    plot_clusters(X, labels, title=f"Hierarchisches Clustering ({linkage_method}) - {n_clusters} Cluster")
    plot_dendrogram(Z, title=f"Dendrogramm ({linkage_method}-Linkage)")
    
    # 4. Zum Vergleich: Visualisiere die wahren Cluster
    plot_clusters(X, y_true, title="Wahre Cluster der synthetischen Daten")
    
    # 5. Zeige alle Plots
    plt.show()

# -----------------------------------------------
# Programmausführung
# -----------------------------------------------

if __name__ == "__main__":
    main()
    print("Programm beendet.")

Erzeuge 5000 synthetische Datenpunkte mit 6 Clustern...
Starte hierarchisches Clustering mit ward-Linkage...
Clustering abgeschlossen in 0.68 Sekunden