2,406 research outputs found
Relatedness Measures to Aid the Transfer of Building Blocks among Multiple Tasks
Multitask Learning is a learning paradigm that deals with multiple different
tasks in parallel and transfers knowledge among them. XOF, a Learning
Classifier System using tree-based programs to encode building blocks
(meta-features), constructs and collects features with rich discriminative
information for classification tasks in an observed list. This paper seeks to
facilitate the automation of feature transferring in between tasks by utilising
the observed list. We hypothesise that the best discriminative features of a
classification task carry its characteristics. Therefore, the relatedness
between any two tasks can be estimated by comparing their most appropriate
patterns. We propose a multiple-XOF system, called mXOF, that can dynamically
adapt feature transfer among XOFs. This system utilises the observed list to
estimate the task relatedness. This method enables the automation of
transferring features. In terms of knowledge discovery, the resemblance
estimation provides insightful relations among multiple data. We experimented
mXOF on various scenarios, e.g. representative Hierarchical Boolean problems,
classification of distinct classes in the UCI Zoo dataset, and unrelated tasks,
to validate its abilities of automatic knowledge-transfer and estimating task
relatedness. Results show that mXOF can estimate the relatedness reasonably
between multiple tasks to aid the learning performance with the dynamic feature
transferring.Comment: accepted by The Genetic and Evolutionary Computation Conference
(GECCO 2020
Improving the Scalability of XCS-Based Learning Classifier Systems
Using evolutionary intelligence and machine learning techniques, a broad
range of intelligent machines have been designed to perform different
tasks. An intelligent machine learns by perceiving its environmental status
and taking an action that maximizes its chances of success.
Human beings have the ability to apply knowledge learned from a
smaller problem to more complex, large-scale problems of the same or a
related domain, but currently the vast majority of evolutionary machine
learning techniques lack this ability. This lack of ability to apply the already
learned knowledge of a domain results in consuming more than
the necessary resources and time to solve complex, large-scale problems
of the domain. As the problem increases in size, it becomes difficult and
even sometimes impractical (if not impossible) to solve due to the needed
resources and time. Therefore, in order to scale in a problem domain, a
systemis needed that has the ability to reuse the learned knowledge of the
domain and/or encapsulate the underlying patterns in the domain.
To extract and reuse building blocks of knowledge or to encapsulate
the underlying patterns in a problem domain, a rich encoding is needed,
but the search space could then expand undesirably and cause bloat, e.g.
as in some forms of genetic programming (GP). Learning classifier systems
(LCSs) are a well-structured evolutionary computation based learning
technique that have pressures to implicitly avoid bloat, such as fitness
sharing through niche based reproduction.
The proposed thesis is that an LCS can scale to complex problems in
a domain by reusing the learnt knowledge from simpler problems of the
domain and/or encapsulating the underlying patterns in the domain. Wilson’s
XCS is used to implement and test the proposed systems, which is a well-tested,
online learning and accuracy based LCS model. To extract the reusable building
blocks of knowledge, GP-tree like, code-fragments are introduced, which are more
than simply another representation (e.g. ternary or real-valued alphabets). This
thesis is extended to capture the underlying patterns in a problemusing a cyclic
representation. Hard problems are experimented to test the newly developed scalable
systems and compare them with benchmark techniques.
Specifically, this work develops four systems to improve the scalability
of XCS-based classifier systems. (1) Building blocks of knowledge are extracted
fromsmaller problems of a Boolean domain and reused in learning
more complex, large-scale problems in the domain, for the first time. By
utilizing the learnt knowledge from small-scale problems, the developed
XCSCFC (i.e. XCS with Code-Fragment Conditions) system readily solves
problems of a scale that existing LCS and GP approaches cannot, e.g. the
135-bitMUX problem. (2) The introduction of the code fragments in classifier
actions in XCSCFA (i.e. XCS with Code-Fragment Actions) enables the
rich representation of GP, which when couples with the divide and conquer
approach of LCS, to successfully solve various complex, overlapping
and niche imbalance Boolean problems that are difficult to solve using numeric
action based XCS. (3) The underlying patterns in a problem domain
are encapsulated in classifier rules encoded by a cyclic representation. The
developed XCSSMA system produces general solutions of any scale n for
a number of important Boolean problems, for the first time in the field of
LCS, e.g. parity problems. (4) Optimal solutions for various real-valued
problems are evolved by extending the existing real-valued XCSR system
with code-fragment actions to XCSRCFA. Exploiting the combined power
of GP and LCS techniques, XCSRCFA successfully learns various continuous
action and function approximation problems that are difficult to learn
using the base techniques.
This research work has shown that LCSs can scale to complex, largescale
problems through reusing learnt knowledge. The messy nature, disassociation of
message to condition order, masking, feature construction, and reuse of extracted
knowledge add additional abilities to the XCS family of LCSs. The ability to use
rich encoding in antecedent GP-like codefragments or consequent cyclic representation
leads to the evolution of accurate, maximally general and compact solutions in learning
various complex Boolean as well as real-valued problems. Effectively exploiting
the combined power of GP and LCS techniques, various continuous action
and function approximation problems are solved in a simple and straight
forward manner.
The analysis of the evolved rules reveals, for the first time in XCS, that
no matter how specific or general the initial classifiers are, all the optimal
classifiers are converged through the mechanism ‘be specific then generalize’
near the final stages of evolution. Also that standard XCS does not use
all available information or all available genetic operators to evolve optimal
rules, whereas the developed code-fragment action based systems effectively use figure
and ground information during the training process.
Thiswork has created a platformto explore the reuse of learnt functionality,
not just terminal knowledge as present, which is needed to replicate human capabilities
Constructing Complexity-efficient Features in XCS with Tree-based Rule Conditions
A major goal of machine learning is to create techniques that abstract away
irrelevant information. The generalisation property of standard Learning
Classifier System (LCS) removes such information at the feature level but not
at the feature interaction level. Code Fragments (CFs), a form of tree-based
programs, introduced feature manipulation to discover important interactions,
but they often contain irrelevant information, which causes structural
inefficiency. XOF is a recently introduced LCS that uses CFs to encode building
blocks of knowledge about feature interaction. This paper aims to optimise the
structural efficiency of CFs in XOF. We propose two measures to improve
constructing CFs to achieve this goal. Firstly, a new CF-fitness update
estimates the applicability of CFs that also considers the structural
complexity. The second measure we can use is a niche-based method of generating
CFs. These approaches were tested on Even-parity and Hierarchical problems,
which require highly complex combinations of input features to capture the data
patterns. The results show that the proposed methods significantly increase the
structural efficiency of CFs, which is estimated by the rule "generality rate".
This results in faster learning performance in the Hierarchical Majority-on
problem. Furthermore, a user-set depth limit for CF generation is not needed as
the learning agent will not adopt higher-level CFs once optimal CFs are
constructed
Setting the basis of best practices and standards for curation and annotation of logical models in biology
International audienceThe fast accumulation of biological data calls for their integration, analysis and exploitation through more systematic approaches. The generation of novel, relevant hypotheses from this enormous quantity of data remains challenging. Logical models have long been used to answer a variety of questions regarding the dynamical behaviours of regulatory networks. As the number of published logical models increases, there is a pressing need for systematic model annotation, referencing and curation in community-supported and standardised formats. This article summarises the key topics and future directions of a meeting entitled ‘Annotation and curation of computational models in biology’, organised as part of the 2019 [BC]2 conference. The purpose of the meeting was to develop and drive forward a plan towards the standardised annotation of logical models, review and connect various ongoing projects of experts from different communities involved in the modelling and annotation of molecular biological entities, interactions, pathways and models. This article defines a roadmap towards the annotation and curation of logical models, including milestones for best practices and minimum standard requirements
Redocumentation through design pattern recovery:: an investigation and an implementation
In this thesis, two methods are developed in an aid to help users capture valuable design information and knowledge and reuse them. They are the design pattern recovery (DPR) method and pattern-based redocumentation (PBR) method. The DPR method is for matching up metrics of patterns with patterns themselves in order to capture valuable design information. Patterns are used as a container for storing the information. Two new metrics, i.e., p-value and s-value are introduced. They are obtained by analysing product metrics statistically. Once patterns have been detected from a system, the system can be redocumented using these patterns. Some existing XML (extensible Markup Language) technologies are utilised in order to realise the PRB method. Next, a case study is carried out to validate the soundness and usefulness of the DPR method. Finally, some conclusions drawn from this research are summarised, and further work is suggested for the researchers in software engineering
Scalable Transfer Evolutionary Optimization: Coping with Big Task Instances
In today's digital world, we are confronted with an explosion of data and
models produced and manipulated by numerous large-scale IoT/cloud-based
applications. Under such settings, existing transfer evolutionary optimization
frameworks grapple with satisfying two important quality attributes, namely
scalability against a growing number of source tasks and online learning
agility against sparsity of relevant sources to the target task of interest.
Satisfying these attributes shall facilitate practical deployment of transfer
optimization to big source instances as well as simultaneously curbing the
threat of negative transfer. While applications of existing algorithms are
limited to tens of source tasks, in this paper, we take a quantum leap forward
in enabling two orders of magnitude scale-up in the number of tasks; i.e., we
efficiently handle scenarios with up to thousands of source problem instances.
We devise a novel transfer evolutionary optimization framework comprising two
co-evolving species for joint evolutions in the space of source knowledge and
in the search space of solutions to the target problem. In particular,
co-evolution enables the learned knowledge to be orchestrated on the fly,
expediting convergence in the target optimization task. We have conducted an
extensive series of experiments across a set of practically motivated discrete
and continuous optimization examples comprising a large number of source
problem instances, of which only a small fraction show source-target
relatedness. The experimental results strongly validate the efficacy of our
proposed framework with two salient features of scalability and online learning
agility.Comment: 12 pages, 5 figures, 2 tables, 2 algorithm pseudocode
A Domain-Specific Language and Editor for Parallel Particle Methods
Domain-specific languages (DSLs) are of increasing importance in scientific
high-performance computing to reduce development costs, raise the level of
abstraction and, thus, ease scientific programming. However, designing and
implementing DSLs is not an easy task, as it requires knowledge of the
application domain and experience in language engineering and compilers.
Consequently, many DSLs follow a weak approach using macros or text generators,
which lack many of the features that make a DSL a comfortable for programmers.
Some of these features---e.g., syntax highlighting, type inference, error
reporting, and code completion---are easily provided by language workbenches,
which combine language engineering techniques and tools in a common ecosystem.
In this paper, we present the Parallel Particle-Mesh Environment (PPME), a DSL
and development environment for numerical simulations based on particle methods
and hybrid particle-mesh methods. PPME uses the meta programming system (MPS),
a projectional language workbench. PPME is the successor of the Parallel
Particle-Mesh Language (PPML), a Fortran-based DSL that used conventional
implementation strategies. We analyze and compare both languages and
demonstrate how the programmer's experience can be improved using static
analyses and projectional editing. Furthermore, we present an explicit domain
model for particle abstractions and the first formal type system for particle
methods.Comment: Submitted to ACM Transactions on Mathematical Software on Dec. 25,
201
- …