• ← Previous (Continuous Model)
• Next (End of Men Model) →

Agent Based Model

Background

The agent based model implementation of SIR divides the population in three components — as in the continuous model — Susceptible, Infected, and Recovered. In the agent based model the component is represented as the Agent.state.

Each individual is represented as an agent and the state of each agent changes over time based on the interactions between agents:

• The world contains a discrete spatial grid with wraparound geometry (as in Game of Life).
• Multiple agents can be in the same grid location, so use mesa.space.MultiGrid, instead of mesa.space.SingleGrid.
• Agents are placed randomly on the grid, with at most one in each grid location, with probability density. (Later in the simulation, as agents move there can be multiple agents in a single location.)
• Agents have state of SUSCEPTIBLE, INFECTED, or RECOVERED.
• Agents have a get_neighborhood method that returns the list of neighbouring cells.
• Agents have a step method that implements the following rules:
  • If an agent is INFECTED, it will infect any susceptible agents in the same location with probability pr_infect.
  • If an agent is INFECTED, it will recover with probability pr_recover.
  • Agents move, with probability pr_move, to a random neighbouring cell each step.

Outline of core classes Agent and Model

Agent class

• stores the state of SUSCEPTIBLE, INFECTED, or RECOVERED.
• has function, get_neighborhood to return a list of all neighboring cells.
• has function, step to compute its behaviour based on its state and the state of its neighbours.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12

class Agent(mesa.Agent):

    SUSCEPTIBLE = 0
    INFECTED = 1
    RECOVERED = 2

    def __init__(self, model):
        super().__init__(model)

    def get_neighborhood(self): ...

    def step(self): ...

The Model class

The Model class stores the model parameters, the model geometry (space/grid), and the agents in the model.

The basic structure of this class is

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

class Model(mesa.Model):

    def __init__(self, seed=None):
        super().__init__(seed=seed)

        # store model parameters

        # create the model space/grid

        # create agents in the model

        # setup data collection

        # start simulation

    def step(self): ...   

Implementing the SIR Model

Agent class

The get_neighborhood method:

• This is similar the get_neighbors method defined in the Game of Life and other models, but calls the method grid.get_neighborhood in place of grid.get_neighbors. What is the difference? Well get_neighbors returns a list of agents in the neighbourhood, while get_neighborhood returns a list of grid locations in the neighbourhood. We need to locations to pick one to move to when updating.

The step method has the following rules:

• The agent moves to a random neighbouring cell with probability pr_move. To do this:

  • use model.pr_move to determine if the agent should move.
  • get the list of neighbouring cells using self.get_neighborhood.
  • pick a random destination cell from the list of neighbouring cells, using np.choice.
  • move the agent to the destination cell.

• If an agent is INFECTED, then it can infect each SUSCEPTIBLE agents in the same location (if they exist) with probability pr_infect.

• If an agent is INFECTED, then it can recover with probability pr_recover.

We could implement these rules fully, but instead we will implement them step by step and examine progress.

The Model class

This is implemented along similar lines to the Fire Model or the Schelling Model:

In Model.__init__:

• Replace SingleGrid with MutliGrid
• Add agents (default state is SUSCEPTIBLE)
• Pick one random agent to be INFECTED.

In Model.step:

• Same as in the Schelling Model (where all agents are updated in random order).

Visualisation

To start, the function draw_model is near identical to the Schelling Model function. use colours and labels:

1
2

    colors = ['green', 'red', 'yellow']
    labels = ['Susceptible', 'Infected', 'Recovered']

Then creating a model and displaying it using

1
2
3

model = Model(20, 10, seed=666)
fig, ax = plt.subplots(nrows=1, ncols=1, figsize=(6,2))
draw_model(model, ax)

should result in the following

This is OK, but what happens when multiple agents are in the same grid location? How can we see multiple agents since we will only see the last one drawn.

There are a number of fixes for this. The easiest of these is to draw smaller agents and give each agent a random offset (from the centre). This works, but we want to be careful of two things:

• We do not want any randomness used in the visualisation to affect the randomness in the simulation. You should think about why this is not desirable.
• We want the random offset for the agents to be constant for the duration of the simulation - otherwise the agents will be jumping around within a grid location even when that are not moving grid locations.

There is a solution to both of these issues:

• In Model._init__ create a separate random number generator that will be only used for visualisation. Here I used default_rng which I imported from numpy.random.

1

    self.rng = default_rng(666)

• When creating an agent, in Agent.__init__ give it a random offset

1

    self.offset = model.rng.uniform(0.2, 0.8, size=2)

• In draw_model, change the radius to 0.2 and change pos from

1

    pos = agent.pos + np.array([0.5,0.5])

to

1

    pos = agent.pos + agent.offset

This results in the following

Implementing Agent update rules in separate versions

Version 1 — INFECTED agent movement

Add movement to the agent that is INFECTED only. Use grid method move_agent.

By moving just the single INFECTED agent it is easier to verify that the correct behaviour is implemented.

TEST: When you run simulation only the INFECTED agent show move and only move from grid location to neighbouring grid location.

Version 2 — all agent movement

Now modify the agent.step method so that all agents move.

TEST: Now all agents should be moving. Lower density value so easier to track each agent to verify movement.

Version 3 — disease spread

When updating an INFECTED agent we need to see if they infect any SUSCEPTIBLE agents who are sharing their current grid location. To do this:

• We need grid method get_cell_list_contents which returns a list of agents in the specified grid location.
• Iterate over the list of agents and infect any that are SUSCEPTIBLE with probability py_infect.

TEST: Now infection should spread as agents move around the grid.

Version 4 — recover from disease

An infected agent recovers with probability pr_recover, changing state from INFECTED to RECOVERED.

TEST: Now infection should spread but over time the infected are replaced by recovered.

NOTE: Finally check the order of your actions in agent.step we want the move to be the last action carried out.

Data Collection

Next add the data collection (similar to Fire Model and Schelling Model). And generate plots similar to the fire model to investigate the impact of the model parameters pr_infect and pr_recover. These parameters play a similar role to the Fire model parameters pr_spread and pr_burnout, and play a similar role to the continuous SIR model parameters beta and gamma.

Task 2

Generate generate plots similar to the fire model to investigate the impact of the model parameters.

Task 3

Modify the model so that it includes state DEAD. This gives use the SIRD model and is implemented using:

• New state DEAD.
• New model parameter pr_die. Agents that are infected now recover with probability pr_recover*(1-pr_die) and die with probability pr_recover*pr_die. This is so the parameters pr_die works similar to the parameter mu in the continuous SIRD model (Task 1).
• A DEAD agent does not die and the simplest approach is not display them in draw_model.

Task 4

One advantage of the agent based model approach for disease spread is that it is easy to add effects of social distancing. One approach is to add another parameter, say pr_isolate, which when state is INFECTED the agent does not move with probability pr_isolate. This probability check is applied inside the probability check self.random.random()<self.model.pr_move.

Then using data collector and batch runner generate plots to show the impact of pr_isolate.

• ← Previous (Continuous Model)
• Next (End of Men Model) →