Difference between revisions of "Autonomous agents"
m |
|||
Line 57: | Line 57: | ||
{{#pmid: 23891719}} | {{#pmid: 23891719}} | ||
+ | {{#pmid: 22311865}} | ||
{{#pmid: 22052476}} | {{#pmid: 22052476}} | ||
{{#pmid: 20459813}} | {{#pmid: 20459813}} | ||
+ | {{#pmid: 18585096}} | ||
{{#pmid: 18425405}} | {{#pmid: 18425405}} | ||
+ | {{#pmid: 17695749}} | ||
+ | {{#pmid: 17430564}} | ||
+ | {{#pmid: 16621723}} | ||
+ | {{#pmid: 16420735}} | ||
{{#pmid: 15890745}} | {{#pmid: 15890745}} | ||
{{#pmid: 15196484}} | {{#pmid: 15196484}} |
Latest revision as of 13:57, 14 September 2013
Autonomous agents
Autonomous agents for bioinformatics.
Introductory reading
Merelli et al. (2007) Agents in bioinformatics, computational and systems biology. Brief Bioinformatics 8:45-59. (pmid: 16772270) |
Levels of software coupling
Considering flexibility in design and development of software introduces the notion of coupling of components. This describes how widely and deeply components depend on each other. Tight coupling may lead to better performance. Loose coupling may lead to higher flexibility. Dependencies can exist along many dimensions. Thus coupling can be structural (a component includes another component), explicit (two components use each other), or implicit through sharing resources, requiring to communicate thorugh a common language or standards, assuming some (or no) synchronicity or sequence of execution. As a general rule: unnecessary coupling is always bad.
One can identify degrees of coupling with programming paradigms as follows:
- Sequential (unstructured) programming ([1])
- Instructions are written and executed one after another. Intermediate data is not isolated but kept in variables in memory. Everything is tightly coupled. This was the traditional way to develop code. Advantage: can be quick to develop and very effcient to run (little overhead). Disadvantage: code is hard to maintain and not easily reusable; changes often have unanticipated sideeffects.
- Procedural programming ([2])
- Code is broken up into modules that communicate through well-defined interfaces. Advantages: code becomes much easier to structure and to maintain as projects become more complex. Rather than requiring awareness of the entire state of the program, the procedures (or functions, or subroutines ...) need only be aware of the parameters that are passed to them. Disadvantages: Parameters can still move out of synchrony regarding their syntax (their datatypes or datastructures) or their semantics (their meaning), since they are not defined and maintained in paralell with the procedures that use them.
- Object oriented programming ([3])
- To further insulate code components from side-effects and inadvertent change, support code-reuse, simplify maintenance and extensibility, the idea of objects was introduced. An object contains both the description of parameters (attributes, properties ...) and of the functions that operate on the object (methods). The object oriented paradigm is usually said to facilitate three goals: encapsulation (no need to concern oneself with the internal workings of a procedure if the interface is specified), polymorphism (the same request can have different results depending on its context, e.g. an object may support the method multiply() that behaves dffernetly, depending on whether an instance of the object is a scalar or a matrix), and inheritance (classes of objects can be defined based on the properties of other classes, which they inherit). Advantages: An emphasis on modeling and structured design supports tackling very complex problems through iterated development. Disadvantages: Encapsulation can make code hard to debug, polymorphism can make code hard to read, inheritance may not be all that useful in the real world and may introduce side-effects (changing code in base-classes effects all derived classes). OO is not a panacea and not a substitute for clear thinking.
- Distributed computing ([4])
- In the quest for increased computing resources, distributed computing schemes have been developed that farm out parts of a larger computation across a network to other machines, typically ones that have nothing to do at the moment. As the code is executed on remote machines, it needs to be sufficiently independent. Structural or procedural coupling are avoided but implicit coupling can be significant. Advantages: Cheap access to resources. Easily scalable. redundancy and fault-tolerance. Disadvantages: Security concerns; not all problems can be divided up into distributable tasks; development overhead for scheduling, communication and integration of results.
- Autonomous agent systems ([5])
- The loosest coupling could be achieved if software components could act totally autonomously. Such "autonomous" components can be called agents. Agents are abstract concepts, not recipes for implementation. The emphasis is on behaviour, not data or method. The many exisiting definitions for agents usually include concepts such as persistence (code is not executed on demand but runs continuously and decides for itself when it should perform some activity), autonomy (agents have capabilities of task selection, prioritization, goal-directed behaviour, decision-making without human intervention), social ability (agents are able to engage other components through some sort of communication and coordination), reactivity (agents perceive the context in which they operate and react to it appropriately). Advantages: Most flexible of all programming paradigms, weakest coupling, easily able to integrate wide variety of standards, resources and languages. Disadvantages: Hype has obscured concepts; Computations are no longer strictly deterministic (since they are dependent on external, changing context) and may thus not be reproducible. It may be difficult to keep track of task progress. Scheduling overhead may be significant.
Further reading and resources
Hassanien et al. (2013) Computational intelligence techniques in bioinformatics. Comput Biol Chem 47:37-47. (pmid: 23891719) |
Su & Huang (2012) Cooperative output regulation with application to multi-agent consensus under switching network. IEEE Trans Syst Man Cybern B Cybern 42:864-75. (pmid: 22311865) |
Holcombe et al. (2012) Modelling complex biological systems using an agent-based approach. Integr Biol (Camb) 4:53-64. (pmid: 22052476) |
Severin et al. (2010) eHive: an artificial intelligence workflow system for genomic analysis. BMC Bioinformatics 11:240. (pmid: 20459813) |
García-Sánchez et al. (2008) Combining Semantic Web technologies with Multi-Agent Systems for integrated access to biological resources. J Biomed Inform 41:848-59. (pmid: 18585096) |
Ren et al. (2008) Multi-agent-based bio-network for systems biology: protein-protein interaction network as an example. Amino Acids 35:565-72. (pmid: 18425405) |
Bartocci et al. (2007) An agent-based multilayer architecture for bioinformatics grids. IEEE Trans Nanobioscience 6:142-8. (pmid: 17695749) |
Bartocci et al. (2007) BioWMS: a web-based Workflow Management System for bioinformatics. BMC Bioinformatics 8 Suppl 1:S2. (pmid: 17430564) |
Alonso-Calvo et al. (2007) An agent- and ontology-based system for integrating public gene, protein, and disease databases. J Biomed Inform 40:17-29. (pmid: 16621723) |
Keele & Wray (2005) Software agents in molecular computational biology. Brief Bioinformatics 6:370-9. (pmid: 16420735) |
Karasavvas et al. (2005) A criticality-based framework for task composition in multi-agent bioinformatics integration systems. Bioinformatics 21:3155-63. (pmid: 15890745) |
Karasavvas et al. (2004) Bioinformatics integration and agent technology. J Biomed Inform 37:205-19. (pmid: 15196484) |