In diesem Artikel implementiere ich ein SIR-Modell in Python, indem ich eine Bibliothek verwende, die ich für die agentenbasierte Modellierung in Python entwickelt habe. Mit anderen Worten, ich verwende ein vorhandenes Framework, um ein agentenbasiertes SIR-Modell zu implementieren.
Einführung des agentenbasierten SIR-Modells
SIR steht für anfällig , infiziert und wiederhergestellt . Wie in der folgenden Abbildung dargestellt, können Agenten in einem SIR-Modell die folgenden Statusübergänge erfahren: Von anfällig zu infiziert, von infiziert zu wiederhergestellt und von wiederhergestellt zu anfällig.

Die in der obigen Abbildung dargestellten Zustandsübergänge werden normalerweise mit einer zufälligen Verteilung und einer bestimmten Wahrscheinlichkeit implementiert. Außerdem müssen Sie nicht alle Zustandsübergänge berücksichtigen. In diesem Artikel werde ich beispielsweise Agenten nicht erlauben, von ihrem wiederhergestellten Zustand in einen anfälligen Zustand zurückzufallen. Nachfolgend finden Sie das in diesem Artikel implementierte SIR-Modell.

Auf die gleiche Weise könnten Sie auch ein SIR-Modell formulieren, in dem Sie einen Fallback vom wiederhergestellten Zustand in den infizierten Zustand zulassen, nicht nur in den anfälligen Zustand.
Agentenbasiertes Modellierungsframework in Python
Ich habe ein Framework für die agentenbasierte Modellierung erstellt. Das Framework soll im Laufe der Zeit erweitert und aktualisiert werden. Es unterstützt derzeit ein Setup, mit dem Agenten, Simulationsumgebung und Populationen in einem gitterbasierten Modell platziert werden können. Simulationsergebnisse können in einem standardisierten Format in eine SQLite-Datenbank geschrieben werden, und Visualisierungen und Animationen werden basierend auf den in dieser Datenbank gespeicherten Daten generiert. Das Framework besteht aus mehreren Python-Dateien (Modulen), die bearbeitet werden können, um benutzerdefinierte Funktionen hinzuzufügen.

Wenn Sie sich das Framework ansehen möchten, können Sie es auf GitHub verfolgen . Hier ist der Link:
Das Besondere dabei ist, dass das Framework Grid-basierte agentenbasierte Modellierung unterstützt. Agenten interagieren in einem 2D-Raster. Dieses 2D-Raster erleichtert die Simulationsumgebung. Je nach Modelleinstellungen können sich ein oder mehrere Agenten in derselben Zelle befinden. Agenten können mit anderen Agenten innerhalb einer bestimmten Nachbarschaft interagieren. In diesem Artikel beziehen sich Wechselwirkungen auf die Übertragung von Krankheiten, die zur Ausbreitung der Krankheit führen.

Agenten haben Attribute und Funktionalität, dargestellt durch innere Dynamiken, Variablen und Zustände. Das Innenleben eines Agenten beeinflusst seine Handlungen, Entscheidungen und Interaktionen mit anderen Agenten. Auch diese Interaktionen können durch die Interaktionsumgebung beeinflusst werden.

Ich werde nun fortfahren, indem ich die relevante ABM-Modellimplementierung in Python dokumentiere.
Implementieren des agentenbasierten SIR-Modells in Python
Im folgenden Code verwende ich das agentenbasierte Modellierungsframework. Ich habe einen Simulationslauf eingerichtet, der 300 Iterationen dauert. Die Wahrscheinlichkeit, dass anfällige Erreger infiziert werden, beträgt 7 % für jede Begegnung mit einem infizierten Erreger. Andererseits hat ein infizierter Erreger bei jeder Iteration eine Heilungswahrscheinlichkeit von 3 %.
__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) # Environment constructor implicitly resets environment table in database
# create initial population of healthy humans
pops = framework.Populations(amount = 1, env = env, db_manager = db_manager, attributes = ["infected","recovered"], datatypes = ["INTEGER","INTEGER"])
pops.add_population(name = "humans",
size = 200,
attributes = ["infected","recovered"],
datatypes = ["INTEGER","INTEGER"],
initialvals = [0, 0]
)
# randomly infect 5%
pop = pops.Populations["humans"]
sampleagents = pop.get_agents(int(0.05*pop.Size))
for agent in sampleagents: agent.Attributes["infected"] = 1
_prob_infection = 0.07
_prob_recovery = 0.03
# setup simulation
sim = framework.Simulation(300)
# 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, store every 10th run into the database
while sim.run():
# look at every agent
for agent in pop.get_agents():
if agent.get_attr_value("infected") == 1:
neighbours = env.get_neighbourhood(agent)
for neighbour in neighbours:
if neighbour.get_attr_value("infected") == 0 and neighbour.get_attr_value("recovered") == 0:
# this neighbour is not resistant and not infected; infect with specified probability
if random.uniform(0, 1) < _prob_infection: neighbour.set_attr_value("infected", 1)
# the infected agent recovers with a specified probability
if random.uniform(0, 1) < _prob_recovery:
agent.set_attr_value("recovered", 1)
agent.set_attr_value("infected", 0)
# update results in database, for agents and for environment
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
humans_df = db_manager.get_populationdf(pop = "humans")
env_df = db_manager.get_environmentdf()
density_df = db_manager.get_densitydf()
# visualize simulation data
stats.set_fontsizes(8,10,12)
stats.plot_agentattr_lines("infected", humans_df)
stats.save_plot("infection_curves")
stats.plot_agentattr_lines("recovered", humans_df)
stats.save_plot("recovery_curves")
stats.plot_grid_occupation(env_df, ["humans"])
stats.save_plot("human_locations")
stats.plot_density_markersize(density_df, "infected", 50, "red")
stats.save_plot("infection_density")
stats.plot_density_markersize(density_df, "recovered", 50, "green")
stats.save_plot("recovery_density")
stats.plot_avgattr_lines(["infected","recovered"], humans_df)
stats.save_plot("avginfectedavgrecovered")
# create and save animations
animation.animate_density(
df = density_df,
filename = "infectionanimation",
attr = "infected",
defaultsize = 50,
color = "red",
tpf = 0.05
)
animation.animate_density(
df = density_df,
filename = "recoveryanimation",
attr = "recovered",
defaultsize = 50,
color = "green",
tpf = 0.05
)
# end program
db.close()
print("demo ends")
Die obige agentenbasierte SIR-Modellimplementierung generiert Ergebnisse, die in einer SQLite-Datenbank gespeichert werden. Diese Datenbank wird später für Visualisierungen verwendet. Diese Visualisierungen können in einem separaten Skript, von einem anderen Analysten und zu einem anderen Zeitpunkt implementiert werden. Das heißt, Modellausführung und Datenvisualisierung sind zwei getrennte Aktivitäten, die durch die Datenbank entkoppelt sind.
Agentenbasierte SIR-Modellsimulationsergebnisse
Ich kann jetzt endlich die Ergebnisse überprüfen, die vom gitterbasierten agentenbasierten SIR-Modell generiert wurden. Nachfolgend finden Sie eine Visualisierung der Agentenstandorte während dieses Simulationslaufs.

Die folgende Animation zeigt, welche Agenten im Laufe der Zeit infiziert wurden. Die Animation zeigt außerdem Agentenstandorte. In diesem einfachen Beispiel sind die Agentenstandorte statisch.
Als nächstes eine Animation der Agentenwiederherstellung während der Simulationszeit.
Das folgende Diagramm visualisiert die mittlere Wahrscheinlichkeit, dass ein Agent zum gegebenen Simulationszeitpunkt infiziert oder wiederhergestellt wird.

Die Agentenwiederherstellung stellt sicher, dass nicht alle Agenten infiziert sind. Agenten in diesem Modell haben jedoch statische Standorte. In einem anderen Simulationslauf könnten wir dynamische Agentenstandorte oder sogar eine Art Diffusion/Migration zulassen. Dies würde höchstwahrscheinlich die Gesamtzahl der Agenten erhöhen, die während des Simulationslaufs infiziert werden.
Das in diesem Artikel angewendete agentenbasierte Modellierungsframework kann zusätzliche Diagramme liefern. Darüber hinaus bleiben die Simulationsergebnisse in einer SQLite-Datenbank gespeichert, die beliebig analysiert werden kann. Dies würde jedoch einige zusätzliche Anpassungen/Anpassungen, dh Codierung, erfordern.
Schlussbemerkungen und zugehörige Inhalte
Agentenbasierte Simulation ist eine Simulationsmethode, die versucht, komplexes makroskopisches Systemverhalten zu erklären, indem Agentendynamiken und -interaktionen auf mikroskopischer Systemebene beschrieben werden. Es ist eine ziemlich abstrakte Methode, die oft zum Verständnis komplexer Systeme verwendet wird. Komplexe Systeme sind komplexer als komplizierte Systeme und andererseits weniger komplex als chaotische Systeme. Die US-Wirtschaft, makroskopisch sichtbar zB in Form des Bruttoinlandsprodukts, ist ein Beispiel für ein komplexes System. Agentenbasierte Modelle können beispielsweise verwendet werden, um die Entstehung bestimmter Phänomene und Trends in der US-Wirtschaft zu verstehen.
In diesem Artikel habe ich ein kürzlich sehr beliebtes Modell für die Ausbreitung von Krankheiten implementiert. Dies ist in der Tat ein weiterer interessanter Bereich, in dem agentenbasierte Modellierung häufig angewendet wird. Unter Verwendung eines Frameworks für agentenbasierte Modellierung habe ich ein agentenbasiertes SIR-Modell implementiert. Die Visualisierungs- und Animationsfunktionen des Frameworks wurden verwendet, um die Simulationsergebnisse zu überprüfen. Das Framework selbst kann verwendet werden, um andere Arten von agentenbasierten Simulationsmodellen zu implementieren – und das Framework wird im Laufe der Zeit aktualisiert und regelmäßig erweitert.
Hier sind einige andere SCDA im Zusammenhang mit der agentenbasierten Simulation :
- Link : Simulationsmethoden für SCM-Analysten
- Link : Ein einfacher agentenbasierter Simulationslauf, der mit Matplotlib in Python visualisiert wurde
- Link : Agentenbasierte Modellierung in Python
- Link : Entwicklung eines einfachen agentenbasierten Simulationsmodells in Python
- Link : Visualisierung von 2D-Gittern und -Arrays mit Matplotlib in Python

Wirtschaftsingenieur mit Interesse an Optimierung, Simulation und mathematischer Modellierung in R, SQL, VBA und Python
Leave a Reply