Assignment Chef icon Assignment Chef
All German tutorials

Programming lesson

Python-Strategien für das Gefangenendilemma: Spielsimulation und Auswertung mit iterierten Spielen

Lerne, wie man in Python verschiedene Strategien für das wiederholte Gefangenendilemma implementiert und gegeneinander antreten lässt – inklusive eigener Strategie und Analyse der Ergebnisse.

Gefangenendilemma Python Strategien simulieren Python Spieltheorie COP4521 Assignment Python Strategie implementieren wiederholtes Gefangenendilemma Python Programmieraufgabe KI Lernstrategie Spielsimulation Python Python Projekt Studium Algorithmen Spieltheorie Python Turnier Simulation eigene Strategie entwickeln Python Code Beispiel Spieltheorie Studium Python für Anfänger

Einführung in das Gefangenendilemma und die Aufgabenstellung

Das Gefangenendilemma ist ein klassisches Spiel aus der Spieltheorie, das zeigt, wie individuelle und kollektive Rationalität kollidieren können. In der aktuellen Assignment-Chef-Aufgabe (COP4521) geht es darum, dieses Spiel in Python zu simulieren und verschiedene Strategien gegeneinander antreten zu lassen. Die Grundregeln sind einfach: Zwei Spieler wählen gleichzeitig zwischen Kooperation und Defektion. Die Auszahlungen sind:

  • Beide kooperieren: jeder 3 Münzen
  • Einer kooperiert, einer defektiert: Defektor 5, Kooperator 0
  • Beide defektieren: jeder 1 Münze

Ziel ist es, über viele Runden hinweg möglichst viele Münzen zu sammeln. Dazu implementierst du neun vorgegebene Strategien und entwickelst eine eigene zehnte. Anschließend simulierst du Turniere zwischen allen Strategien und wertest die Gesamtpunktzahlen aus. Klingt nach einer spannenden Herausforderung, oder? Genau wie bei der KI-Entwicklung in modernen Apps oder Spielen geht es darum, Muster zu erkennen und die beste Reaktion zu wählen.

Die neun vorgegebenen Strategien im Detail

alwaysCooperate & alwaysDefect

Diese beiden Basisstrategien sind einfach: alwaysCooperate wählt immer Kooperation, alwaysDefect immer Defektion. Sie dienen als Referenz für die Bewertung komplexerer Strategien.

probeAndLock

Diese Strategie sondiert erst einmal: Die ersten 20 Runden wird defektiert, die nächsten 20 kooperiert. Danach vergleicht sie die Gesamtbelohnungen beider Phasen. War Defektion profitabler, wird für den Rest des Spiels defektiert, sonst kooperiert. Beispielcode:

defect = 0
cooperate = 1

def strategy_probeAndLock(myHistory, oppHistory):
    if len(myHistory) < 20:
        return defect
    elif len(myHistory) < 40:
        return cooperate
    else:
        reward1 = rangeReward(0, 20, myHistory, oppHistory)
        reward2 = rangeReward(20, 40, myHistory, oppHistory)
        if reward1 > reward2:
            return defect
        else:
            return cooperate

continuousProbe

Hier wird in Runde 1 defektiert, in Runde 2 kooperiert. Ab Runde 3 berechnet die Strategie den durchschnittlichen Gewinn pro Aktion und wählt die Aktion mit dem höheren Durchschnitt. Das erinnert an Machine Learning-Algorithmen, die aus Erfahrungen lernen.

defectUntilCooperate

Diese Strategie defektiert so lange, bis der Gegner das erste Mal kooperiert. Danach kooperiert sie für immer. Eine freundliche, aber vorsichtige Taktik.

opponentCooperatePercentage

Hier wird basierend auf der bisherigen Kooperationsrate des Gegners entschieden. Liegt die Rate über einem Schwellwert (10%, 50% oder 90%), wird kooperiert, sonst defektiert. Du implementierst drei Varianten: opponentCooperate10Percentage, opponentCooperate50Percentage und opponentCooperate90Percentage.

random50

Eine Zufallsstrategie: mit 50% Wahrscheinlichkeit wird kooperiert oder defektiert. So simulierst du unberechenbare Gegner.

Eigene Strategie entwickeln – der kreative Teil

Nun darfst du deine eigene optimierte Strategie entwerfen. Überlege dir, welche der neun Strategien besonders stark sind und wie du sie schlagen kannst. Ein guter Ansatz ist, die Spielgeschichte zu analysieren und adaptiv zu reagieren. Vielleicht kombinierst du Elemente aus continuousProbe und probeAndLock? Oder du setzt auf Nachgiebigkeit gegenüber Kooperateuren, aber Vergeltung bei Defektion? In der Künstlichen Intelligenz werden solche Lernstrategien auch in autonomen Systemen eingesetzt, z.B. in Robotern oder Spiel-KIs. Lass dich von aktuellen Trends wie Reinforcement Learning inspirieren.

Implementierung der Spielsimulation

Dein Python-Programm soll zwei optionale Kommandozeilenargumente akzeptieren: num_of_iterations (Anzahl der Runden pro Spiel, Standard 2000) und num_of_strategies (Anzahl der zu bewertenden Strategien, Standard 8). Beispielaufrufe aus der Aufgabenstellung:

python3 sample_assignment1.py 4 2
# Ausgabe: alwaysCooperate: 0 alwaysDefect: 20

python3 sample_assignment1.py 4 3
# Ausgabe: alwaysCooperate: 0 alwaysDefect: 24 probeAndLock: 24

python3 sample_assignment1.py 4 8
# Ausgabe: alwaysCooperate: 39 alwaysDefect: 48 probeAndLock: 48 continuousProbe: 52 defectUntilCooperate: 40 opponentCooperate10Percentage: 40 opponentCooperate50Percentage: 42 opponentCooperate90Percentage: 42

python3 sample_assignment1.py
# (Standard: 2000 Runden, 8 Strategien) liefert z.B.:
# alwaysCooperate: 24051 alwaysDefect: 22084 probeAndLock: 29792 ...

Die Logik: Für jede Strategie wird gegen jede andere (und gegen sich selbst?) ein Spiel mit der angegebenen Rundenzahl simuliert. Die Gesamtpunktzahl jeder Strategie über alle Spiele wird am Ende ausgegeben. Achte darauf, dass deine Funktionen exakt die geforderten Namen haben (strategy_alwaysCooperate, etc.) und die History-Listen als Parameter erhalten.

Hilfreiche Tipps für die Umsetzung

  • Modularität: Schreibe Hilfsfunktionen wie rangeReward, um die Auszahlungen für einen bestimmten Bereich zu berechnen.
  • Testen: Beginne mit wenigen Runden (z.B. 4) und wenigen Strategien (z.B. 2-3), um die Korrektheit zu prüfen.
  • Dokumentation: Füge einen Header mit deinem Namen und der Aufgabenbeschreibung ein.
  • Eigene Strategie: Nenne sie strategy_meineStrategie (frei wählbar) und dokumentiere, warum sie effektiv sein könnte.

Auswertung und Erkenntnisse

Nach der Simulation kannst du analysieren, welche Strategie im Durchschnitt am besten abschneidet. Oft zeigt sich, dass kooperative Strategien langfristig besser sind, besonders wenn sie Vergebung und Vergeltung kombinieren. Dieses Prinzip findet sich auch in sozialen Netzwerken oder Online-Communities wieder: Wer fair spielt, hat langfristig mehr Erfolg. Die Aufgabe ist eine tolle Gelegenheit, algorithmisches Denken und Python-Programmierung zu üben – und vielleicht die beste Strategie zu finden, die alle anderen schlägt!

Fazit

Das wiederholte Gefangenendilemma ist nicht nur ein theoretisches Modell, sondern hat praktische Anwendungen in Wirtschaft, Politik und KI. Mit dieser Python-Aufgabe lernst du, Strategien zu implementieren, zu simulieren und zu bewerten. Viel Erfolg beim Tüfteln an deiner eigenen Strategie – wer weiß, vielleicht entwickelst du die ultimative Taktik, die in Turnieren unschlagbar ist!