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:
- Link : Mund-til-mund agent-baseret salgsmodel
- Link : Agent-baseret adskillelsesmodel (Python)
- Link : Agent-baseret SIR-model Python-eksempel
- Link : Agent-baseret modellering i Python
- Link : Agentbaseret simulering i Python
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.
Industriingeniør som gerne beskæftiger sig med optimering, simulation og matematisk modellering i R, SQL, VBA og Python
Leave a Reply