Conways Spiel des Lebens in Python

Ein weiteres agentenbasiertes Simulationsbeispiel von meiner Seite! In diesem Artikel werde ich Conways Spiel des Lebens in Python implementieren, indem ich das agentenbasierte Modellierungsframework abm_framework verwende . Sie finden das Framework, indem Sie auf den unten stehenden Link klicken.

Link : https://github.com/LinnartSF/abm_framework

Conways Spiel des Lebens ist ein guter Einstieg in die agentenbasierte Modellierung und wird genau aus diesem Grund auch an Universitäten gelehrt. Es ist auch eine gute Einführung in die Programmierung in Python im Allgemeinen.

Ich habe kürzlich eine Reihe von Beispielen dafür bereitgestellt, wie Sie das abm_framework in Python für die agentenbasierte Modellierung implementieren können. Den Rahmen finden Sie hier:

Link : Verkaufsmodell auf Basis von Mundpropaganda
Link : Agentenbasiertes Segregationsmodell (Python)
Link : Python-Beispiel für ein agentenbasiertes SIR-Modell
Link : Agentenbasierte Modellierung in Python
Link : Agentenbasierte Simulation in Python

Der folgende Abschnitt beschreibt die Regeln von Conways Spiel des Lebens. Danach implementiere ich das Spiel des Lebens in Python.

Regeln von Conways Spiel des Lebens

Konzeptionell besteht das Spiel des Lebens aus einem Raster. Jedes Gitter in der Zelle wird von einem Agenten bevölkert. Der Agent ist entweder tot oder lebendig. Ausgehend von einem Anfangszustand aktualisiert das Spiel des Lebens Iteration um Iteration. Während jeder Iteration gelten die folgenden Regeln:

Wenn ein Agent lebt und seine Nachbarzellen 2 oder 3 lebende Agenten enthalten, überlebt der Agent bis zur nächsten Runde. Es lebt dann in der nächsten Runde. Andernfalls stirbt der Agent und ist in der nächsten Runde tot.
Wenn ein toter Agent genau 3 lebende Agenten in seiner Nachbarschaft hat, wird der Agent wiedergeboren und lebt in der nächsten Runde.

Diese Regeln reichen aus, um Conways Spiel des Lebens zu modellieren. Der Anfangszustand, definiert durch die toten oder lebendigen Agenten zu Beginn der Simulation, ist die einzige Eingabe, die die Simulation ausführen muss. In diesem Artikel verwende ich drei Versionen des Modells. Die ersten beiden Versionen haben eine zufällige anfängliche Verteilung von lebenden Wirkstoffzellen. Die dritte Version hat ein spezifisches anfängliches Saatmuster von lebenden Agenten. In der ersten und dritten Version ist das Raster endlos. Das bedeutet, wenn Sie das Raster links verlassen, betreten Sie das Raster auf der rechten Seite, und wenn Sie das Raster oben verlassen, betreten Sie das Raster unten. Die zweite Version wendet ein Raster mit Begrenzungen an, dh ein Raster, das nicht endlos ist.

Implementierung des Spiels des Lebens in Python

Mit dem abm_framework in Python (von mir auf Github bereitgestellt) implementiere ich das Modell in Python. Ich erstelle ein Simulationsgitter mit 100 Zellen. Der Anfangszustand (als Seed bezeichnet) besteht aus 50 lebenden Agenten, die zufällig über das Gitter verteilt sind. Der folgende Code implementiert die endlose Grid-Version des Simulationsmodells .

__author__ = "Linnart Felkl"
__email__ = "LinnartSF@gmail.com"

if __name__ == "__main__":

    print("demo starts")

    import sys
    from pathlib import Path
    file = Path(__file__).resolve()
    parent, root = file.parent, file.parents[1]
    sys.path.append(str(root))

    # remove the current file's directory from sys.path, unless already removed
    try:
        sys.path.remove(str(parent))
    except ValueError:
        pass

    import data
    import stats
    import config
    import framework
    import random
    import animation

    # setup database manager and connection
    db = data.Database("sqlite3", config.path_databasefile)
    db_manager = data.Manager(db)
    
    # create an empty environment
    env = framework.Environment(1, True, 10, 10, db_manager) # Environment constructor implicitly resets environment table in database

    # create initial population of healthy humans
    attrs = ["life_t0","life_t1"]
    datatypes = ["INTEGER","INTEGER"]
    pops = framework.Populations(amount = 1, env = env, db_manager = db_manager, attributes = attrs, datatypes = datatypes)
    pops.add_population(name = "units", 
                        size = 100, 
                        attributes = attrs, 
                        datatypes = datatypes, 
                        initialvals = [0, 0]
                        )
   
    # set seed of simulation (number of agents alive and their pattern)
    agents = pops.get_agents()
    random.shuffle(agents)
    for i in range(50):
        agents[i].set_attr_value("life_t0",1)

    # setup simulation
    sim = framework.Simulation(50)

    # make sure that environment and agents tables in database are setup at this time
    pops.write_env_to_db(sim.Iteration)
    pops.write_agents_to_db(sim.Iteration)

    # execute simulation run; with centralized simulation control
    while sim.run():
        
        for agent in agents:

            # get that agents neighbourhood
            neighbours = env.get_neighbourhood(agent, mode = "moore", radius = 1)

            _neighbours_alive = 0
            for neighbour in neighbours:
                
                if neighbour.get_attr_value("life_t0") == 1: 
                    _neighbours_alive  += 1

            if agent.get_attr_value("life_t0") == 1: 

                if _neighbours_alive == 2 or _neighbours_alive == 3: 
                    
                    agent.set_attr_value("life_t1", 1)

                else:

                    agent.set_attr_value("life_t1", 0)

            elif _neighbours_alive == 3:

                agent.set_attr_value("life_t1", 1)

            else:

                agent.set_attr_value("life_t1", 0)
                
        # update results in database, for agents and for environment
        pops.write_agents_to_db(sim.Iteration)
        pops.write_density_to_db(sim.Iteration)

        # update attributes for next round
        for agent in agents:

            agent.set_attr_value("life_t0", agent.get_attr_value("life_t1"))
    
    # get dataframes with simulation results
    density_df = db_manager.get_densitydf()

    # visualize simulation data
    stats.set_fontsizes(8,10,12)

    animation.animate_density(
        df = density_df,
        filename = "gol_randomendless",
        attr = "life_t1",
        defaultsize = 50,
        color = "black",
        tpf = 0.30
    )

    # end program
    db.close()
    print("demo ends")

In einer zweiten Version des Modells habe ich ein Raster implementiert, das nicht endlos ist. Die einzige Anpassung im Code besteht im Environment-Konstruktoraufruf, bei dem das endlose Grid-Argument auf False statt auf True gesetzt wird.

Animation von Conways Spiel des Lebens

Unten ist die Animation von Conways Spiel des Lebens in Python. Die erste Animation stellt das Modell mit einem Endlosraster dar.

Die zweite Animation, die unten angezeigt wird, stellt das Modell mit einem begrenzten Gitter dar.

Zuletzt führe ich ein Szenario aus, in dem ich einen bestimmten anfänglichen Modellzustand definiert habe. Die Animation ist unten zu sehen und stellt ein endloses Gitter dar.

Sie können verschiedene Beispiele für Spiele des Lebens finden, indem Sie eine einfache Google-Abfrage durchführen. Es stehen auch verschiedene Tools zur Verfügung, mit denen Sie Ihren eigenen Startwert angeben und das Modell Schritt für Schritt ausführen können.

Abschließende Bemerkungen

In diesem Artikel habe ich Conways Spiel des Lebens in Python implementiert, indem ich ein Framework verwendet habe, das ich abm_framework genannt habe . Ich habe drei Szenarien ausgeführt, die sich in der Gittergrenzendefinition (endlos vs. nicht endlos) und dem anfänglichen Seed (zufälliger anfänglicher Seed vs. spezifischer anfänglicher Seed) unterscheiden. Wenn Sie agentenbasierte Modellierung lernen möchten, könnte die Implementierung des Spiels des Lebens in Python ein guter erster Schritt für Sie sein.