Kent Academic Repository
Full text document (pdf)
Copyright & reuse
Content in the Kent Academic Repository is made available for research purposes. Unless otherwise stated all
content is protected by copyright and in the absence of an open licence (eg Creative Commons), permissions
for further reuse of content should be sought from the publisher, author or other copyright holder.
Versions of research
The version in the Kent Academic Repository may differ from the final published version.
Users are advised to check http://kar.kent.ac.uk for the status of the paper. Users should always cite the
published version of record.
Enquiries
For any further enquiries regarding the licence status of this document, please contact:
researchsupport@kent.ac.uk
If you believe this document infringes copyright then please contact the KAR admin team with the take-down
information provided at http://kar.kent.ac.uk/contact.html
Citation for published version
Watkins, A. and Timmis, Jon (2004) Exploiting Parallelism Inherent in AIRS, an Artificial Immune
Classifier. In: Nicosia, Giuseppe, ed. Third International Conference on Artificial Immune Systems.
LNCS, 3239 (3239). Springer pp. 427-438. ISBN 3-540-23097-1.
DOI
Link to record in KAR
https://kar.kent.ac.uk/14101/
Document Version
UNSPECIFIED
Exploiting Parallelism Inherent in AIRS,
an Artificial Immune Classifier
Andrew Watkins
1,2
and Jon Timmis
1
1
Computing Lab orat ory, University of Kent, UK
{abw5,jt6}@kent.ac.uk
http://www.cs.kent.ac.uk/˜abw5/
2
Department of Computer Science and Engineering, Mississippi State University,
USA
Abstract. The mammalian immune system is a highly complex,
inherently parallel, distributed system. The field of Artificial Immune
Systems (AIS) has developed a wide variety of algorithms inspired by
the immune system, few of which appear to capitalize on the parallel
nature of the system from which inspiration was taken. The work in this
pap er presents the first steps at realizing a parallel artificial immune
system for classification. A simple parallel version of the classification
algorithm Artificial Immune Recognition System (AIRS) is presented.
Initial results indicate that a decrease in overall runtime can be achieved
through fairly na¨ıve techniques. The need for more theoretical models of
the behavior of the algorithm is discussed.
1 Int roduction
Among the oft-cited reasons for exploring mammalian immune systems as a
source of inspiration f or computational problem solving include the observations
that the immune system is inherently parallel and distributed with many diverse
components working simultaneously and in cooperation to provide all of the
services that the immune system provides [1,2]. Within the AIS community,
there has been some exploration of the distributed nature of the immune system
as evidenced in algorithms for network intrusion detection (e.g., [3,4]) as well
as some ideas for distributed robot control (e.g., [5,6]), to name a couple of
examples. However, very little has been done in the realm of parallel AIS–that is,
applying methods to parallelize existing AIS algorithms in the hopes of efficiency
(or other) gains. While just par allelizing AIS algorithms is, admittedly, venturing
fairly far afield from the initial inspiration found in the immune system, the
computational gains through this exercise could well be worth the (possible) side-
track. Additionally, this exploration may provide some insight into other relevant
areas of AIS, such as ways to incorporate diversity or even understanding the
need for such.
The exploitation of parallelism inh erent in many algorit hms has provided
definite gains in efficiency and lent insight into the limitations of the algorithms
[7,8]. One example of this within the field of AIS was a very basic study of a
G. Nicosia et al. (Eds.): ICARIS 2004, LNCS 3239, pp. 427–438, 2004.
c
Springer-Verlag Berlin Heidelberg 2004
428 A. Watkins and J. Timmis
parallel version of the CLONALG algorithm [9]. That study took advantage of
the embarrassingly parallel nature of this basic AIS algorithm and demonstrated
that parallel techniques can be effectively ap pli ed to AIS. This paper builds upon
the lessons learned in the parallelization of CLONALG to parallelize another
immune learning algorithm: AIRS. While some theoretical results are hinted,
the results discussed here are very much of an empirical nature with most of the
required theoretical analysis still needing to be performed.
The remainder of this paper details these initial results in p arallelizing AIRS.
Section 2 gives a brief overview of the serial version of the AIRS algorithm.
Section 3 discusses the issues involved with parallelizing this algorithm and
provides results from an initial method for this parallelization. Section 4 discusses
the role of memory cells in AIRS, the impact of the initial parallel technique on
the number of memory cells produced, and a possible way to overcome this
apparent issue. Section 5 presents a third memory cell merging technique and
the r esults obtained from adopting this method for solving the memory cell
issue. Finally, section 6 offers some concluding remarks about this initial study
of parallel AIRS.
2 Overview of the AIRS Algorithm
Developed in 2001, the Artificial Immune Recognition System (AIRS) algorithm
was introduced as one of the first immune-inspired supervised learning
algorithms and has subsequently gone through a period of study and refinement
[10,11,12,13,14,15,16,17,18,19,20]
1
. To use classifications from [1], AIRS is a
bone-marrow, clonal selection type of immune-inspired algorithm, and, as with
many AIS algorithms, immune-inspired is the key word. We do not pretend to
imply that AIRS directly models any immunological process, but rather AIRS
employs some components that can metaphorically relate to some immunological
components. In the AIS community, AIRS has two basic precursor algorithms:
CLONALG [21] and AINE [22]. AIRS resembles CLONALG in the sense that
both algorithms are concerned with developing a set of memory cells that
give a representation of the learned environment. AIRS also employs affinity
maturation and somatic hypermutation schemes that are similar to what is found
in CLONALG. From AINE, AIRS has borrowed pop ulati on control mechanisms
and the concept of an abstract B-cell which represents a concentration of
identical B-cells (referred to as Artificial Recognition Balls in previous papers).
AIRS has also adopted from AINE the use of an affinity threshold for some
learning mechanisms. It should be n oted that while AIRS d oes owe some debt of
1
There is a debate concerning the label of supervised learning for AIRS. The authors
are of the view that supervised learning is any learning system which utilizes
knowledge of a training example’s actual class in the building of its representation of
the problem space. While AIRS does not use this information to directly minimize
some error function (as seen with neural networks), it does utilize classification
information about the training instances to create its world-view. Therefore, we feel
that the label of supervised learning is more apt than that of reinforcement learning.
Exploiting Parallelism Inherent in AIRS, an Artificial Immune Classifier 429
inspiration to AINE, AIRS is a population based algorithm and not a network
algorithm like AINE.
While we will not detail the entire algorithm here, we do want to highlight
the key parts of AIRS that will allow for understanding of the parallelization
2
.
Like CLONALG, AIRS is concerned with the discovery/development of a set of
memory cells that can encapsulate the trainin g data. Basically, this is done in a
two-stage process of first evolving a candidate memory cell and then determining
if this candidate cell should be added to the overall pool of memory cells. This
process can be outlined as follows:
1. Compare a training instance with all memory cells of the same class and
find the memory cell with the best affinity for the training instance
3
.We
will refer to this memory cell as mc
match
.
2. Clone and mutate mc
match
in propor tion to its affinity to create a pool of
abstract B-Cells.
3. Calculate the affini ty of each B-Cell with the training instance.
4. Allocate resources to each B-Cell based on its affinity.
5. Remove the weakest B-Cells until the number of resources returns to a pre-
set li mit.
6. If the average affinity of the surviving B-Cells is above a certain level,
continue to step 7. Else, clone and mutate these surviving B-Cells based
on their affinity and return to step 3.
7. Choose the best B-Cell as a candidate memory cell (mc
cand
).
8. If the affinity of mc
cand
for the training instance is better than the affinity
of mc
match
, then add mc
cand
to the memory cell pool. If, in addition to this,
the affinity between mc
cand
and mc
match
is within a certain threshold, then
remove mc
match
from the memory cell pool.
9. Repeat from step 1 until all training instances have been presented.
Once this training routine is complete, AIRS classifies instances using k-nearest
neighbor with the developed set of memory cells.
3 Parallelizing AIRS
Having reviewed the serial version of AIRS, we turn our attention to our initial
strategies for parallelizing this algorithm. Our primary motivation for these
experiments is computational efficiency. We would like to employ mechanisms
of harn essing the power of multiple processors applied to the same learning task
rather than relying solely on a single processor. This ability will, in theory, allow
us to apply AIRS to problem sets of a larger scale without sacrificing some of the
appealing features of the algorithm. Secondary goals of this work include gaining
more insight into the processes necessary to parallelize immune algorithms, in
2
See [14] for the pseudocode of AIRS.
3
Affinity is currently defined as Euclidean distance. We are looking for the closest
memory cell of the same class as the training instance.
430 A. Watkins and J. Timmis
Step 3:
AIRS
Creates
Memory
Cells
Step 1:
Read Data
Step 5:
Cells
Merged
Step 2: Data is
scattered to
different
processors
Step 4:
Memory Cells
are gathered
Step 3:
AIRS
Creates
Memory
Cells
Step 1:
Read Data
Step 5:
Cells
Merged
Step 2: Data is
scattered to
different
processors
Step 2: Data is
scattered to
different
processors
Step 4:
Memory Cells
are gathered
Step 4:
Memory Cells
are gathered
Fig. 1. Overview of Parallel AIRS
general, as well as the implication of such work for the study of the role of
diversity and distributedness in AIS.
Our initial approach to parallelizing this process is the same as the approach
to parallelizing CLONALG presented in [9]: we partition the training data
into np (number of pro cesses) pieces and allow each of the processors to train
on the separate portions of the training data. Figure 1 depicts this process.
Unfortunately, unlike CLONALG which simply evolves one memory cell for each
training data item, AIRS actually employs some degree of interaction between
the candidate cells and the previously established memory cells. Partitioning
the training data and allowing multiple copies of AIRS to run on these fractions
of the data in essence creates np separate memory cell pools. It introduces a
(possibly) significant difference in behavior from the serial version. So, when
studying this parallelism, we must examine not only the computational efficiency
we gain through this use of multiple processors, but we must also learn how
evolving these memory cell pools in isolation of one another effects the overall
performance of the algorithm.
Algorithmically, based on what is described in section 2, the parallel version
behaves in the following manner:
1. Read in the t rain ing data at the root process.
2. Scatter the training data to the np processes.
3. Execute, on each process, steps 1 through 9 from the serial version of the
algorithm on the portion of the training data obtained.
4. Gather the developed memory cells from each processes back to the root.
5. Merge the gathered memory cells into a single memory cell pool for
classification.
