Conways livvspil i Python

Endnu et agentbaseret simuleringseksempel fra min side! I denne artikel vil jeg implementere Conways game of life i Python ved hjælp af den agentbaserede modelleringsramme abm_framework . Du kan finde rammen ved at klikke på linket nedenfor.

Conways game of life er en god introduktion til agent-baseret modellering, og det bliver også undervist på universiteter af netop denne grund. Det er også en god introduktion til programmering i Python generelt.

Jeg har for nylig delt en række eksempler på, hvordan du kan implementere abm_framework i Python til agentbaseret modellering. Du kan finde rammerne her:

Det følgende afsnit beskriver reglerne for Conways livsspil. Derefter implementerer jeg livets spil i Python.

Regler for Conways livsspil

Begrebsmæssigt består livets spil af et gitter. Hvert gitter i cellen er befolket af en agent. Agenten er enten død eller levende. Startende fra en indledende tilstand opdaterer spillet om livet iteration efter iteration. Under hver iteration gælder følgende regler:

  • Hvis en agent er i live, og dens naboceller indeholder 2 eller 3 levende agenser, overlever agenten indtil næste runde. Den er så levende i næste runde. Ellers dør agenten og er død i næste runde.
  • Hvis en død agent har præcis 3 levende agenter i sit nabolag, bliver agenten genfødt og er i live i næste runde.

Disse regler er tilstrækkelige til at modellere Conways livsspil. Starttilstanden, defineret af agenterne døde eller levende i begyndelsen af ​​simuleringen, er det eneste input, som simuleringen skal køre. I denne artikel kører jeg tre versioner af modellen. De to første versioner har en tilfældig initial fordeling af levende agensceller. Den tredje version har et specifikt indledende frømønster af levende midler. I den første og tredje version er gitteret uendeligt. Det betyder, at hvis du forlader gitteret til venstre, kommer du ind i gitteret i højre side, og hvis du forlader gitteret øverst, kommer du ind i gitteret i bunden. Den anden version anvender et gitter med grænser, dvs. et gitter, der ikke er uendeligt.

Implementering af livets spil i Python

Ved at bruge abm_framework i Python (stillet til rådighed af mig på Github) implementerer jeg modellen i Python. Jeg laver et simuleringsgitter med 100 celler. Starttilstanden (benævnt frø) består af 50 levende midler, der er tilfældigt fordelt over nettet. Koden nedenfor implementerer den endeløse gitterversion af simuleringsmodellen .

__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")

I en anden version af modellen implementerede jeg et gitter, der ikke er uendeligt. Den eneste justering i koden er i Environment constructor-kaldet, der indstiller uendeligt gitter-argument til False i stedet for True.

Animation af Conways livsspil

Nedenfor er animationen af ​​Conways livsspil i Python. Den første animation repræsenterer modellen med et endeløst gitter.

Den anden animation, der vises nedenfor, repræsenterer modellen med et afgrænset gitter.

Til sidst kører jeg et scenarie, hvor jeg definerede en specifik initial modeltilstand. Animationen kan ses nedenfor og repræsenterer et endeløst gitter.

Du kan finde forskellige eksempler på livets spil ved at lave en simpel Google-forespørgsel. Der er også forskellige værktøjer til rådighed til at specificere dit eget frø og køre modellen trin for trin.

Afsluttende bemærkninger

I denne artikel implementerede jeg Conways game of life i Python ved hjælp af en ramme, som jeg kaldte abm_framework . Jeg kørte tre scenarier, der adskilte mig i definition af gittergrænsen (endeløs vs. ikke endeløs) og indledende frø (tilfældig indledende frø vs. specifik indledende frø). Hvis du ønsker at lære agentbaseret modellering, kan implementering af livets spil i Python være et godt første skridt for dig.

Leave a Reply

Skriv et svar

Din e-mailadresse vil ikke blive publiceret. Krævede felter er markeret med *

This site uses Akismet to reduce spam. Learn how your comment data is processed.

Close

Meta