Welcome to the Paraphrase AGH project.
The goal of this project is to help creating highly-concurrent multi-agent systems (MAS) targeted at massively multicore hardware. The Paraphrase AGH project is part of the more general Paraphrase research project.
Why we do this
Most multi-agent software come into two categories:
- Heavy-grained agent programming (e.g. Jade), where every agent runs in a separate thread,
- Fine-grained agent simulations (e.g. Netlogo), where the whole agent population is thread-contained.
The first approach is not efficient in computationally intensive simulations with large numbers of agents. (see) The second does not make use of the growing parallel capabilities of modern hardware.
We want to fill the gap and allow fine-grained agent-based simulations and computations which could be run efficiently on massively multicore hardware.
Ease of use
Writing a concurrent application is hard for most programmers. Writing a concurrent agent simulation is even harder. Moreover, most of the existing software tighly couples the agent programming model to the underlying execution model and parallelism type.
We want programmers to be able to design a multi-agent system at a high level which abstracts of the actual execution model. Then, such high level multi-agent patterns could be mapped to match a specific hardware by using the most adequate execution model for that hardware.
In consequence, multi-agent simulations and computations could be easily designed and tested and the same design could then be scaled out along with additional resources to solve harder problems or run bigger simulations.
How we do this
We use high-level functional patterns to design multi-agent algorithms in a way similar to the MapReduce model.
The multi-agent system is decomposed into:
The mapping part
- Agent state (and possibly location in spatial simulations)
- Agent action
- Agent behaviour, .i.e. a function of agent state into agent action
behaviour: (State, Location) -> (Action, Location)
During the exection of the multi-agent system, agents will repeatedly choose an action to be performed in some location based on their current state and location.
The reducing part:
Agents are repeatedly grouped by similar actions and location. For every such group a meetings is performed. Meeting are defined as having some given arity - the group of reduced agents is subdivided into smaller groups of that arity and for each such smaller group the meeting function is called, which yields a new sequence of agents as the result of the meeting.
meeting: (Action, Location, [State]) -> [(State, Location)]
Agents may interact during the meetings or act individually - it follows the arity of the meeting function, which is problem-dependent.
The resulting sequence of agents may contain previous agents with updated state, or new agents. Existing agents may also be dropped from the resulting list, effectively removing them from the system.
The results of the meetings are combined to yield subsequent populations.
A multi-agent simulation is then fully defined by the space of possible agent states, the set of possible actions and a behaviour and meetings functions.
All that remains is to combine these functions to run a multi-agent simulation. We provide several ways to do this, which allows the system to be decomposed as follows:
The top layer is where you define the functions described above, which are problem specific. The bottom layer represents the MAS engine which binds the system together. Several implementations are available, as described in the documentation of the MAS engine subproject (see below).
This project is divided into several subprojects.
- MAS engine
- EMAS application
- Several EMAS applications: continuous optimization and discrete optimization.
For spatial simulations, a slightly different MAS simulation engine is available.
The documentation for each of the subprojects is available in the corresponding README files and wikis.
Roman Debski, SIMULATION-BASED HIGH-PERFORMANCE ALGORITHMS FOR ALPINE SKI RACER’S TRAJECTORY OPTIMIZATION IN HETEROGENEOUS COMPUTER SYSTEMS, Int. Journal of Applied Mathematics and Computer Science (accepted).
Aleksander Byrski, Marek Kisiel Dorohinicki, MEMETIC COMPUTING IN SELECTED AGENT-BASED EVOLUTIONARY SYSTEMS Proc of THE 28TH EUROPEAN CONFERENCE ON MODELLING & SIMULATION BRESCIA, ITALY, 27-30 MAY 2014.
Daniel Krzywicki, Lukasz Faber, Aleksander Byrski, Marek Kisiel-Dorohinicki Computing agents for decision support systems. Future Generation Comp. Syst. 37: 390-400 (2014)
Maciej Kazirod, Wojciech Korczynski, Aleksander Byrski Agent-oriented computing platform in Python Proc of The 2014 IEEE/WIC/ACM International Conference on Intelligent Agent Technology, Warsaw, Poland 11-14 August 2014 (accepted).
D. Krzywicki, J. Stypka, P. Anielski, L. Faber, W. Turek, A. Byrski and M. Kisiel-Dorohinicki Generation-free Agent-based Evolutionary Computing Proc of Int Conf on Computational Science, Cairns, Australia, 1-12 June 2014.
Michal Kowol, Aleksander Byrski and Marek Kisiel-Dorohinicki Agent-based Evolutionary Computing for Difficult Discrete Problems Proc of Int Conf on Computational Science, Cairns, Australia, 1-12 June 2014.
Leszek Siwik, Rafal Drezewski Evolutionary Multi-Modal Optimization with the use of Multi-Objective Techniques Proc of Int. Conf. on Artificial Intelligence and Soft Computing, Zakopane, Poland June 1-5, 2014.
Authors and Contributors
2013-2015, Daniel Krzywicki, Jan Stypka, Piotr Anielski, Marcin Miszczyk