AGENT-BASED MODEL Impossible to analyze in the reality ...€¦ · Keywords: Agent Based Models,...
Transcript of AGENT-BASED MODEL Impossible to analyze in the reality ...€¦ · Keywords: Agent Based Models,...
Manuela Testa
Economic Sociology and Labour Studies
University of Milan and University of Brescia
AGENT-BASED MODEL
Impossible to analyze in the reality? Simulation is the way!
Abstract
With this work I'd like to show you the fun and useful world of the agent-based modelling system.
Simulation is an easy way to study phenomena which are difficult, dangerous or even illegal to
analyze in the real world. The agent-base modelling system is a kind of simulation which is based
on a bottom-up perspective, which starts from the single agents' behaviour and studies a macro
phenomenon given by the interaction between them. Starting from a short description of the
underlying theory and history, the article focuses on the practical perspective, as this is the best
way to understand how modelling works. I used an easy example in which students interact with
each other in order to share knowledge (or not). In the example, students are divided by
cooperative and competitive behaviour. Their interactions can be analyzed to understand the
frequency of spread or disappearance of these two different types of students.
Keywords: Agent Based Models, ABM, Simulation, Model, NetLogo
Introduction
How many times did you want to study a phenomenon that seems curious and interesting, or you
had an intuition for an innovative research, but the costs are too high or the protocol is too long,
maybe even dangerous? That's why, since the '50s, there has been made extensive use of the
method of “simulation” in various fields of interest (e.g. medicine, economics) to support decision-
making. The first research group to use this technique was the Centre of Operational Research of
BISRA, metals technology industry research group in England, who also produced the first
specialized “languages”, which then expanded in the United States, and further on throughout the
world.
What are ABMS?
The really interesting aspect of simulation is that with this method it is possible to re-create
"micro-worlds" that can have two characteristics at the same time as they are in fact, checking and
highlighting the interdependencies between different parts and protagonists possibly amending
their characteristics during construction, while at the same time representing new scenarios and
possibly "impossible" phenomena detected in the world we live in (the word impossible is in
quotation marks because who is to say what is impossible?). Simulations show the unfolding of
events, under certain parameters (which we are able to control in the simulation) over a certain
time span and lets us search for new solutions, even to old problems.
With a simulation we can "see how things would be if ...", without changing the actual fact, it
allows us not only to do repeated tests always starting from the same condition (which is
impossible in reality as there are no time machines to take us back the conditions before the
experiment, for now!), but it also allows us to formulate and test hypotheses that might otherwise
be very expensive or dangerous (for example the study of some natural disasters ...).
From what has been said so far, we can summarize a number of important advantages of
simulations over other modes of research:
• Substantial reduction of costs: with simulation just a computer and an idea are needed to
"shake up" the world. Study a phenomena in the reality could be dangerous and have some
risk. If you make some mistakes, in most of the cases, you can't try again with same
situation of the first time, so the use of simulation is a really good substitute for a first
experiment.
• Speed: through simulation we can study events, which in reality could need ten years,
within only few seconds.
• Safety and legality: I have mentioned that some objects of study could be dangerous or
even illegal. With the simulation, this problem can be overcome and allow studies on
innovative ideas, which for fear of failure and consequence are often not even attempted.
Repeatability and better understanding of the object of study: in reality you cannot repeat
experiments without the prior attempt somehow changing the new starting conditions. A
simulation allows a continuous repetition of an experiment including the initial conditions
and to have the opportunity to gather more data, in order to evaluate the result that most
satisfies us and allows us to run a more detailed analysis due to the large amount of data
collected.
Obviously, as in all techniques, we also have disadvantages:
• As a simulation, and not reality, the results can be only approximate of what ultimately will
actually post the behavior of the system; so we can't take the result as absolutely true.
• In addition, the output of a simulation has to be interpreted in an effective way in order to
find an optimal resolution. This may require a complex data analysis which beats high risks
of error created by the user.
How it works
Simulation models, so called ABMs (agent-based modelling), are based on agents (from the Latin
agens, identifying someone or something that does something, sometimes even by describing the
means through which such action occurs) that interact and move coordinated within the virtual
environment in which they "live". A more operational definition of agents, useful to explain their
role in the simulations, is provided by Shoam (1997, pp. 272): "an agent is an entity whose state is
viewed as consisting of mental components such as beliefs, capabilities, choices, and
commitments”. The actions of agents, usually an expression of these mental components, are
based on perceptions of the environment in which the agents operate. The behaviours that
emerge from the individual agents in the interaction with others and with the environment create
a particular system (economic, territorial, social, etc.) through a bottom-up mechanism. These
behaviours are therefore defined by rules that allow the agent to evaluate its own status (priority,
preferences, and available resources) and consequently make decisions. The different behaviours
of several agents together can finally create something totally new, something that is not
deductible from the mere sum of the behaviours. That is the reason why we talk about complex
systems.
It seems only right to open a small parenthesis here to explain the difference between
complicated and complex in this situation. A system is complicated if it is difficult to understand,
but once you understand the function of each part, you can also include the operation of all
parties, because it is simply given by its sum or overlap. In a complex system, understanding how a
single agent (whether person, animal or thing) behaves does not ensure understanding the
phenomenon that emerges from the interaction between more agents, because often this
interaction gives an added value that cannot be estimated from the study of the individual parts.
An interesting reading in this regard is Seth Lloyd, who developed, a physicist at MIT and the Santa
Fe Institute, who developed the so called Complexity theory (the institute also provides courses on
NetLogo, with video tutorials tours, slides and test for free).
Let's Simulate
Now we can narrow down the simulation as part of ABM. We describe our situation in a software
program applied to the analysis of an environmental system circumscribed, conducted by actors
that perceive a certain state of the system, interact with one another and express some
preference structure that tend to change over the same simulation. Once the model is built, it
must be translated into a language appropriate to the use of the program. This should not scare
you if you do not know programming languages general purpose as Pascal, C, or specialized
languages as SIMSCRIPT, ModSim, GPS. There were many interactive applications developed that
are easy to use for everyone but are much more suitable for quickly build models which are still
sophisticated.
There are several software platforms for the construction of ABM. Among the best known:
• Swarm, http://www.swarm.org;
• Netlogo, www.ccl.northwestern.edu/Netlogo.;
• repast, http://repast.sourceforge.net/;
• Ascape, http://www.brook.edu/dynamics/models/ascape/;
• StarLogo, http://el.www.media.mit.edu/groups/el/Projects/starlogo/;
• AgentSheets, http://www.agentsheets.com;
• AutoMod, http://www.automod.it/v2/index.php;
• SIMUL8, http://www.simul8.com/;
• Arena simulation, http://www.arenasimulation.com/Arena_Home.aspx;
• EcosimPro, http://www.ecosimpro.com/.
An Example using NetLogo
To design an example of a simulation I chose the platform NetLogo Version 5.2.0. The software
combines the performance of a powerful programming tool with the advantage of having a
graphical interface which is simple and immediate to commands. The program has an excellent
graphics support and many advanced features for implementation. Moreover, it is able to simulate
very complex systems that evolve over time. There are several tutorials online that can be used for
creating models. Additionally there are simulations in the Models Library of the program, useful
for information about the countless fields of investigation in which the program can be used as the
ABM source for basic procedures. It is challenging and interesting to note the wide variety of areas
referred to by the simulations which are present in the log: biology, mathematics, economics,
sociology, medicine, chemistry, retrogames, etc.). In addition to the interaction with the existing
models, NetLogo is also an environment Authoring (Creation) that allows users to create their own
models. NetLogo, in fact, is quite simple to allow ordinary users to easily perform or even build
their own simulations, and it is advanced enough to be used as a powerful forecasting tool by
experiences researchers. There are also some useful applications for using NetLogo that facilitate
interaction. The description of which and some possible implementations are available in the
"features" on the site http://ccl.northwestern.edu/netlogo/docs/
The software has the potential to operate in all important operation platforms (Mac, Windows,
Linux) thanks to the programming language Java. The screen that appears when opening NetLogo,
presents a black box where the simulation models will be displayed (with the help of colours,
images and wallpapers), a 2D representation of a world made of turtle and patch. You can also
open the 3D view, using the 3D button.
Figure 1. Home Screen- Interface
What is named “Patches” and “Turtles” above are only two of four possible agents that will make
what is just a black box at first become "a populated world". The former (patches) are the
background upon which you move the latter (turtles). Both have the coordinates to be "arranged"
in an environment: (pxcor: pycore) for Patch and (xcore: ycore) for Turtles, only that the former
are stationary and arranged in a grid, whereas the latter will move in the world according rules
assigned by the user. Since they are not created automatically, the Turtles can be created by the
observer and the patches and may take different forms (some of them are very funny and you can
also import or create your shape from the library: going on the top bar → Tools → Turtle shapes
Editor).
The other two agents that populate NetLogo are the links and the observer. The first, defined by
two points for each turtle, connecting the latter to form networks and grids. The observer exists
because the first three agents are not able to control their own commands independently, it acts
as a supervisor and it is “located” outside of the turtles and patches, without having a specific
location. It can be useful to group these agents, in order to make the language more powerful and
flexible, in subgroups such agent-sets. The actions are assigned to agents by commands and
reporters. The controls define actions that agents must fulfil; reporters perform operations and
report a result to a command or to another reporter. Commands and reporters already in NetLogo
are called primitive, and are listed in a special dictionary, which can be downloaded from the this
website: http://www.cytomaize.org/outreach/sas/p/ppts/NetLogo%202.1/docs/dictionary.html ).
Those defined by the user, instead, are called procedures. Each procedure begins with the name
assigned by the keyword "to" and ends with the keyword "end".
Once defined, a procedure can be used in any part of the program.
The variables are the characteristics associated to the agents, indicated by values. They may be
global, refer to the patches or turtles. Some variables are already existing in NetLogo such as, for
example, the colour of the turtles or patches, while others may be defined user through the
In the main NetLogo interface, above, there are three labels: "Interface", "Information", "Code".
In the "Interface" (Figure 2) it we can be see then running of the model. Below the labels is the
toolbar that contains several buttons that allow you to create, modify or delete elements in the
interface mode, which and we will see gradually by in the example. The buttons (drop-down menu
in Figure 2) allow the user to check and change the model without acting writing continuously on
the code. For does this purpose interface there are created at least two buttons created on the
interface, which can handle the setting and the subsequent launch of the simulation: the setup
and the go buttons.
Figure 2. Interface
There are two different types of buttons: the button once and forever button. The first triggers a
procedure that will stop as soon as it comes to completion, so when the program read one times
all the rows of the “procedure” code ore “setup” code. The second triggers a procedure that needs
a second pressure to be stopped (e.g. go). If you want to assign to the button by a different name
and procedure to the button to which it refers, go to in the Display name of the button and you
can change type any label.
Other features are:
The “sliders” on the other hand (Figure 5) are global variables that apply to all agents of the
model. They allow to change the values of some variables in a quick and immediate
manner. In practice, without having recoded procedures, but simply moving the bar from
one value to another, the user can instantly observe the changes in the model.
The “chooser” provides the ability to assign values to the global variables by setting a menu
of alternatives as users that agents can be followed by agents.
The “monitors” are viewers that allow us to see the current value of a variable, as well as a
complex expression also which is updated automatically based on the timeline set. The
plots are graphs displaying the development of data in real time which of the data that the
model generates during the simulation.
“Text boxes” are useful to write down information about the model directly in the interface
section. The Command Centre, located always inside the interface on the bottom, allows
you to enter commands directly without adding them to the procedures of the model that
remain so unchanged, so you can manipulate the agents in order to observe immediately
rations to different commands assigned. The commands are placed in the line observer.
Once you launch a command it will be moved in the white space above with all previous
commands forming a list available and can be called in a special menu, which is you may
cancel by clicking on the clear button.
In the section Information (Figure 3) there is information introduced relating to into the model and
explains the way in which we can use it, explore it, but also extend it.
Figure 3. Information
The Code section (Figure 4) stores the code of the model. Indeed, while in the Command Center
commands are not permanent, those that are found in the code determine the structure of the
simulation and are permanent. Under the series of sections is a bar that contains a set of controls.
The commands are different for each card-section.
Figure 4. Code
After this first introductory phase of the peculiarities and structure of the program, let's develop a
simulation model itself (it is recommended to keep on hand a glossary of primitives).
The example:
The agents (or turtles), meaning the protagonists of the simulation, are university students divided
into two main categories: cooperative students and competitive students. Each student category,
according to its characteristics, interacts in an environment recreated to provide knowledge and
develop knowledge. In practice, the two types decide according to the "attitudes" which have
been prescribed to them (through the instructions given to the agents in the code) and how to
deal with the learning process. By all of these interactions between agents you can analyze how
often students sprout or disappear, how often they behave competitively or cooperatively. In
reality this difference is always present and seems to have found an equilibrium, the purpose of
the simulation is to understand under which conditions this balance is present (with which
parameters) and observe if by changing the instructions that agents follow (both of turtles and
patches) a new equilibrium can be found.
The model begins by mentioning the global variables as “Globals” (which refer to the entire
context) and their proprietary (i.e. those variables that refer only to the agent who is associated).
Then species of turtles used in the simulation are defined:
The model continues by drafting the procedure "setup" (referred to the button that establishes
the initial parameters, and that should always be present in the interface). Remember that each
procedure must begin with "to" followed by a name (this is usually also assigned to the button in
the interface), and ends with "end":
After setting the setup parameters we pass to the second button, which is essential for how the
program works: go. As mentioned, this button is used to run the model continuously. Is the button
pressed, the pattern runs and does not stop until it is pressed a second time. The model could
therefore potentially run indefinitely.
This procedure has the following features:
As you can see within the code written so far, some procedures have been "recalled", this means
that such procedures are defined and configured in another section of code which, with a single
command line, are easily called on. At this point, it is important to note that the procedures will
be executable only when the under-mentioned procedures will be completed. The plot written in
code will have an equivalent configuration interface and global variables created by us will have
sliders in the interface to define the numerical value.
The procedures referred to are divided into two procedures that characterize the environment
(Patches) which moves the agents (growth-awareness and colour-concepts) and two that instruct
the turtles on the way of interaction with other agents and the environment (dissemination and
learning):
After configuring the plot in the code, we will end the process in the interface mode adding the
actual graphics support and setting its values. We have seen the commands that define the actions
the agents must fulfil; we conclude the list of code with reporters that perform operations and
report the result to a command or another reporter (in this case to a command):
At this point the part of the code is completed, we have drawn the architecture of our simulation,
but still cannot start the experiment. As we have said before the graphical user interface is closely
linked to the code in order to define the variables that we included (e.g. t-waiting, n-steps, cost-of-
diffusion, cognitive-processes, etc.). As long as all the sliders, corresponding to all twelve global
variables inserted, will not have been defined in the program we will not be able to "read" (or
compute) the numerical values that we want to assign to those variables. This table lists all the
values of the sliders in the simulation: The content of the last column (value) corresponds to the
actual parameters of the slider starting time of the simulation and they can be changed by simply
sliding the bar. These variations are helpful to simulate different scenarios, in fact, changing the
values attributed to the twelve variables included, the agents will create interactions and the
outcome still unpublished are sometimes unpredictable. Also the arranged sliders simulation is
ready to be launched, but if we want to see the flow of the cycles in real time and the increase or
decrease created in turtles, we need to set the parameters of the monitor (time, cooperative,
competitive).
Nothing is easier than to create your monitor from the list of buttons in the interface and write
time in reporter section of the dialog box. Repeat this for the remaining two monitors writing the
section reporter, respectively, count cooperative-students and count competitive-students, you can
add in the Display Name, simply name them "Cooperative" and "Competitive". Finally, we can find
in the code the check button, which reveals errors in the code. Even in case of errors in the
connection between the code and the interface. If the check result is positive, the simulation is
ready to be launched. It 's time to go back in the interface mode, press the setup button to set the
initial moment, and start the simulation with the button go. Have fun changing the parameters
with the Sliders also during construction. Once you have learned the rudiments of an ABM in
NetLogo, you can create new and original simulations very easily. Increasingly refining your
technique, the ABM will become the tool that can give "life" to your ideas, visions and follies.
An old saying reminds that "the finer simulation is good use of the truth" and reading this, a
young thinker might ask, "What is truth? Concept or a rigid and dichotomous rather a gradient
value, as suggested by the fuzzy logic? I can still imagine worlds Different? I could try to create
one ... ". Now is the time to become "the Demiurge" (craftsmen).
Bibliography
Shoham, Yoav (1997): An overview of agent-oriented programming. Software agents 4.
Tisue, S., & Wilensky, U. (2004, May): Netlogo: A simple environment for modeling
complexity. In International conference on complex systems.