Ich habe zuvor den ersten Sprint eines agentenbasierten Modellierungs- und Simulationsframeworks vorgestellt, an dem ich arbeite. In diesem Blogbeitrag implementiere ich ein agentenbasiertes Segregationsmodell in Python. Ähnliche Modelle, mit einigen Anpassungen und Abweichungen, werden zB zum Verständnis sozialer Segregation verwendet. Das Hauptziel dieses Blogbeitrags ist es, eine weitere Demonstration der agentenbasierten Modellierung und Simulation in Python zu liefern. Das verwendete Framework ist das abm_framework in Python.
Framework für agentenbasierte Modellierung in Python
Ich entwickle ein Segregationsmodell als weiteres Anwendungsbeispiel des agentenbasierten Modellierungsframeworks, an dem ich in Python arbeite. Sie können das Framework hier auf GitHub herunterladen:
Das GitHub-Repository enthält einen Demo-Ordner. Beispielanwendungen finden Sie hier. Zum Zeitpunkt der Veröffentlichung dieses Artikels sind noch nicht so viele Demomodelle verfügbar. Ich werde in den kommenden Wochen weitere Demomodelle hinzufügen, und die bestehenden Module werden erweitert, um ein breiteres Spektrum an agentenbasierten Modellierungsanwendungen zu unterstützen.
Im abm_framework sind die wichtigsten Module die folgenden:
- framework.py zur Modellierung von zB Agenten, Agentenpopulationen und der Simulationsumgebung
- data.py zum Verwalten von Datenbankoperationen zum Schreiben und Lesen von Simulationsergebnissen
- stats.py zum Plotten von Simulationsergebnissen (auch unabhängig von der Ausführung des Simulationslaufs)
- config.py , um zB relevante Pfade anzugeben, zB den Datenbankdateipfad
- animation.py zum Animieren von Simulationsergebnissen
Die folgende Abbildung fasst den Inhalt des abm_framework- Repositorys auf GitHub zusammen.
Die Datei model.py ist das Simulationsmodell selbst. Bei dem im vorliegenden Artikel beschriebenen Beispiel habe ich die Datei zB segregation.py genannt . Die Modelldatei implementiert ein bestimmtes Modell. Das Framework (mit allen oben beschriebenen Modulen) dient als Werkzeugkasten. Mit anderen Worten soll das Framework die Implementierung eines bestimmten Simulationsmodells erleichtern .
Konzeptionelle Beschreibung des agentenbasierten Segregationsmodells
Da ich das von mir in früheren Artikeln vorgestellte agentenbasierte Modellierungsframework verwende, entwickle ich ein gitterbasiertes agentenbasiertes Simulationsmodell . Das heißt, ich weise einem Gitter einen Agenten zu. Agenten haben somit Standorte. Agenten haben auch eine Nachbarschaft mit einem bestimmten Radius. Interaktionen zwischen Agenten finden innerhalb dieser Nachbarschaft statt. Die folgende Abbildung aus meinem vorherigen Beitrag zur agentenbasierten SIR-Modellimplementierung in Python veranschaulicht dieses Konzept.
In diesem beispielhaften agentenbasierten Segregationsmodell erleichtere ich Segregationsmechanismen, indem ich das folgende Flussdiagramm implementiere:
Für jede Iteration wähle ich zufällig einen Agenten aus. Dann berechne ich die Nutzenauswirkung in der aktuellen Zelle des Agenten. Diese Nutzenauswirkung wird durch Iteration über alle benachbarten Agenten berechnet. Wenn der Nachbar vom „gleichen Typ“ ist wie der Agent selbst, wird der Nutzeneffekt erhöht (positiver Einfluss). Wenn der Nachbar nicht „gleicher Art“ ist, wird die Nutzenwirkung verringert (negative Auswirkung).
Als nächstes wird eine zufällige freie Zelle im Raster ausgewählt und die hypothetische Auswirkung auf den Nutzen in dieser Zelle berechnet. Für diese Berechnung gilt dieselbe Logik wie oben beschrieben. Wenn die hypothetische Nutzenauswirkung in dieser Zelle positiv ist, verlagert sich der Agent an diesen Ort und aktualisiert seinen Nutzen erneut. Wenn nicht, wird eine andere freie Zelle ausgewählt und derselbe Test gilt. Der Vorgang wiederholt sich bis zu einer maximalen Suchgrenze, dh einer vorgegebenen maximalen Anzahl von Wiederholungen.
Agentenbasierte Segregationsmodellimplementierung in Python
Unten ist der Code, der das agentenbasierte Segregationsmodell implementiert.
__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, 20, 20, db_manager)
# create initial population of healthy humans
attrs = ["utility","type"]
datatypes = ["REAL","TEXT"]
pops = framework.Populations(amount = 2, env = env, db_manager = db_manager, attributes = attrs, datatypes = datatypes)
pops.add_population(name = "natives",
size = 50,
attributes = attrs,
datatypes = datatypes,
initialvals = [100, "native"]
)
pops.add_population(name = "immigrants",
size = 50,
attributes = attrs,
datatypes = datatypes,
initialvals = [100, "immigrant"]
)
# setup simulation
sim = framework.Simulation(1000)
# make sure that environment and agents tables in database are set
pops.write_env_to_db(sim.Iteration)
pops.write_agents_to_db(sim.Iteration)
agents = pops.get_agents()
# other model specific global settings
_max_search = 10
_impactarea = 1
# execute simulation run
while sim.run():
# select one random agent
agent = random.choice(agents)
# get that agents neighbourhood
neighbours = env.get_neighbourhood(agent, mode = "moore", radius = _impactarea)
util_is = 0.0
# if there are neighbours, then recalculate the utility of the agent
for o in neighbours:
if o.get_attr_value("type") == agent.get_attr_value("type"):
util_is += 10
else:
util_is += -10
# update agent utility
agent.increase_attr_value("utility",util_is)
# for search up to maximum limit of random free cells
cells = env.get_freecells(n = _max_search)
for c in cells:
util_new = 0.0
neighbours = env.get_neighbourhood(c, "moore", radius = _impactarea)
for o in neighbours:
if o.get_attr_value("type") == agent.get_attr_value("type"):
util_new += 10
else:
util_new += -10
if util_new > util_is:
# relocate agent, then break loop
env.relocate(agent, c)
agent.increase_attr_value("utility",util_new)
break
# update results in database, for agents and for environment
if (sim.Iteration % 10) == 0:
pops.write_agents_to_db(sim.Iteration)
pops.write_env_to_db(sim.Iteration)
pops.write_density_to_db(sim.Iteration)
# get dataframes with simulation results
agents_df = db_manager.get_agentsdf()
env_df = db_manager.get_environmentdf()
density_df = db_manager.get_densitydf()
# visualize simulation data
stats.set_fontsizes(8,10,12)
stats.plot_grid_occupation(env_df, ["natives","immigrants"], colors = ["#F52D2D","#4A87F1"], maxtime=0, markersize = 150.0)
stats.save_plot("segplt_early_ia1_50agents_1000it")
stats.plot_grid_occupation(env_df, ["natives","immigrants"], colors = ["#F52D2D","#4A87F1"], maxtime=500, markersize = 150.0)
stats.save_plot("segplt_intermediate_ia1_50agents_1000it")
stats.plot_grid_occupation(env_df, ["natives","immigrants"], colors = ["#F52D2D","#4A87F1"], maxtime=1000, markersize = 150.0)
stats.save_plot("segplt_late_ia1_50agents_1000it")
stats.plot_avgattr_lines(["utility"], agents_df)
stats.save_plot("avgutil_ia1_50agents_1000it")
animation.animate_grid_occupation(
df = env_df,
filename = "segvid_ia1_50agents_1000it",
population = ["natives","immigrants"],
colors = ["#F52D2D","#4A87F1"],
tpf = 0.20, # time per frame
mintime = 0,
maxtime = 1000,
markersize = 150.0
)
animation.animate_density(
df = density_df,
filename = "segdens_ia1_50agents_1000it",
attr = "utility",
defaultsize = 150,
color = "#F52D2D",
tpf = 0.20,
maxtime = 1000
)
# end program
db.close()
print("demo ends")Da dies nur ein beispielhafter Artikel ist, der zeigt, wie Sie das rasterbasierte agentenbasierte Modellierungsframework für agentenbasierte Segregationsmodelle verwenden können, führe ich nur 250 Iterationen aus. Für eine begrenzte Anzahl von Iterationen kann ich die aktuellen Systemzustände (Agentenattributwerte, Netzbelegung etc.) in meine Ergebnisdatenbank schreiben. Wenn ich eine viel höhere Anzahl von Iterationen habe, sollte ich jedoch nur eine Teilmenge von Iterationen in meine Datenbank schreiben. ZB jede 10. Iteration. Um die Erstellung von Animationen zu beschleunigen, kann ich z. B. Ergebnisse unterteilen, indem ich nur jede n-te Simulationszeit aus der Datenbank ziehe. Bei der Verwendung von matplotlib für Animationen sollte ich außerdem vermeiden, loc = „best“ für die Auswahl der Legendenposition zu verwenden.
Simulationsergebnisse des agentenbasierten Segregationsmodells
In diesem Abschnitt präsentiere ich Visualisierungen, die durch den obigen Simulationslauf generiert wurden. Die Visualisierungen liegen in standardisierter Form vor. Ich habe sie erstellt, indem ich mein GitHub-Repository (abm_framework) verwendet habe. Das heißt, der Rahmen unterstützt die Datenbankverwaltung zum Speichern von Simulationsergebnissen und die Visualisierung sowie Animation von Simulationsergebnissen.
Das folgende Diagramm visualisiert die Netzbelegung beim Start der Simulation.
Und schließlich ein Diagramm, das die Gitterbelegung nach 1000 Iterationen visualisiert.
Um diesen Abschnitt abzuschließen, möchte ich auch den durchschnittlichen Agentennutzen während der Simulationszeit betrachten. Ich kann dies mit der Funktion plot_avgattr_lines() visualisieren, die stats.py des abm_framework zur Verfügung stellt .
Die durchschnittliche Versorgungsleitung nimmt weiter zu. Das deutet darauf hin, dass sich die Agenten im Durchschnitt in einem Zustand befinden, in dem sie mehr Nutzen akkumulieren. Dieser Zustand ist höchstwahrscheinlich nicht stationär, und es gibt Segregationsmodelle, die zB den maximalen Nutzen eines Agenten begrenzen oder Änderungen des Nutzens nur berücksichtigen, wenn sich die Umgebung ändert. Es gibt auch agentenbasierte Segregationsmodelle, die einen Umzug eines Agenten nur dann zulassen, wenn die Situation des jeweiligen Agenten „schlecht genug“ ist (dh Agenten können Nutzenverluste bis zu einer bestimmten Grenze tolerieren).
Wie bereits erwähnt, unterstützt das Modul stats.py auch Animationen. Im folgenden Abschnitt werden zwei Animationen des agentenbasierten Segregationsmodells vorgestellt.
Animation des agentenbasierten Segregationsmodells
Für diese exemplarische Framework-Implementierung habe ich zwei standardisierte Animationen verwendet. Die erste zeigt Änderungen der Agentenstandorte im Laufe der Zeit.
Die zweite Animation zeigt, wie sich die Versorgungsdichte im Laufe der Zeit ändert. Cluster mit sehr hohem Nutzen werden gebildet. Gleichzeitig leiden andere Bereiche unter einem sehr geringen Nutzen (im Vergleich zu anderen Mitteln).
Wenn ich wollte, könnte ich jetzt z. B. einen genaueren Blick auf die Distributionen von Agent Utility usw. werfen. Dieser Blog – Beitrag sollte jedoch zeigen, wie mein agentenbasiertes Framework (derzeit in einem frühen Stadium) auf das Segregationsmodell angewendet werden kann Entwicklung. Das habe ich jetzt getan. Weitere beispielhafte Anwendungen des ABM-Frameworks werde ich in zukünftigen Blogbeiträgen dokumentieren.
Zugehörige Inhalte zur agentenbasierten Modellierung
Weitere Inhalte zu agentenbasierter Modellierung und agentenbasierter Simulation finden Sie in unserem Blog. Hier sind einige verwandte Artikel, die für Sie von Interesse sein könnten:
- Link : Python-Beispiel für ein agentenbasiertes SIR-Modell
- Link : Agentenbasierte Modellierung in Python
- Link : Agentenbasierte Simulation in Python
- Link : Agentenbasiertes Modell in Python
- Link : Simulationsmethoden für SCM-Analysten
Wirtschaftsingenieur mit Interesse an Optimierung, Simulation und mathematischer Modellierung in R, SQL, VBA und Python
Leave a Reply