1. Home
  2. Docs
  3. A set of tutorials
  4. Building a Block World
  5. Preliminaries: Block Worlds for Teams

Preliminaries: Block Worlds for Teams

Before we start coding, a bit of background on what we will build.


BW4T

The Block Worlds for Teams, or BW4T for short, is an agent coordination and communication test-bed. See this paper by Johnson et. al for a complete description of this test-bed. Currently, the test-bed is developed and maintained by the Computer Science faculty at the Technical University of Delft in the Netherlands. Do visit their Github page for their version written in Java, they use it to research the Belief-Design-Intentions (BDI) agent programming paradigm.

The BW4T test-bed consists out of multiple rooms containing coloured blocks. Two or more agents that do not see each other need to collect these coloured blocks and deliver them to a drop off point that dictates the block colour and order of collection. The difficulty lies not in solving this task, but in doing so efficiently. A straightforward approach would be for each agent to memorize which coloured blocks need to be collected in which order, followed by exploring rooms until the first block is found and return this to the drop-off point and repeat for the second block. However, even with two agents this is clearly sub-optimal. Within the research field Human-Agent Teaming this is called opportunistic interdependence: The agents are not obliged to communicate, but if they do they can perform the joint task of collecting blocks a lot better.

A classic example of both required and opportunistic interdependence in the joint task of traversing a railway. The left shows two trains where one train pulls the other, making their interdependence relation required for them to both travel the railway. The right shows two people walking the rails while holding hands to maintain a better balance. Holding hands is not required, but it does improve their joint performance. Image obtained from Johnson et. al (2014)

So, if you are a bit like me you probably crave for a visualization. To the left a screenshot from the Java BW4T implementation (image source). It shows a single agent, here visualized as a black block, a number of rooms (the dark grey rectangles) filled with coloured blocks, and a brown drop off point. The bottom shows which blocks need to be collected and their order from left to right. Some additional features is the ‘ticks per second’ slider, a drop-down menu to select a map (here set to random), a reset button and a checkbox to enable collisions between agents and blocks.

The purpose of the BW4T test-bed is numerous. Among other, it can be used to evaluate new agent programming paradigms and do user experiments on human-agent communication. We will leverage MATRX in the upcoming tutorials to bring BW4T to the world of Python and all the tools we have available in that language. The aim of these tutorials is to familiarize you with the basics of MATRX, from building a complex world to the development of custom autonomous and human agents. In addition it explores some of the uses of MATRX; simulating many runs with autonomous agents and the basics for setting up a user experiment with a human controlled agent.

Since this is a tutorial on the basics of MATRX, we will minimize the complexity of all non-MATRX related features and those that require advanced MATRX skills. This means that not all BW4T features will make it (e.g. the slider or checkbox in the image), but a lot will.

If you are curious, a fully fledged BW4T task will be implemented soon and will be one of the first tasks that will be included as an out-of-the-box World in MATRX. This is the Github page for that.

The flow of this series of tutorials is as follows:

  1. Step 1: Environment Design
    In this first tutorial we describe our environment and what the task is that the agents have to perform. We will also build the first version of the environment (e.g. the rooms, blocks, and drop zone).
  2. Step 2: Random Environment
    This second tutorial we explores the Builder’s capacity to add randomness to this environment. Here we will adjust our World’s blueprint such that each time a World is created by the Builder, it is different.
  3. Step 3: World’s Goal
    In the third tutorial we will build the World’s goal check. The job of this check is to verify that all blocks are collected in the right order, and if so, terminate the World. We will add a simple Human Agent to the World to test this check in the same tutorial.
  4. Step 4: Autonomous Agent
    In this tutorial we will build a very simple autonomous agent that solves the collection task. It is simple because it will look at the next block that needs to be collected and starts a search for it. If it finds that block, it will bring it to the drop zone and drop it if it is still the next required block.
  5. Step 5: Data Logging
    Here we will add MATRX’ loggers to our World that logs generic data (e.g. which action is taken when) but also data specific to our World (e.g. which blocks are picked up). This tutorial shows how you can use MATRX’ predefined loggers but also make your own to log data from the World and from Agents.
  6. Step 6: Agent Communication
    To improve our simplistic Autonomous Agent, we will introduce agent-agent communication in this tutorial. We will show the concept of ‘team’ as implemented in MATRX and how this makes it easy to implement the sharing of information between agents of the same team. We will also show how the more explicit communication between agents works in MATRX, using our straightforward messaging system. On top of adding this communication, we will also alter our Autonomous Agent to actually respond to new information to make a better Agent that can work in a team.
Was this article helpful to you? Yes 1 No

Leave a Reply

Your email address will not be published. Required fields are marked *