Desenvolvendo um modelo simples de simulação baseado em agente em Python

Em um post anterior, demonstrei como visualizar uma grade 2D, usando matplotlib e pyplot em Python (post titulado “Visualizando grades e arrays 2D usando matplotlib em Python”). Essa postagem foi feita como uma primeira introdução sobre como visualizar grades em Python. A visualização de grades pode ser interessante ao, por exemplo, visualizar resultados de estudos de simulação baseados em agentes.

Neste post, eu modelo as bases de um modelo de simulação simples baseado em agente, usando uma matriz 2D como um ambiente que pode ser preenchido por dois tipos de agentes.

Esta matriz 2D servirá como um campo de batalha no qual dois grupos de agentes lutarão uma batalha.

Os agentes têm o mesmo conjunto de atributos, sendo um deles sua associação ao grupo. Além disso, todos eles têm uma pontuação de vida, que é igual no início da simulação. Por último, eles possuem um conjunto de coordenadas (coordenadas x e y), representando sua localização espacial em um mundo bidimensional.

Não irei realizar um estudo de simulação neste post. Isso será feito em uma próxima postagem. Vou usar o modelo deste post em um post futuro para simular uma batalha entre os dois grupos de agentes.

No trecho de código abaixo, defino uma classe para agentes, contendo atributos e métodos relevantes. A documentação é adicionada ao código na forma de comentários.

# classe, definindo agentes como tipos de dados abstratos
class agent:
    # método init, o método construtor para agentes
    def __init__(self,x,y,group):
        self.life = 100.0 # pontuação de vida do agente
        self.x = x
        self.y = y
        self.group = group

O próximo passo é definir uma matriz de grade 2D, na forma de uma lista 2D. As linhas representam as coordenadas x, as colunas representam as coordenadas y. Esta lista 2D representa o campo de batalha. Eu defino que tenha um tamanho de 100 x 100 células, ou seja, 10.000 locais. Usarei o tipo de lista padrão em Python para definir esse array de “campo de batalha”. O caminho a seguir é usar compreensões de lista em Python:

# criação de lista 100 x 100 vazia usando compreensão de lista em python
battlefield = [[None for i in range(0,100)] for i in range(0,100)]

Em seguida, vou criar dois grupos de agentes e localizá-los em locais aleatórios dentro do campo de batalha. Além disso, em listas separadas, armazeno referências aos objetos do agente. Vou criar 1000 agentes do grupo A e 1000 agentes do grupo B.

# lista com as localizações x e y disponíveis
locations = battlefield.copy() # using .copy prevents copying by reference
# crie uma lista vazia para conter referências de agente no futuro, digite A e B
agents_A = []
agents_B = []
# atribuição de pontos aleatórios para agentes do grupo A e B;
# - para isso, vou precisar do módulo aleatório, então importe-o
import random
# - definir uma função para criar agentes e atribuí-los à grade
def agentCreator(size,group,groupList,field,n,m):
    # loop por todo o grupo, ou seja, neste caso, 1000 unidades
    for j in range(0,size):
        # selecione a localização disponível aleatoriamente
        while True:
            # coordenada x aleatória
            x = random.choice(range(0,n))
            # coordenada y aleatória
            y = random.choice(range(0,m))
            # verifique se há vaga disponível; se não, reiterar
            if field[x][y] == None:
                field[x][y] = agent(x=x,y=y,group=group)
                # anexar referência de objeto de agente à lista de grupo
                groupList.append(field[x][y])
                # sair do loop while; local no campo é tomado
                break
# - Eu preencho o campo de batalha usando a função agentCreator
agentCreator(size = 1000,
                group = "A",
                groupList = agents_A,
                field = battlefield,
                n = 100,
                m = 100)
 agentCreator(size = 1000,
                group = "B",
                groupList = agents_B,
                field = battlefield,
                n = 100,
                m = 100)

A lista 2D “campo de batalha” agora contém “Nenhum” ou referências de agente, do tipo A ou B. Todos os agentes têm um valor de vida de 100, uma vez que a batalha ainda não começou.

Para concluir esta primeira postagem sobre simulação baseada em agente, visualizarei a localização dos agentes do tipo A e a localização dos agentes do tipo B, em dois gráficos de grade separados. A chave para fazer isso é usar matplotlib.pyplot, com o método .imshow ():

# .imshow () precisa de uma matriz com elementos flutuante;
population = [[0.0 for i in range(0,100)] for i in range(0,100)]
# se o agente for do tipo A, coloque 1.0, se for do tipo B, tipo a 2.0
for i in range(1,100):
    for j in range(1,100):
        if battlefield[i][j] == None: # vazia
            pass # deixar 0,0 na célula de população
        elif battlefield[i][j].group == "A": # agentes do grupo A
            population[i][j] = 1.0 # 1.0 significa "A"
        else: # group B agents
            population[i][j] = 2.0 # 2.0 significa "B"
# importar pyplot e cores de matplotlib
from matplotlib import pyplot, colors
# usando cores de matplotlib, defina um mapa de cores
colormap = colors.ListedColormap(["lightgrey","green","blue"])
# definir o tamanho da figura usando pyplot
pyplot.figure(figsize = (12,12))
# usando pyplot adicione um título
pyplot.title("battlefield before simulation run (green = A, blue = B)",
            fontsize = 24)
# usando pyplot adicione rótulos x e y
pyplot.xlabel("x coordinates", fontsize = 20)
pyplot.ylabel("y coordinates", fontsize = 20)
# ajustar as marcações dos eixos xey, usando pyplot
pyplot.xticks(fontsize = 16)
pyplot.yticks(fontsize = 16)
# use o método .imshow () do pyplot para visualizar as localizações dos agentes
pyplot.imshow(X = population,
             cmap = colormap)

<matplotlib.image.AxesImage em 0x1c756b04c88>

Em uma próxima postagem, usarei o modelo básico desenvolvido nesta postagem para simular a batalha real entre os dois grupos de agentes. Veremos diferentes parâmetros e como eles influenciam o resultado da batalha. Este será o nosso ponto de partida para aprender mais sobre simulação baseada em agente em Python.