Learning Abstract Properties of Swarm Systems Don Miner
Marie desJardins
University of Maryland, Baltimore County 1000 Hilltop Circle Baltimore, Maryland
University of Maryland, Baltimore County 1000 Hilltop Circle Baltimore, Maryland
[email protected]
[email protected]
ABSTRACT Rule abstraction is an intuitive new tool that we propose for implementing and controlling swarm systems. The methods presented in this paper encourage a new paradigm for designing swarm applications: engineers can interact with a swarm at the abstract (swarm) level instead of the individual (agent) level. This is made possible by modeling and learning how particular abstract properties arise from lowlevel agent behaviors. In this paper, we present a procedure for building abstract properties and discuss how they can be used. We also provide experimental results showing that abstract rules can be learned through observation.
General Terms Emergence
Keywords swarms, multi-agent systems, learning, control
1.
INTRODUCTION
Emergent behavior in a swarm system is the result of multiple agents’ independent behaviors. These agents do not reason about the emergent behavior that results from their collective actions; they simply follow a set of basic local rules that govern their behavior. We call these emergent behaviors abstract properties and the agent programs the low-level rules. For example, army ants create efficient two-way highways from the nest to food sources[5]; the characteristics of these highways are abstract properties of the swarm. This emergent behavior results from the ants following pheromone trails, avoiding collision, and obeying other low-level rules. In this paper, we propose a method called Rule Abstraction, which designers can use to represent the correlation between low-level rules and abstract properties. Continuing with our ant example, abstract properties for this system would map the ants’ low-level rule parameters to the length, width and speed of the two-way ant highways. Cite as: Learning Abstract Properties of Swarm Systems, Don Miner and Marie desJardins, Proc. of 8th Int. Conf. on Autonomous Agents and Multiagent Systems (AAMAS 2009), Decker, Sichman, Sierra and Castelfranchi (eds.), May, 10–15, 2009, Budapest, Hungary, pp. XXX-XXX. c 2008, International Foundation for Autonomous Agents and Copyright Multiagent Systems (www.ifaamas.org). All rights reserved.
Designing and debugging swarm systems is an art, and there are a number of stumbling blocks when implementing swarm applications: • Identifying and then hand-engineering the individual agent rules and interactions is difficult. • Discovering which subset of the individual behaviors is causing undesirable emergent behavior during debugging often involves many iterations of manual trialand-error. • A large set of rules without any structure can become disorganized, making debugging, modifying, and maintaining applications difficult. • From an end-user perspective, understanding how the low-level behaviors specifically result in a particular swarm-level behavior is difficult. Therefore, controlling the swarm using the low-level rules is not intuitive. To make multi-agent system development simpler, several frameworks have been developed [4][9], but many fail to address swarm-level control. Other frameworks provide a richer set of tools but are domain-dependent [1][14]. Rule abstraction solves these problems by enabling intuitive swarmlevel control with a domain-independent approach. Rule abstraction is the result of our goal of designing and controlling swarms at the swarm level. With existing approaches, shaping emergence involves an iterative process of adjusting the low-level rules and then observing the result. By contrast, rule abstraction permits swarm system designers to adjust the behavior of the swarm in terms of the emergent behavior, not the low-level rules. This approach is more intuitive because the user controls the emergent properties directly, instead of indirectly through the low-level rules. Rule abstraction can potentially be applied to a wide variety of domains that have previously been developed and modified by hand-tuning low-level rules; these domains include swarm-based optimization algorithms (such as ant colony optimization[6], particle swarm optimization[7], and stochastic beam search[3]), multi-robot systems (such as the swarm-bots project[10] and McLurkin’s robot swarm[8]), and biological simulations (such as ant simulations[2][5], flocking[12], and fish schooling[11]). Providing swarm-level control through rule abstraction requires solving three main problems: • The Specification Problem – the designer must be able to measure an abstract property of interest;
• The Mapping Problem – the system must be able to map low-level agent behaviors onto the values of an abstract property; and • The Reverse Mapping Problem – the designer must be able to control the swarm by specifying a desired value (or change in value) of a swarm-level property. This paper focuses on methods for solving the mapping problem and the reverse mapping problem. We provide an approach and empirical results using two abstract properties, circle-radius and boid density, as examples of rule abstraction. We use a systematic sampling and interpolation approach to construct a mapping from low-level rules to an abstract property and vice versa through a set of observations. In addition, we provide a simple query language that acts as an interface to these mappings. In he next section, we provide an extended example to illustrate the need for rule abstraction. We then formally define rule abstraction and present our approach for mapping low-level rules onto abstract properties, and for swarmlevel control by reverse mapping the target abstract property onto low-level parameters. Finally, we provide experimental results for two separate domains, discuss future work and conclude.
2.
SWARM-LEVEL CONTROL EXAMPLE
To illustrate the concept of swarm-level control, we use “Boids,” a classic rule-based computer graphics technique by Reynolds [12] in which a swarm of agents produce flocking behavior in a two- or three-dimensional Euclidean environment. Realistic flocking behavior emerges from each agent adhering to three simple rules: (1) avoid being too close to other agents, (2) tend towards the average location of nearby agents, and (3) move in the direction in which other agents are moving. Each of these rules has an associated parameter that indicates its strength relative to the other rules. A group of boids flocking is shown in Figure 1. Controlling this group of agents as a whole is challenging because modifications to the swarm-level behavior may require adjustments to one or more of the three low-level rules. We can improve the control of the Boid application by using our rule abstraction method to add a new abstract property, density, which describes how tightly the boids move together. Density can be mathematically defined as the area covered by the agents divided by the number of agents in the flock. For example, the swarm in Figure 1 has a higher density than that of the flock in Figure 2. Intuitively, decreasing the density of the flock corresponds to making the boid avoidance rule stronger and the other two rules weaker. However, the exact connection between particular values for the parameters of these low-level rules and the resulting density is not obvious from inspection. Once the abstract property is implemented, changing the density only requires the adjustment of one parameter instead of all three. Additionally, adjusting an abstract property that represents density is more intuitive from the user’s perspective than adjusting three rules that produce the emergent behavior indirectly. Rule abstraction may also be used in the other direction to predict the behavior of the swarm based on its low-level parameters. For example, the density value of a flock can be estimated by knowing the low-level parameters.
Figure 1: A swarm of boids flocking in a twodimensional environment.
Figure 2: A swarm of boids flocking in a twodimensional environment. This swarm is less dense than that in Figure 1.
3.
RULE ABSTRACTION
Rule abstraction is the process of finding a correlation between low-level rules and abstract properties. In this section, we expand on this definition by explaining its components and the methodology for discovering these correlations. Then, we explain how users can submit queries to use abstract properties for swarm control. Abstract properties are used to relate the agents’ low-level behavior to a single abstract parameter. An abstract property is represented as a function (often user-provided) that yields a quantitative value based on a swarm’s emergent behavior. For example, the density rule in the Boids domain can be described as the number of agents divided by the area covered by the swarm. The parameters of the low-level rules are values that modify the behavior of the rule. For example, an agent’s center rule in the boids domain generates a velocity vector towards the center of the swarm (c) with a magnitude of rcenter ∗ distance(agent, c). The parameter of the center low-level rule is rcenter because it adjusts the strength of the behavior. If the low-level parameters for rules r1 , r2 , ..., rk are denoted by a parameter vector r = r1 , r2 , ..., rk , and the parameter of an abstract property of interest is denoted as a, then the connection between the low-level and abstract parameters can be represented by a mapping function T : r → a, as illustrated in Figure 3. Learning these mapping functions is the fundamental challenge in solving the mapping and reverse mapping problems. Although T could possibly be manually specified, a more practical approach would be to learn the mapping function by observing the swarm-level behavior in various conditions. The goal is to learn how changing the low-level parameters affects the value of the abstract property (the mapping prob-
Rule (r1) Rule (r2) Abstract Rule (a)
a= T(r1, r2, ... , rn)
Rule (rn)
Figure 3: The mapping between low-level parameters and an abstract property can be represented as a mapping function T : r → a.
lem) and vice-versa (the reverse mapping problem). For example, in the Boids application, increasing the strength of the avoidance rule (agents avoid being too close to one another) will increase the density. However, if we lower the strength of the avoidance rule and increase the strength of the center rule (agents tend to the center of the swarm) simultaneously, we would observe that the swarm’s density is considerably higher. We will discuss the sample/interpolate method for learning abstract properties after we outline the necessary use cases in the following subsection.
3.1
Using Abstract Rules
Given a mapping function T , the value of a can be predicted for any particular values or set of values of the lowlevel parameters r. Conversely, if we invert the mapping function T , we can identify appropriate values of low-level rules. These are the solutions to the mapping and inverse mapping problems, respectively. Both of these functionalities are provided by our basic query language. The query language is the user interface to the abstract property: it enables the user to submit constraints on the low-level rules’ parameters and a target value for an abstract property. The system then provides a suggested solution to satisfy the user’s constraints. The structure of a query is a list of inequality or equality constraints referring to the parameters by name. This list is passed to the mapping method (such as sample/interpolate), which then returns specific values for all parameters in the system that satisfy the constraints. For example, if a user wishes to know the avoidance factor and center factor that result in a density between .01 and .011 in a boid swarm of 100 agents, the user would submit the following query: {.01 < Density < .011; N umAgents = 100}. The user would then receive a result in the form of a list of satisfactory value combinations. The result of a query may contain any number of solutions: zero if the constraints are impossible to satisfy, one if there is a unique set of values that satisfy the constraints, or more than one if there are multiple solutions. In our current implementation of the query interface, we return a list of discrete points that could satisfy the constraints, even though the total number of satisfactory points could be infinite. We plan to explore the possibility of returning a function that describes a continuous range of possible solutions, instead of discrete points, in future work. Queries to abstract rules can serve several purposes. The first of two major types of queries is direct mapping. Di-
rect mapping simply uses the original mapping (from lowlevel rules to abstract properties) to look up values of abstract properties given particular low-level parameter settings. With this type of query, we can determine how a swarm will behave without measuring the emergent property while the swarm system is running. Without direct mapping, the swarm would have to be executed (in simulation or in the true domain) to determine if the specified low-level parameters would result in the desired emergent behavior. If the result was not satisfactory, the parameters would have to be adjusted and the swarm executed again. This is unacceptable if the swarm system takes a significant amount of time to run (e.g., in multi-robot systems). Direct mapping enables interactive planning of swarm systems in one step, without simulation or trial-and-error iterations. The second type of query provides users with swarm-level control, which is the main goal of our research. We call this type of query a reverse mapping because the original mapping (from low-level rules to abstract properties) is inverted, yielding a mapping from abstract properties to lowlevel rules. Reverse mapping does not necessarily have to be used directly by the user: it can serve as an interface between a swarm system control panel and a running swarm system. For example, a flocking swarm could be displayed moving around an environment while the user has access to a sliding bar that represents the abstract property density. The user would be able to adjust this slider and the density of the swarm would change accordingly in real time by applying the low-level parameters that are returned by the query. The rule learning method used (e.g., sample/interpolate) should be able to create a mapping that responds to both of these types of queries. The particular approach is not significant as long as the method supports the query language. That is, if the learning method results in a mapping that can support the query language, the actual learning method may be treated as a black box to the user.
3.2
Sample / Interpolate
Our learning method, sample/interpolate, constructs a mapping between low-level rules and abstract properties. This method, as suggested by the name, has two major phases: 1. Systematically sample a large number of data points (by simulating or executing a swarm system) and record the low-level parameters along with the resulting abstract property value. 2. When the abstract property is queried, use interpolation to determine a suitable value. The systematic sampling may be done only once, although it may be augmented later if more parameter settings are observed in the swarm system. Each parameter is sampled in evenly spaced intervals to create a multi-dimensional data mapping that correlates low-level rules with abstract properties. For example, if three low-level rules were sampled for ten values per dimension, we would sample 103 data points and record each resulting abstract property value. In addition, each data point may be an average of several iterations with the same low-level parameter values to decrease error. A data set generated by applying this sampling technique to the circle-radius domain is shown in Figure 4.
Radius
250
0 8000
tor
ac eF
3 Numbe
nc ida
o Av
r of Ag
ents
24
150
Figure 4: Length of the resulting circles’ radius, given the number of agents and avoidance factor. As the avoidance factor increases and the number of agents increases, the circle’s radius increases.
The next step is to utilize multi-dimensional interpolation to satisfy user queries (direct mapping and reverse mapping). Direct mapping (when all of the low-level rules are given) is the simpler of the two queries. When presented with a direct mapping query, we find the smallest hypercube (a cube with the same dimensionality of the data) that contains the point representing the low-level rules. For example, in a domain that has three low-level rules, we find the eight sampled points that form the smallest possible cube around the query’s point. Once these points are selected, we use multi-dimensional linear interpolation (e.g., bilinear interpolation for two dimensions, trilinear interpolation for three dimensions) to determine the abstract property of the desired point inside the hypercube. This interpolated value is then returned to the user. We will show through our experiments that this procedure yields accurate results. Reverse mapping permits the user to specify the values of some of the low-level parameters, along with the target value for an abstract property. These queries are difficult to handle because the interpolation method must be inverted and frequently the result is a set of solutions. We first determine which hypercubes contain desired abstract property values with the intermediate value theorem.1 That is, given the values of abstract properties a = a1 , a2 , ..., a2d (where d is the number of low-level rules sampled) at the corners of a hypercube and the target abstract property value ap , if ∃x∃y(ax , ay ∈ a) ∧ (ax ≤ ap ≤ ay ), then the value ap can be found in this hypercube. Then, we use interpolation to find a gradient inside each of these selected hypercubes that represents all the points that have the desired abstract property value. These individual gradients for each hypercube are combined to generate a piecewise gradient over the entire space. Examples of these gradients are illustrated in Figures 8 and 11. This gradient can easily be narrowed down by applying other user provided constraints on the low-level rules. A subset of possible solutions (with a specified density) is returned since all points satisfy the user’s constraints.
There are several strategies for satisfying the case that the user only desires one point instead of all possible points. Although we leave this up to the user to decide and is not in the scope of sample/interpolate, a few suggested methods are as follows: randomly select a point (since all points satisfy the constraints), select the point in the “center” of the gradient, or select the point closest to the current swarm’s state. Selecting the center of the gradient avoids extreme values for variables. Most frequently, the extreme values for low-level rules create undesired emergent behavior but may still satisfy the abstract property constraint. The other technique, which selects the closest point to the swarm’s current state, is the best choice in real-time systems because the agents’ low-level behavior are adjusted in a gradual manner. Sample/interpolate is extremely flexible and may be viewed as a framework instead of a method. Other interpolation and sampling techniques can be substituted for linear interpolation and evenly spaced sampling, as long as they can support direct and reverse mapping. We have experimented with more complex interpolation methods such as natural neighbor interpolation [13] and quadratic interpolation but, for the scope of this paper, the marginal benefits of these advanced techniques do not outweigh the simplicity and ease of explanation offered by linear interpolation.
4.
RESULTS
To demonstrate that rule abstraction is implementable, functional, precise, and domain-independent, we present experimental results for two domains. The circle-radius domain is a simple domain that we will use to illustrate the rule abstraction process. We then present quantitative results for the boid swarm density domain. Both domains have a variable number of agents that move within a twodimensional environment. Other than this environmental similarity and sharing some low-level rules, the swarm systems exhibit very different emergent behavior. In the circleradius domain, the agents align themselves around a circle’s circumference, forming one unfilled circle. Three low-level rules contribute to this emergent behavior: 1. Avoidance repels agents agentx and agenty away from one another with force: ravoidance /distance(agentx , agenty )2 2. Circle moves an agent towards the perceived existing circle. The agent calculates the average distance from its local neighbors to the center (distanceavg ) and conforms to this distance by moving towards the center with force: rcircle ∗ (distance(agentx , center) − distanceavg ) Note that if distance(agentx , center) is greater than distanceavg , the agent will move away from the center because the difference produces a negative magnitude. 3. Center attracts an agent towards the center of the environment with force: rcenter ∗ distance(agentx , center)
1
If f (x) is continuous on the interval [a, b], and u is a number between f (a) and f (b), then there is a c ∈ [a, b] such that f (c) = u.
This rule is typically relatively weak (rcenter < .01) in this domain.
Figure 6: Boid flocks with 25 members shown in order of decreasing density (left to right).
For simplicity’s sake, we will only vary the parameter of the avoidance rule ravoidance , which repels agents from one another. We treat the number of agents N as a low-level parameter. Although N does not directly affect any individual’s behavior, the number of agents does affect the swarm behavior. Therefore, there are two low-level rule parameters: N and ravoidance . The abstract property we wish to model is the radius of the circle Cr . Circles of different radii are shown in Figure 5. This property is interesting because it is trivial to compute when viewing the swarm in action, but is not immediately obvious from the values of the low-level rules. In the boid swarm density domain, agents follow the traditional Reynolds boid rules [12] that generate flocking behavior. As in the the original work, three low-level rules contribute to this emergent behavior: 1. Avoidance repels agents agentx and agenty away from one another with force: ravoidance /distance(agentx , agenty )2 2. Center attracts an agent towards the center of the flock with force: rcenter ∗ distance(agentx , center) 3. Align steers agents towards the average heading (~vavg ) of neighboring agents. This is done by applying a velocity vector to the current agent’s velocity vx : ~vx = ~vx + (~vavg − ~vx ) ∗ ralign In the experiment, we maintain the align factor ralign at a constant value of .05. Therefore, there are three low-level parameters: ravoidance , rcenter , and the number of agents N . The abstract property we wish to measure is the density ρ of the swarm. Boid swarms of varying density are shown in Figure 6. The density is measured by dividing the number of N agents by the area covered by the swarm: ρ = πC 2 , where Cr r is the radius of a bounding circle. To find the area covered by the swarm, we determine the area of the circle with the center at the average location of the agents and the radius Cr that would contain all agents. Therefore, the area covered is greater if the flock is more spread out. The bounding circle can be seen in a screenshot of our simulation software in Figure 10.
3 0 Radius
Number of Agents
Figure 5: Two circles with different radii. The length of the radius is completely determined by the underlying rule parameters. It is never explicitly specified in the rules.
250 24 150
8000 150 Avoidance Factor
8000
Figure 7: The left plot is a subset of the plot in Figure 4. These sample points are used as the corners of boxes to create a piecewise gradient function, which is shown in the right plot. This gradient is used to determine desired radius values, as seen in Figure 8.
4.1
Circle-Radius
Using the sample/interpolate method, we sampled 21 values for the number of agents N , evenly spaced from 3 to 24 and 49 values for ravoidance , evenly spaced from 150 to 7350. Therefore, a total of 1029 data points were sampled. At each point, the radius formed by the agents was recorded. The result of this sampling is plotted in Figure 4. The data is very smooth because there is negligible variance in the radius over several runs with the same parameter. Given this data set, a user can begin submitting queries. Bilinear interpolation is used to determine the radius of a circle given the two variable parameters. The square that the data point fits into is found and the four corner points are used to interpolate a value for radius. We illustrate this process in Figure 7: a selection of sampled data points are shown on the left along with a high-resolution plot of interpolated points on the right. Using sample/interpolate, we can also determine the values necessary to create a circle of a desired radius. Gradient lines for the target radius are created in each square and pieced together so that the user may select one point as the result of the query. This process is illustrated in Figure 8. We demonstrated that this method works well by applying the abstract property to two thousand random direct mapping queries and recording the error. The error in the prediction is determined by comparing the predicted value and the actual value after running the swarm with the query’s low-level rule parameters. With radii in this sample ranging from 20 to 210 pixels, and using a sample size of 500, the mapping yielded an average error of .23 pixels over the entire query test set. Also, as expected, we found that decreasing the sample size increases the error of the predictions. These results are shown in Figure 9.
50 3
75 100
Number of Agents
125
150
175
200 24 150
Avoidance Factor
8000
Figure 8: The continuous radius gradient is used to find desired radius values. For example, gradient lines for radii of 50 to 200 are shown as cuts in the image. For example, if a user desired a circle of radius 150 with 20 agents, the transfer function determines an avoidance factor of 3500. Sample Size 100 150 200 250 300 350 400 450 500
Average Error 5.636 3.531 2.338 2.012 0.971 0.863 0.427 0.329 0.235
Figure 9: The average error of two thousand random direct mapping queries, varied by the sample data set size in the circle’s radius domain.
4.2
Boid Swarm Density
This domain is more complex than the circle-radius domain because there are three low-level parameters instead of two, which results in a three-dimensional search space. Although this difference may appear to make rule abstraction more difficult, the same methods are applied in this domain as the circle-radius domain. Sampling occurs on the three-dimensional space; trilinear interpolation is used instead of bilinear interpolation; and queries are adjusted to handle one more possible constraint.
4.2.1
Sampling and Interpolation
First, we systematically sampled evenly spaced combinations of the low-level parameters: ravoidance , rcenter , and N . We sampled all 21780 combinations of the following low-level values: 20 values of N from 10 to 29, 33 values of ravoidance from 25 to 825, and 33 values of rcenter from .03 to .99. For each of these data points, the average density of a simulated boid flock over time was recorded. A screenshot of our simulation software in action is shown in Figure 10. To reduce error in the sampling, each data point is the average of five
Figure 10: A screenshot of our boid flock simulation. Statistics and parameters are shown at the top of the screen. The boid agents are shown as dots, along with the bounding circle (used to calculate density) and a line indicating the average direction of the flock
simulations. The sampled points in this data set have an average density of 0.011, ranging from 0.001 to .05 with a standard deviation σ = .0074. From this data we created 19456 adjacent 8-point cubes. For experimental purposes, we can reduce the number of cubes by removing a portion of the sample if the the evenly spaced property is maintained. For each cube, we calculated and stored the maximum and minimum densities over all the 8 points to quickly decide which cubes contain the queried density value. For this domain, our software responds to all types of queries (both direct mapping and reverse mapping) in the same manner. First, the query is formulated as a hypercube. For example, from the query {ρ = 0.115; rcenter < .3; N = 25} (“For 25 agents and a rcenter factor of less than .3, what combination of parameters will yield a density of 0.115?”) we create a two-dimensional square representing varying values rcenter and ravoidance because N is fixed. Then, we identify the relevant cubes as the ones that intersect with this query. Effectively, we filter out cubes that cannot interpolate the value ρ. These remaining cubes are used to generate the gradient returned to the user. Trilinear interpolation is used to interpolate several evenly spaced points inside each relevant cube. We then determine which sub-cubes can interpolate the desired value of density in the same way that relevant cubes were selected in the previous step. This process may be repeated several times to increase the resolution of the gradient. When enough iterations of this process have been completed or a certain error bound has been reached, points representing the relevant sub-cubes are returned to the user. A density gradient is shown in Figure 11. Note that a direct mapping query (e.g., {rcenter = .3, ravoidance = 180, N = 25}) is a special case and is handled as a zero-dimensional hypercube. This single point will only intersect with one cube and will be interpolated at the query point to retrieve a single value for ρ.
4.2.2
Experimental Results
We submitted 50,000 random direct queries to test the accuracy of rule abstraction in this domain. The random parameter value combinations are contained within the sampled data set’s bounds. We compared the actual density pro-
Gradient for Density=.0115 .99
center
center
.99
.03 10
#
ag
800
en
ts
30
75
nce
avoida
.03 75
avoidance
800
Figure 11: Two different views of the gradient for density = .0115. On the left, points show samples of the gradient in respect to the three varied parameters: center, avoidance and number of agents. From this graph, we determine that the number of agents has a minimal effect on the swarm density and that the two important parameters are avoidance and center. On the right, we ignore the number of agents dimension and plot all the points in respect to center versus avoidance. We see that the data shows a mostly linear correlation, except for an inflection point around center = .8. vided by our boid simulation with each predicted value for density and recorded the error. We repeated this experiment several times after reducing the number of cubes by varying amounts. The results of these experiments are shown in Figure 12. From the quantitative results, we conclude that a large number of cubes (around twenty thousand) provides more than sufficient accuracy in direct mapping queries relative to the standard deviation of density values (σ = .0074). Also, as expected, decreasing the number of sample cubes increases the average error significantly. Sample Cubes 19456 2560 320 75 8
Average Error e 0.0004995 0.0025855 0.0041827 0.0058983 0.0063675
Figure 12: The average error of 50,000 queries to determine density and the average error’s proportion to the standard deviation σ = .0074. By inspecting density gradients we were also able to infer some interesting features from the data. The most important observation is that the number of agents N has very little effect on the density. Intuitively, this is because the size of the bounding circle grows linearly with the number of agents while the low-level rules avoidance and center enforce a uniform spreading of agents. This fact is illustrated by the right graph in Figure 11. Also, an inflection point appears in every density gradient we observed, which can also be seen in Figure 11. To determine what causes this, we examined some of the simulations around this boundary. We found that this inflection point represents the threshold at which the center rule over-
comes the avoidance and match rules and causes the agents to cyclically move through the center of the swarm. That is, the avoidance rule is not preventing the agents from moving in and out through the center, causing a behavior more similar to swarming bees than flocking boids.
5.
FUTURE WORK
We are exploring three directions for this research in the near future. First, we are developing an online learning approach that does not use a systematically sampled data set. This method would replace sample/interpolate in some situations. The advantage of this approach is that it will allow users to begin work in a domain immediately, without having to simulate a large number of swarm setting combinations in advance. The obvious disadvantage is that the accuracy of initial queries will suffer. This problem may be solved by making several iterated queries until the result provided is within a certain error bound. The intuition behind this approach is that the actual result must be determined by running a simulation in order to measure the error. This data point would be added to the data set, making the next prediction more accurate. Therefore, a sequence of estimations will become more accurate as more simulations are performed. The second near-term direction is to apply rule abstraction to more domains. In addition to the boids domain, we have implemented an ant colony simulation and several geometric “swarm shape” domains. We wish to find a crossdisciplinary open problem that we can solve with rule abstraction. In addition, we will expand on the sample/interpolate method discussed in this paper by building a library of interpolation and sampling techniques that can be incorporated into our framework. Determining which methods work best
for different domains will give insight in how to solve future unforeseen problems.
6.
CONCLUSION
We have presented rule abstraction, new framework for swarm-level control of multi-agent systems. We demonstrated that rule abstraction is an implementable method that provides accurate results through the two experiments presented in this paper. The methods used in the boids experiment can be expanded to other properties in that domain, as well as properties in other domains, since rule abstraction is domain-independent. Sample/interpolate was used for two different domains with different data dimensionality. In addition, we believe that rule abstraction is flexible enough to handle many different situations. Sample/interpolate may be replaced with other methods that perform the same tasks. We believe that the contributions presented in this paper provide, and will lead to, advances in the intuitiveness in the design and control of swarm applications.
7.
REFERENCES
[1] O. Babaoglu, H. Meling, and A. Montresor. Anthill: a framework for the development of agent-based peer-to-peer systems. In Proceedings of the 22nd International Conference on Distributed Computing Systems, 2002. [2] R. Beckers, J. Deneubourg, and S. Goss. Trails and U-turns in the selection of a path by the ant Lasius niger. Journal of theoretical biology, 159(4):397–415, 1992. [3] J. Bishop. Stochastic Searching Networks. In Proceedings of the 1st IEEE Conference on Artificial Neural Networks, pages 329–331, 1989. [4] N. Collier. Repast: An extensible framework for agent simulation. The University of Chicago’s Social Science Research, 2003. [5] I. Couzin and N. Franks. Self-organized lane formation and optimized traffic flow in army ants. In Proc. R. Soc. Lond. B, volume 270, pages 139–146, 2003. [6] M. Dorigo. Ant Colony Optimization. MIT Press, 2004. [7] J. Kennedy and R. Eberhart. Particle Swarm Optimization. In Proceedings of the 1995 IEEE International Conference on Neural Networks, 1995. [8] J. McLurkin. Stupid Robot Tricks: A Behavior-Based Distributed Algorithm Library for Programming Swarms of Robots. PhD thesis, Massachusetts Institute of Technology, 2004. [9] N. Minar. The Swarm Simulation System: A Toolkit for Building Multi-agent Simulations. Santa Fe Institute, 1996. [10] F. Mondada, G. Pettinaro, A. Guignard, I. Kwee, D. Floreano, J. Deneubourg, S. Nolfi, L. Gambardella, and M. Dorigo. Swarm-Bot: A New Distributed Robotic Concept. Autonomous Robots, 17(2):193–221, 2004. [11] J. Parrish, S. Viscido, and D. Grunbaum. Self-organized fish schools: an examination of emergent properties. Biological Bulletin, Marine
Biological Laboratory, Woods Hole, 202(3):296–305, 2002. [12] C. W. Reynolds. Flocks, Herds, and Schools: A Distributed Behavioral Model. In Computer Graphics, 21(4) (SIGGRAPH ’87 Conference Proceedings), pages 25–34, 1987. [13] R. Sibson. A brief description of natural neighbour interpolation. Interpreting Multivariate Data, pages 21–36, 1981. [14] R. Sikora and M. Shaw. A Multi-Agent Framework for the Coordination and Integration of Information Systems. Management Science, 44(11):65–78, 1998.
