Probabilistic Programming for Dynamic Data Assimilation on an Agent-Based Model

Probabilistic Programming for Dynamic
Data Assimilation on an Agent-Based
Model
Luke Archer, Prof. Nick Malleson, Dr. Jon Ward

• Rapid advancements in computation power and the societal push to collect as
much data as possible has led to the formation of ‘Smart Cities’
• This wealth of individual level data opens up new avenues of research, with a
potential to revolutionise areas of social science
• One of these areas is Agent-Based Social Simulation (ABSS)
• These are social simulations based on agent-based modelling, where the
movement and behaviour of people can be represented at the individual level
• Improving our simulations of people in Smart Cities can be used to better inform
things like disaster management, and planning transport and utility infrastructure

This is a well known example of an ABM -
Schelling’s model of spatial segregation
Each coloured icon is an individual agent
that has the ability to move a short distance
each timestep
Agents in this model try to find others of
the same type, and segregate themselves
from their opposite colour
There are many examples in the
literature of ABM used in social
simulation

ABMs are constantly improving, partly
due to the increasing amounts of high
resolution data for calibration
Many new types of data are now being
collected, including but not limited to…

Consumer purchase data
Social media dataTraffic sensors
Pedestrian sensors

• Current methods of calibration however lead to an issue for ABMs – they can only
be calibrated once using historical data (sometimes known as ‘one-shot
calibration’)
• This means that simulations can be created where agents act like the real-life
counterparts from whom the data was collected, but no simulation can accurately
model a real-world system
• In order to model a system in real time, we need to find a way to update the
model with new data as it is collected – in other words to stream data into the
model and update its state to match the system of interest
• The objective of this project therefore is to…

Develop a Data Assimilation algorithm on
an Agent-Based Model

~50yr
Data Assimilation is a group of statistical techniques
that have been keenly developed in weather prediction
They allow for the combination of a prediction (most
often from a computer model) and real-world
observations, to produce a more accurate model state
These techniques are touted as the reason for the huge
improvement in weather prediction over the last ~70
years
For example, an Australian study found that current 5
day forecasts are as accurate as 1 day forecasts were 50
years ago

In data assimilation, a computer model produces a
prediction (or forecast, blue) of a system.
Assimilation algorithms then combine the
observations (analysis, red), with the forecast. The
result is a more accurate state, that is closer to the
true state than either the forecast or the
observations.
Importantly for our objective, Data Assimilation allows the inclusion of new data in real-time with a
model, and does not require the model be retrained or stopped and restarted. This makes it perfect for
streaming new observations into an ABM as it runs.

Data Assimilation is governed by a set of well studied
techniques, but we have attempted to do something a bit
novel. We have been working with a Probabilistic
Programming library called Keanu, which is in
development by Improbable Worlds Ltd., based in London.
The power of Keanu comes from the way it uses
computational graphs, termed Bayesian Networks (below)
in Probabilistic Programming.
Bayesian networks represent the conditional
relationships between each vertex, which are the
building blocks of probabilistic models.
Keanu can ‘observe’ one or multiple values in a
network, setting its value and removing the
uncertainty for that vertex. It then calculates the most
likely value of all vertices in the network.
Using Keanu, we can represent a predictive model as
a Bayesian Network, observe some true values, and
Keanu will calculate the most likely value of our
model state – all in real time.

To test this new method, we have been working with an
ABM affectionately known as StationSim – a very simple
representation of people moving through a train station.
People (blue) move at varying speeds from green
entrances on the left towards fewer red exits on the
right. When a fast person gets stuck behind someone
slower, they randomly move left or right to get around
them. This results in some emergence – a key property
of ABMs – which allows us to compare between runs.
In one cycle, we run the model once without any
assimilation to collect data. The model is then run a
second time, and the Bayesian Network is built to
represent this run. Data from the first run is then
observed at intervals (known as assimilation windows),
and Keanu calculates a new model state from the
prediction and observations.

Unfortunately, we have not yet achieved good results for data
assimilation in real-time. One of the main reasons behind this is
how difficult it is to represent complex models accurately using
Keanu. StationSim is built in MASON (a powerful agent-based
modelling framework) and has a large network of complex
interactions, sometimes made more complex by how MASON
organises and handles these.
Due partly to these complications, StationSim will not
be used in the next stage of this project. A new model
is being built from scratch, to avoid complications that
arose from MASON. This will reduce some complexity,
particularly when trying to interface between the
Probabilistic language and the model.
Keanu will also be replaced. Two potential replacements are Pyro and TensorFlow
Probability, which both have excellent documentation and a large community of
people using and contributing to them. This should make any challenges easier to
overcome.

Probabilistic Programming for Dynamic Data Assimilation on an Agent-Based Model

Recommended

More Related Content

Similar to Probabilistic Programming for Dynamic Data Assimilation on an Agent-Based Model (20)

Recently uploaded (20)

Probabilistic Programming for Dynamic Data Assimilation on an Agent-Based Model

Editor's Notes