You are here

Key Topics

More on NetLogo

Having downloaded NetLogo and played around with it for a while, I am unsure whether it will meet the needs of our modeling project.

  • NetLogo is particularly aimed at modeling systems as they adapt over time. Agents in NetLogo continuously respond to each other's decisions, resulting in an ever-changing environment. To a great extent, we are interested in modeling a system that will develop over time: at a farmers' market, for example, a seller makes a decision (setting up a vendor station), a buyer makes a decision motivated by the seller's decision (walking over to the vendor station), then another decision (whether or not to buy from the this particular vendor), etc. For these types of interactions, it is crucial to have a simulation program that effectively displays change over time in the system, showing how decisions by each agent impacts each following decision by other agents.
  • NetLogo allows one to easily change the variables in the system. For example in the "Cooperation" (of cows) model contained in the NetLogo models library, meters representing initial number of cows, cooperative probability, reproduction cost, etc. can be adjusted with a click of a button. This is just what we need for our model. We would have a meter representing number of buyers, number of sellers, buying probabilities of each one, price constraints, etc.
  • Having examined many of the models in the NetLogo model library, I am not sure that the program will allow for the level of complexity that we require. We need to have several groups of buyers, each of which has different characteristics and behaviors. The models contained in NetLogo's library have about five adjustable parameters – our program would need many more. Though I don't know that NetLogo cannot provide for this, I am skeptical because none of the provided models shows this type of control over the system, or a system with this degree of complexity.

It should be noted that I do not know the language that NetLogo uses; therefore, my ability to experiment with the program was limited. NetLogo does use a fairly simple programming language, but I did not find it a good use of my time to become familiar enough with it to be able to create my own models.

Conclusion: Though NetLogo may be the most widely-used agent based modeling program, I am skeptical that it will meet our needs. At this point in my research, I have found three programs that appear suitable for the models we want to create: RePast, Ascape, and the at-this-point-in-time only Japanese PlatBox. In order to be sure whether or not NetLogo belongs on this list, I would have to experiment with the program with its required language.

Directory of agent-based modeling links

Located here is a directory of links to applications of agent-based modeling, arranged by subject area. Of greatest importance to us is the economics section, which includes such projects as "artificial life simulation of the textile/apparel market," and "agent based simulation of the hotelling game." The page is put together by Craig Reynolds.

Some articles on agent-based simulation

Just to update on some of the work I've been doing, here and here are links to a couple articles I've read about agent-based simulation that I did not find worthy of individual write-ups as they are not particularly useful to our project. The first article, by Robert Axelrod, presents a walk-through for those who plan to begin an agent-based simulation project, but does not really advance any new ideas for us. The article I've linked to is part of a larger publication of Axelrod's, called "The Complexity of Cooperation: Agent-Based Models of Competition and Collaboration." The second article is entitled "Agent-Based Computational Economies. It is more or less a recitation of ideas put forth by Leigh Tesfatsion; as such, I do not think it is a necessary read in light of our intensive exploration of Tesfatsion's work.

Conceptual Model for the Canadian Food and Nutrition System

Located here "Conceptual Model for the Canadian Food and Nutrition System," used by Health Canada. This model is more complex than ours will be, as it takes into account five levels of food use: food supply, distribution, consumption, utilization, and health outcome. Our model will certainly elminate the last two, as it will not incorporate the health aspects of the food we eat to that extent.

According to Health Canada, the model "points to the potential areas for data collection, analysis, surveillance related research, dissemination and implementation and supports the need for a systematic approach to surveillance activities, which can be applied to other domains such as research and policy. The Conceptual Model identifies potential linkages across all sectors of the food and nutrition system, including agricultural, social, medical and economic sectors, and the interrelations of food and nutrition to health. It is a starting point to engage partners and stakeholders in a dialogue that can lead to a co-operative approach to surveillance. A comprehensive surveillance system based on the conceptual model will more efficiently support the development of policies in food and nutrition."

A few more agent-based simulation platforms

Moduleco is a "modular "multi-agent" platform, designed for to simulate markets and organizations, social phenomenons and population dynamics."

In addition to being a resource for agent-based modeling information, SwarmWiki is the home of Swarm, one of the original agent-based simulation programs. Swarm is a "multi-agent software platform for the simulation of complex adaptive systems. In the Swarm system the basic unit of simulation is the swarm, a collection of agents executing a schedule of actions. Swarm supports hierarchical modeling approaches whereby agents can be composed of swarms of other agents in nested structures. Swarm provides object oriented libraries of reusable components for building models and analyzing, displaying, and controlling experiments on those models." An in-depth description of Swarm can be found here

The CORMAS programming environment is "oriented towards the building of simulation models, with a specificity in the domain of natural-resources management. It provides a framework for developing simulation models of coordination modes between individuals and groups who jointly exploit the resources."

NetLogo

Given the positive reviews of the agent-based modeling platform NetLogo contained in the article "Agent-Based Simulation Platforms: Review and Development Recommendations" (see my earlier blog about this article), it is worthwhile to add a direct link to NetLogo. From this page, one can read about and download the program. Once downloaded, one can play around with the sample models that come along with NetLogo (more on this later).

An article comparing five agent-based simulation platforms

Here is an article entitled "Agent-based Simulation Platforms: Review and Development Recommendations," written by Steven F. Railsback, Steven L. Lytinen, and Stephen K. Jackson. This article compares five agent-based simulation platforms: NetLogo, MASON, Repast, Objective-C Swarm, and Java Swarm. The five platforms were reviewed by implementing example models in each. Some important findings from this study include:

  • "Swarm was designed as a general language and toolbox for ABMs, intended for
    widespread use across scientific domains. Swarm's developers started by laying out
    a general conceptual approach to agent-based simulation software. Key to Swarm is
    the concept that the software must both implement a model and, separately, provide
    a virtual laboratory for observing and conducting experiments on the model. Another
    key concept is designing a model as a hierarchy of "swarms", a swarm being a group
    of objects and a schedule of actions that the objects execute. One swarm can contain
    lower-level swarms whose schedules are integrated into the higher-level swarm's; simple
    models have a lower-level "model swarm" within an "observer swarm" that attaches
    observer tools to the model. The software design philosophy appears to have been to
    include software that implements Swarm's modeling concepts along with general tools
    likely to be useful for many models, but not to include tools specific to any particular
    domain. Swarm was designed before Java's emergence as a mature language. One
    reason for implementing Swarm in Objective-C was that this language's lack of strong
    typing (in contrast to, e.g., C++) supports the complex-systems philosophy of lack of
    centralized control; e.g., a model's schedule can tell a list of objects to execute some
    action without knowing what types of object are on the list. Swarm uses its own data
    structures and memory management to represent model objects; one consequence is
    that Swarm fully implements the concept of "probes": tools that allow users to monitor
    and control any simulation object, no matter how protected it is, from the graphical
    interface or within the code."
  • "Java Swarm was designed to provide, with as little change as possible, access to Swarm's Objective-C library from Java. Java Swarm was motivated by a strong demand among Swarm users for the ability to write models in Java, not by the objective of providing Swarm's capabilities as cleanly and efficiently as possible in Java. Java Swarm therefore simply allows Java to pass messages to the Objective-C library, with work-arounds to accommodate Java's strong typing."
  • "Repast development appears to have been driven by several objectives. The initial
    objective was to implement Swarm, or equivalent functionality, in Java. However,
    Repast did not adopt all of Swarm's design philosophy and does not implement swarms.
    Repast was also clearly intended to support one domain – social science – in particular
    and includes tools specific to that domain. The additional objective of making it
    easier for inexperienced users to build models has been approached in several ways by
    the Repast project. These approaches include a built-in simple model, and interfaces
    through which menus and Python code can be used to begin model construction."
  • "MASON was designed as a smaller and faster alternative to Repast, with a clear
    focus on computationally demanding models with many agents executed over many
    iterations. Design appears to have been driven largely by the objectives of maximizing
    execution speed and assuring complete reproducibility across hardware. The abilities
    to detach and re-attach graphical interfaces and to stop a simulation and move it among
    computers are considered a priority for long simulations. MASON's developers appear
    intent on including only general, not domain-specific, tools. MASON is the least mature
    of these platforms, with basic capabilities such as graphing and random number
    distributions still being added."
  • "NetLogo clearly reflects its heritage as an educational tool, as its primary design
    objective is clearly ease of use. Its programming language includes many high-level
    structures and primitives that greatly reduce programming effort, and extensive documentation
    is provided. The language contains many but not all the control and structuring
    capabilities of a standard programming language. Further, NetLogo was clearly
    designed with a specific type of model in mind: mobile agents acting concurrently on
    a grid space with behavior dominated by local interactions over short times. While
    models of this type are easiest to implement in NetLogo, the platform is by no means
    limited to them. NetLogo is by far the most professional platform in its appearance and
    documentation."
  • The Objective-C version of Swarm "is the most mature library platform and is stable and well-organized. Objective-C seems more natural than Java for ABMs but weak error-handling and the lack of developer tools are drawbacks."
  • "A rough comparison of execution speed found MASON and Repast usually fastest, Swarm fastest for simple models but slowest for complex ones, and NetLogo intermediate."
  • "MASON, Repast, and Swarm provide explicit methods for scheduling actions both in fixed time and dynamically. Because it was designed primarily for one kind of model, NetLogo provides fewer tools for explicit control of scheduling."
  • MASON, Repast, and Swarm use the same, somewhat complex, three step process to display agents in space. "NetLogo, in contrast, automatically draws agents on a built-in animation window; users can customize shapes and colors."
  • "Netlogo, with its heritage as an educational tool, stands out for its ease of use and excellent documentation. It is easy to recommend NetLogo for models that are (1) compatible with its paradigm of short-term, local interaction of agents and a grid environment and (2) not extremely complex."
  • "MASON could be a good choice for experienced programmers working on models that are computationally intensive, e.g., having many agents or long run times.

This article was found at the Agent-Based Modeling Resources Page of swarm.org

Two Popular Agent-Based Simulation Platforms: RePast and Ascape

RePast and Ascape appear to be the two most popular platforms for agent based modeling. Repast (Recursive Porous Agent Simulation Toolkit) was developed at the University of Chicago. It is intended primarily for use in the social sciences, and seeks to "support the development of extremely flexible models of living social agents." Models can be written in RePast using several programming languages, including Java, C#, and Python. As I know none of these languages, I was limited in my ability to experiment with RePast. Despite these limitations, however, I formed the opinion that RePast would be a suitable platform for our simulation game. It allows for the depth of interactions and behaviors, as well as the diversity of characterizations that are a necessity for our project.

Ascape, written in Java, is a "software framework for developing and analyzing agent-based models." In Ascape, agents exist within "Scapes" – collections of agents that are themselves agents. Agents interact within these scapes, which govern the actions of the agents contained in them. Ascape supports complex model design, but can also be explored by those unfamiliar with programming.