Anteriormente, apresentei o primeiro sprint de uma estrutura de modelagem e simulação baseada em agente no qual estou trabalhando. Nesta postagem do blog , implemento um modelo de segregação baseado em agente em Python. Modelos semelhantes, com alguns ajustes e desvios, são usados, por exemplo, para entender a segregação social. O objetivo principal desta postagem de blog é fornecer outra demonstração de modelagem e simulação baseada em agente em Python. O framework utilizado é o abm_framework em Python.
Framework para modelagem baseada em agente em Python
Eu desenvolvo um modelo de segregação como outro exemplo de aplicação da estrutura de modelagem baseada em agente em que estou trabalhando em Python. Você pode baixar o framework no GitHub aqui:
O repositório do GitHub contém uma pasta de demonstração. Aplicativos exemplares estão disponíveis aqui. No momento da publicação deste artigo ainda não havia muitos modelos de demonstração disponíveis. Adicionarei mais modelos de demonstração nas próximas semanas e os módulos existentes serão expandidos para oferecer suporte a uma gama mais ampla de aplicativos de modelagem baseados em agentes.
No abm_framework os módulos importantes são os seguintes:
- framework.py para modelagem, por exemplo, agentes, populações de agentes e o ambiente de simulação
- data.py para gerenciar operações de banco de dados para gravar e ler resultados de simulação
- stats.py para plotar os resultados da simulação (também independentemente da execução da simulação)
- config.py para, por exemplo, especificar caminhos relevantes, por exemplo, o caminho do arquivo de banco de dados
- animation.py para animar os resultados da simulação
A figura abaixo resume o conteúdo do repositório abm_framework no GitHub.
O arquivo model.py é o próprio modelo de simulação . No caso do exemplo descrito no artigo em questão, por exemplo, nomeei o arquivo segregation.py . O arquivo de modelo implementa um modelo específico. A estrutura (com todos os módulos descritos acima) serve como uma caixa de ferramentas. Em outras palavras, o framework visa facilitar a implementação de um modelo de simulação específico .
Descrição do modelo de segregação baseado em agente conceitual
Como estou usando a estrutura de modelagem baseada em agente apresentada por mim em artigos anteriores, estou desenvolvendo um modelo de simulação baseado em agente baseado em grade . Ou seja, eu atribuo agente a uma grade. Agentes, portanto, têm locais. Os agentes também têm uma vizinhança com um raio especificado. A interação entre os agentes ocorre dentro desta vizinhança. A figura abaixo, tirada do meu post anterior sobre a implementação do modelo SIR baseado em agente em Python, ilustra esse conceito.
Neste exemplo de modelo de segregação baseado em agente, facilito os mecanismos de segregação implementando o fluxograma abaixo:
Para cada iteração, escolho um agente aleatoriamente. Em seguida, calculo o impacto da utilidade na célula atual do agente. Esse impacto da utilidade é calculado pela iteração sobre todos os agentes vizinhos. Se o vizinho for do “mesmo tipo” do próprio agente, o impacto da utilidade é aumentado (impacto positivo). Se o vizinho não for do “mesmo tipo” o impacto da utilidade é diminuído (impacto negativo).
Em seguida, uma célula livre aleatória na grade é selecionada e o impacto hipotético da utilidade nessa célula é calculado. Para este cálculo aplica-se a mesma lógica descrita acima. Se o impacto hipotético de utilidade nessa célula for positivo, o agente se realoca para esse local e atualiza sua utilidade novamente. Caso contrário, outra célula livre é selecionada e o mesmo teste se aplica. O processo se repete até um limite máximo de busca, ou seja, um número máximo especificado de repetições.
Implementação do modelo de segregação baseado em agente em Python
Abaixo está o código que implementa o modelo de segregação baseado em agente.
__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")Como este é apenas um artigo exemplar, demonstrando como você pode usar a estrutura de modelagem baseada em agente baseada em grade para modelos de segregação baseados em agente, executo apenas 250 iterações. Para um número limitado de iterações, posso escrever os estados atuais do sistema (valores de atributo do agente, ocupação da grade etc.) em meu banco de dados de resultados. Se eu tiver um número muito maior de iterações, devo escrever apenas um subconjunto de iterações no meu banco de dados. Por exemplo, a cada 10 iteração. Da mesma forma, para tornar a criação de animação mais rápida, posso, por exemplo, subconjunto de resultados apenas puxando cada enésimo tempo de simulação do banco de dados. Ao usar o matplotlib para animações, devo evitar o uso de loc = “best” para a seleção do local da legenda.
Resultados da simulação do modelo de segregação baseado em agente
Nesta seção apresento visualizações geradas pela simulação acima. As visualizações vêm em um formato padronizado. Eu os criei usando meu repositório GitHub (abm_framework). Ou seja, o framework suporta gerenciamento de banco de dados para armazenamento de resultados de simulação e visualização e animação de resultados de simulação.
O gráfico abaixo visualiza a ocupação da grade no início da simulação.
E por último, um gráfico que visualiza a ocupação da grade após 1000 iterações.
Para concluir esta seção, também quero examinar a utilidade média do agente ao longo do tempo de simulação. Eu posso visualizar isso usando a função plot_avgattr_lines() fornecida stats.py do abm_framework .
A linha de utilidade média continua aumentando. Isso indica que os agentes, em média, estão em um estado em que acumulam mais utilidade. Este estado provavelmente não é estacionário, e existem modelos de segregação que, por exemplo, limitam a utilidade máxima de um agente, ou consideram apenas mudanças na utilidade quando o ambiente muda. Existem também modelos de segregação baseados em agentes que só permitem que um agente seja realocado se a situação do respectivo agente for “ruim o suficiente” (ou seja, os agentes podem tolerar perdas de utilidade até um certo limite).
Como dito, o módulo stats.py também suporta animações. Na seção seguinte serão apresentadas duas animações do modelo de segregação baseado em agentes.
Animação do modelo de segregação baseado em agente
Para esta implementação de framework exemplar eu fiz uso de duas animações padronizadas. A primeira mostra as mudanças nas localizações dos agentes ao longo do tempo.
A segunda animação mostra como a densidade da utilidade muda ao longo do tempo. São formados clusters com utilidade muito alta. Ao mesmo tempo, outras áreas sofrem de utilidade muito baixa (quando comparadas a outros agentes).
Se eu quisesse, eu poderia, por exemplo, prosseguir examinando mais de perto as distribuições de utilitário de agente, etc. No entanto, esta postagem no blog foi feita para demonstrar como minha estrutura baseada em agente (atualmente em seus estágios iniciais) pode ser aplicada ao modelo de segregação desenvolvimento. Eu fiz isso agora. Documentarei outras aplicações exemplares da estrutura ABM em futuras postagens do blog.
Conteúdo de modelagem baseado em agente relacionado
Conteúdo adicional relacionado à modelagem baseada em agente e simulação baseada em agente está disponível em nosso blog. Aqui estão alguns artigos relacionados que podem ser do seu interesse:
- Link : Exemplo de Python do modelo SIR baseado em agente
- Link : Modelagem baseada em agente em Python
- Link : Simulação baseada em agente em Python
- Link : Modelo baseado em agente em Python
- Link : Métodos de simulação para analistas de SCM
Cientista de dados com foco em simulação, otimização e modelagem em R, SQL, VBA e Python
Leave a Reply