Abstract

In the computer vision and pattern recognition fields, image classification represents an important yet difficult task. It is a challenge to build effective computer models to replicate the remarkable ability of the human visual system, which relies on only one or a few instances to learn a completely new class or an object of a class. Recently we proposed two genetic programming (GP) methods, one-shot GP and compound-GP, that aim to evolve a program for the task of binary classification in images. The two methods are designed to use only one or a few instances per class to evolve the model. In this study, we investigate these two methods in terms of performance, robustness, and complexity of the evolved programs. We use ten data sets that vary in difficulty to evaluate these two methods. We also compare them with two other GP and six non-GP methods. The results show that one-shot GP and compound-GP outperform or achieve results comparable to competitor methods. Moreover, the features extracted by these two methods improve the performance of other classifiers with handcrafted features and those extracted by a recently developed GP-based method in most cases.

1  Introduction

Image classification represents a cornerstone in a broad range of domains such as computer vision and pattern recognition. Mainly, image classification aims at categorising images into different groups based on their contents. This task has received a lot of attention over the last few decades because of its importance and difficulty. Hence, a large number of methods have been proposed in the literature that aim at tackling different aspects of the image classification task. Some of those methods aim at addressing the accuracy problem (Lu and Weng, 2007), while others try to speed up the training process (Fan et al., 2004). Moreover, some methods have been proposed to tackle different variations that can occur on instances of the same group, such as illumination, rotation, and noise (Ojala et al., 2000; Guo et al., 2010).

Most of those methods were not designed to build a model using a limited or small number of labelled instances. In other words, those methods were designed based on the assumption of having an abundant (to some extent) number of instances in order to build a model that can sufficiently generalise to unseen data. However, it is not always easy, feasible, or even possible to acquire a large number of labelled instances. Therefore, the limitation of having only a few labelled instances to build or estimate the set of parameters of a given model needs to be addressed.

Jain and Chandrasekaran (1982) investigated the problem of building or training a model using few instances. Raudys and Jain (1991) studied this problem and provided a list of recommendations and guidelines for practitioners: (1) the design parameters should be carefully selected when the number of instances is small; an example is the number of neighbours in the k-nearest neighbour (kNN) algorithm; (2) using powerful machines (e.g., a computer with a large amount of memory and a high processing speed), it is highly recommended to try a variety of feature extraction and selection methods and test their impact on different classification approaches; (3) in order to estimate the classification error, a sufficient number of instances is required in the testing set; (4) the use of distinct instances in the training and testing sets; (5) identifying and mitigating the problem of high error rate, which can be due to the large number of features, the small number of training instances, the complexity of the model, inappropriate kernel width of nonparametric models, or the presence of outliers in the case of parametric models; and (6) for feature selection, special attention should be given to selecting a good or the best subset of features.

Genetic programming (GP) (Koza, 1992) is a well-known evolutionary computation algorithm inspired by the Darwinian principles of natural selection and the concept of survival of the fittest. GP aims at automatically exploring the solution space in order to evolve a computer program (solution) for a user-defined problem (Koza, 1992). GP has been widely used to tackle the problems of image classification (Smart and Zhang, 2003; Zhang and Smart, 2004; Zhang and Johnston, 2009; Downey and Zhang, 2009; Atkins et al., 2011; Abdulhamid et al., 2011; Al-Sahaf et al., 2014a, 2014b), object detection (Zhang and Ciesielski, 1999; Zhang et al., 2004; Liddle et al., 2010), edge detection (Fu et al., 2011, 2012), and image descriptor (Perez and Olague, 2009; Hindmarsh et al., 2012; Olague and Trujillo, 2011; Albukhanajer et al., 2014). A large number of the GP-based methods operate in two stages, where feature detection and extraction are performed first, and evolving a classifier second. The process of designing a good set of features requires background knowledge from the domain. For example, discriminating between images of benign and malignant tumor cells needs to be carried out under the guidance of an expert in this domain. Other GP-based methods are capable of performing image classification using raw pixel values as input rather than pre-extracted features (Song and Ciesielski, 2004; Al-Sahaf et al., 2012b). However, neither the methods of the first category nor those of the second category were designed to evolve a classifier using a few labelled instances.

Recently, we proposed two GP-based methods for the task of binary classification in images, namely, one-shot GP (Al-Sahaf et al., 2013b) and compound-GP (Al-Sahaf et al., 2013a). Those two methods use only one or a few labelled instances of each class to evolve computer programs that are capable of generalising to unseen data.

To tackle the problem of having a limited number of labelled instances, some methods based on the concept of learning by knowledge transfer have been proposed, and this approach has been termed one-shot learning. The aim is to use a large number of available instances of a domain (the source domain) related to the target domain, and only one or a few labelled instances per class of the target domain, to build a model (Fei-Fei et al., 2006; Ishikawa and Mogi, 2011; Salakhutdinov et al., 2012).

Fei-Fei et al. (2006) proposed a Bayesian-based model for the problem of object recognition. In their system, general knowledge is extracted from previously learned groups of objects using abundant instances, which is then used to form a prior probability density function. A posterior density is then produced by updating this knowledge given a small set of training instances in the target domain. The system was tested using a data set of instances falling into 101 different classes, and compared against two commonly used methods: maximum likelihood (ML), and maximum a posteriori (MAP). The results of their experiments showed that their system significantly outperformed the other methods when the number of training instances was relatively small. Moreover, they investigated the effectiveness of using the knowledge extracted by their method on the performance of the two other methods. The results of the investigation suggested that better performance is achieved when both the ML and MAP methods use the knowledge extracted by the new method.

Deformation matrices were used by Miller et al. (2000) for the problem of object classification. The system was trained using a large number of instances of a character (e.g., the letter A), and then attempts were made to have the system learn a different object (e.g., the number 4) using a single or a few instances. To achieve this goal, two learning scenarios were combined under a single framework: adopting the transfer learning by model parameters approach in order to use a reduced number of instances in the target domain, and frequently updating the system as more training images became available. The method was tested on binary image classification using two different training set sizes: 1,000 instances and only one instance. The results of their experiment showed that unlike other comparative methods, performance does not drop significantly after reducing the number of training instances of the target domain from to 1.

Rodner and Denzler (2011) modified the randomised decision trees (RDF) learning algorithm (Liu et al., 2005; Dhurandhar and Dobra, 2008) in order to build a classifier using very few instances. Similar object classes were used to learn a prior distribution, which was then reused (transferred) to maximise a posteriori estimation of the model parameters. Evaluating the method on three data sets showed that a significant performance improvement was achieved over the RDF classifier of Geurts et al. (2006).

The task of detecting and extracting a set of good features is usually carried out by a domain expert, who, however, may be hard to find or very costly. Feature descriptors or image descriptors play an essential role in detecting and extracting informative features such as shape, texture, scale or size, rotation, and colour (Szeliski, 2010).

The local binary patterns (LBP) descriptor (Ojala et al., 1996) is one of the best known feature descriptors. It represents an essential part of the one-shot GP and compound-GP methods. LBP is discussed further in Section 2.

Motivated by the remarkable ability of the human brain to learn a new object from only one or a few examples, we developed two new GP-based methods for the task of binary classification in image. We are interested in addressing the following objectives:

  • Comparing the performances of those two methods against both GP and non-GP methods using domain-specific handcrafted features

  • Investigating the capability of the evolved programs by those two methods to handle rotation variation

  • Studying the goodness of the features detected and extracted by the evolved programs by those two methods via testing the impact of these features on the performance of different types of classifiers

  • Investigating the efficiency of the two methods by analysing the average time required to evolve a program, average time to evaluate an instance, and the program size

  • Investigating the interpretability of the evolved programs by those two methods

This paper is organised as follows. The concepts of LBP are reviewed in Section 2. Section 3 describes the one-shot GP and compound-GP methods. The experimental settings, data sets, and baseline methods are discussed in Section 4. The results of the experiments are presented in Section 5. Section 6 provides an interpretation of some programs that were evolved by the one-shot GP and compound-GP methods. Section 7 concludes this article and recommends some future work directions.

2  Background

This section provides a brief introduction for the local binary patterns descriptor, which is a key component of the one-shot GP and compound-GP methods.

2.1  Local Binary Patterns

Motivated by the method of Wang and He (1990), Ojala et al. (1994) proposed a simple dense feature descriptor called local binary patterns that calculates a binary code for each pixel of an image based on the intensity value of the neighbouring pixels. Similar to any dense descriptor, LBP scans the image on a pixel-by-pixel basis, and a code of specific length is generated based on the variation in the intensity level of equally spaced pixels located on the boundary of a circle centered on the current pixel. This operator is formally defined as
formula
1
formula
2
formula
3
formula
4
where are the coordinates of the central pixel of the current window, P is the number of neighbouring pixels, R is the radius of the circle (distance between the central pixel and any of the neighbouring pixels), and vp and vc are the intensity of the pth neighbouring and central pixels, respectively. The is a thresholding function that returns 1 if the argument is positive or zero, and 0 otherwise. Originally, LBP was designed to operate in a window and denoted as ; therefore, the resulting binary code is of length 8 bits, as shown in Figure 1.
Figure 1:

Example of steps required to generate the LBP code of a pixel.

Figure 1:

Example of steps required to generate the LBP code of a pixel.

Despite the cost of scanning the image pixel by pixel, the LBP operator has been shown to be a powerful feature descriptor in a large number of studies in the computer vision and pattern recognition fields (Liu et al., 2012; Nguyen et al., 2013; Yang and Chen, 2013). As this operator attracted a large number of researchers over the last decade, numerous variants have been proposed (Pietikäinen et al., 2011), for instance, the size of the window, the method of thresholding the neighbouring pixels, and the length of the resulting code. Figure 2 shows five different LBP examples that vary in size (R) or number of neighbouring pixels (P).

Figure 2:

Examples of circular local neighbouring pixels with different P (number of neighbours) and R (radius) settings. Left to right, , , , and .

Figure 2:

Examples of circular local neighbouring pixels with different P (number of neighbours) and R (radius) settings. Left to right, , , , and .

2.2  Uniform Local Binary Patterns

The introduction of uniform LBP, denoted , represents a substantial restriction of the basic LBP operator (Ojala et al., 1996, 2002). The LBP code is called uniform when it has no more than two circular bitwise transforms, namely, changing from 1 to 0 or from 0 to 1, which is determined using Equation (5). For example, patterns 11100111, 00111100, 11111110, and 00001110 are uniform; whereas patterns 10010111, 11100101, and 00011010 are not uniform.
formula
5

Therefore, uniform patterns represent a subset of the overall space of an LBP code. It has been observed that over 85% of the LBP codes of an image are uniform (Ojala et al., 2002; Ahonen et al., 2006). There are two reasons to prefer uniform codes over basic LBPs: (1) omitting nonuniform codes can significantly reduce the number of possible patterns, which has a large impact on reducing the length of the feature vector, and (2) a variety of texture primitives can be detected using uniform codes, such as line ends, edges, corners, and spots. Figure 3 presents some of these texture primitives, where 0 and 1 are the pixels having lower and higher values than the center pixel, respectively.

Figure 3:

Texture primitives that can be detected using uniform LBP codes.

Figure 3:

Texture primitives that can be detected using uniform LBP codes.

2.3  Local Binary Patterns Histogram

The generated LBP codes of an image are used to form a frequency or spectrum histogram (Ojala et al., 2002) known as a local binary patterns histogram (). Each bin of the accumulates the frequency of a single code. Therefore, the length of the depends on the total number of codes that can be represented, that is, , where P represents the number of neighbouring pixels (i.e., number of bits in the code). For example, if the LBP code is of length 8 bits and a unit radius (), then different codes can be represented starting at 0 = 00000000 and ending at 255 = 11111111; thus, the length of the is in this case 256 bins. is formally defined as
formula
6
where M and N are the width and height of the image, respectively, is the pixel at the coordinates, and b and B are the bth bin of the histogram and the total number of bins, respectively. The function returns 1 if , and 0 otherwise. The pixel at the top left corner of the image has the coordinates , while the pixel at the bottom right corner of the image has the coordinates . Moreover, the border pixels of the image are cropped to ensure that the sampling window does not exceed the image boundaries.

The is a feature vector of an image. The histogram can be either global (Chang et al., 2012) or a concatenation of local histograms (Ahonen et al., 2006; Tan et al., 2006; Pietikäinen et al., 2011). The former approach produces one histogram that consists of bins for each image, as shown in Figure 4a. The latter generates a number of subhistograms that are computed from specific (mostly nonoverlapping) regions of the image, and concatenates those histograms to form the final feature vector. Therefore, the resulting feature vector of the second approach is of length , where G is the number of regions (see Figure 4b).

Figure 4:

Local binary patterns histograms generated from two different approaches. (a) One histogram per image. (b) One histogram per region, then concatenated.

Figure 4:

Local binary patterns histograms generated from two different approaches. (a) One histogram per image. (b) One histogram per region, then concatenated.

As mentioned earlier, omitting nonuniform codes has a significant impact on the length of the resulting feature vector. The 8-bit length code produces a histogram consisting of 256 bins; however, there will be only 58 bins if we consider only uniform codes (see Ojala et al., 2000). In order to also take nonuniform codes into consideration, Ojala et al. (2002) suggested adding an extra bin for all nonuniform codes. Therefore, the total number of bins of an 8-bit length code is 59, which means an approximately 76% shorter histogram than in the original case (256 bins).

3  Proposed Methods

The structure of the one-shot GP and compound-GP methods,1 including the function and terminal sets and the main components, is explained in this section. This section also highlights the major similarities and differences between those two methods. In each method, the function and terminal sets are explained, followed by the fitness measure and the training and testing/evaluation procedures.

3.1  One-Shot GP

The program evolved by this method has a static structure (e.g., type and number of nodes); however, it is dynamic in terms of the position and size of the detected regions. Figure 5 shows the general structure of a program evolved by the one-shot GP method.

Figure 5:

General structure of a program evolved by the one-shot GP method.

Figure 5:

General structure of a program evolved by the one-shot GP method.

3.1.1  Function Set

In this method, the evolved program is made up of three nonterminal types of nodes, each of which has its own restrictions and performs a distinct task. The first type is the controller node, which only occurs at the root of the evolved program. Thus, each program has only one node of this type. The controller node is responsible for predicting the class label of the instance being evaluated based on the results of its children. The second type is the histogram node, which represents the type of the child nodes of the controller node. The histogram node is responsible for accumulating the results of its children to form a single feature vector. Each histogram node corresponds to a single class; the number of this type of node depends on the total number of classes. The third and last type of nonterminal node is the area node. As the name suggests, each area node corresponds to a region of the instance being evaluated (the image) and is specified by the values of its children. The area nodes represent the children of the histogram nodes and are responsible for performing the feature extraction task. As with the histogram nodes, the number of the area nodes is predefined; however, this number is not restricted by the number of the classes. In other words, this number is set experimentally, and in our experiments this number has been set to four.

3.1.2  Terminal Set

Similarly, the terminal set consists of three types of nodes, which are the children of the area nodes, as shown in Figure 5. These nodes are x-coordinate (x for short), y-coordinate (y for short), and window-size (size for short), which are all of type integer. The values of those nodes are randomly generated and represent a square-shaped window of size equal to size and centered at a pixel of the coordinates . Therefore, this part of the evolved program tree is dynamic, as the values of those nodes are randomly generated. The value of the x and y coordinates cannot be negative or greater than the image width and height, respectively, that is, , and , where M and N are, respectively, the width and height of the image. Moreover, size is limited to be between 3 (i.e., window) and , where returns the minimum value of the arguments. The sampling windows are truncated if they exceed the boundaries of the image.

3.1.3  Fitness Measure

The fitness measure of the one-shot GP method aims at maximising the between-class distance, minimising the within-class distance, maximising the accuracy, and minimising the overlapping ratio of the detected regions to ensure the distinction of those regions, as shown in Equation (7).
formula
7
formula
8
formula
9
formula
10
formula
11
Here ACC1 is the performance (accuracy) of the wrapped kNN classifier, where is the number of correctly classified instances and is the total number of nonrepresentative instances. is the overlapping ratio between the detected regions, and and are, respectively, the within-class and between-class distances. Furthermore, and are the set of representative and nonrepresentative instances, respectively; G is the total number of regions; and the function returns the overlapping or intersection (the number of shared pixels) between the arguments (i.e., regions). The and functions are, respectively, returning the histogram and actual class label of the ith instance. In order to prevent division by zero, the denominator of the fitness function is set to a very small value (0.0001) when both the between-class distance and the accuracy of the wrapped classifier are zero. The function calculates the distance between two histograms, which is defined as shown in Equation (12).
formula
12
formula
13
formula
14
Here and are the two histograms (e.g., sets of values), and and return the mean and standard deviation of a histogram, respectively.

The one-shot GP method uses some of the training set instances to be the basis for comparison and decision making, denoted as representative instances (). Each representative instance is randomly selected from the training set; however, only one instance of each class is selected. The number of representative instances is equal to the total number of classes. Each of the representative instances is assigned to one of the controller node children (i.e., the histogram nodes). The aim behind assigning an instance to a histogram node is to make this node responsible for identifying instances of only one class (i.e., identifying instances having a class label similar to that of the representative instance), which can be seen as a one-versus-all approach (Rifkin and Klautau, 2004). The rest of the training set instances form the nonrepresentative set (), which is used to measure the performance of the evolved program during the training phase.

The training process consists of four steps. In the first step, the system iterates over the list of the representative instances to extract the representative histograms, that is, each histogram node generates a single LBP histogram, relying on the regions detected by the area nodes and the assigned representative instance. The distance between the representative instances () is calculated using the generated representative histograms. In the second step, the overlapping ratio () of the detected regions is calculated using Equation (9). Third, the system uses the content of the nonrepresentative set to measure the performance of the wrapped classifier (ACC1) and calculates the within-class distance (). To accomplish this third step, the system generates a set of histograms for each instance (one from each histogram node), calculates the distance between each of the generated histograms and the corresponding representative histograms, and predicts a class label similar to that of the closest representative instance, namely, the nearest neighbour (1-NN) algorithm (Fix and Hodges, 1951). The fourth step is to measure the goodness of the evolved program, which is achieved via passing the calculated distances ( and ), overlapping ratio (), and accuracy (ACC1) to the fitness function. It is important to notice that at least two instances of each class are required to evolve the model, where one of them is used as a representative instance and one or more are used to populate the nonrepresentative set.

3.1.4  The Testing/Evaluation Procedure

The testing phase is handled differently from the training phase. The main concern of the evaluation phase is to test the generalisation ability of the best evolved program on unseen (i.e., testing set) data. Therefore, the proportion of the correctly classified instances to the total number of instances represents the final result of this phase.

In order to classify an instance, the system generates one histogram from each of the histogram nodes based on the region specified by this node’s area nodes. Then the distances between the generated histograms and the corresponding representative histograms are calculated. The class label is predicted based on 1-NN. In other words, the class label of the closest representative histogram is assigned to the instance being evaluated.

3.2  Compound GP

Figure 6 shows the general structure of a program evolved by the compound-GP method.

Figure 6:

General structure of a program evolved by the compound-GP method.

Figure 6:

General structure of a program evolved by the compound-GP method.

3.2.1  Function Set

As with one-shot GP, the tree evolved by the compound-GP method consists of three types of nonterminal nodes, as presented in Figure 6. The first is the special node that represents the root node similar to the controller node of the one-shot GP method. The main roles of this node are to generate and save a number of patch objects based on the results of its children, and to use the generated patch objects to train a number of wrapped classifiers. The patch object is made up of the mean and standard deviation values of a histogram generated from the instances being evaluated, along with the actual class label of the instance being evaluated. Unlike with the controller node of the one-shot GP method, the number of children of the special node is predefined and has no relation to the number of classes. Moreover, the children can be of different types, such as expander and area. The program evolved by the one-shot GP method consists of only one wrapped classifier, while the program evolved by compound-GP consists of four classifiers of two types for each child node (branch). The second type is the expander node, which is responsible for allowing the system to evolve programs of different sizes by having chains of this node. An example is presented in Figure 6, where the special node has three children, each of different tree size. The expander node does not alter the results of its children and only passes these results to its parent node. Hence, the appearance of this node in the program tree is optional. The third type of function is the area node. Similar to the area node of the one-shot GP method, this node resides near the leaves of the program tree. Each area node represents a detected region of the image. However, the numbers of children of this node are different in one-shot GP and compound-GP. In the former this node has three children (x, y, and size), whereas in the latter it has four children (rectangle).

3.2.2  Terminal Set

The terminal set consists of four integer-valued nodes: (1) x-coordinate (x for short); (2) y-coordinate (y for short); (3) window-width (w for short); and (4) window-height (h for short). Those four nodes represent a rectangular window of size and centered at a pixel with coordinates . The values of those four nodes are positive (including zero) and randomly selected from an associated predefined interval for each of them. The intervals of the x and y coordinates are and , respectively, where M and N are the image width and height, respectively. On the other hand, the values of w and h are selected from and , respectively. As with one-shot GP, the sampling windows are truncated if they exceed the boundaries of the image.

3.2.3  Fitness Measure

The fitness function of compound-GP is composed of three main components, as shown in Equation (15).
formula
15
formula
16
Here p-value is the between-groups difference, which is calculated using one-way analysis of variance (ANOVA); is the overlapping ratio between the detected regions of the image using Equation (9); and ACC2 is the total performance (accuracy) of the wrapped support vector machines (SVM) classifiers (Cortes and Vapnik, 1995) on the training set. C is the total number of children of the special node, which is a fixed predefined value that was empirically set to three in our experiments. The and are the ith SVM classifier, which is trained using the list of single and multipatch objects, respectively.

The training process of the compound-GP method is more complicated than that of the one-shot GP method. The process consists of eight steps, as depicted in Figure 7. In the first step, the system iterates over the set of the detected regions (area nodes) and calculates the ratio of overlapping () between those regions. Iterating over the instances of the training set and generating a number of LBP histograms for each instance (one from each area node) represent the second step. Each of those histograms is generated from an area node based on the region specified by the values of the four children (, and h) of that node. In the third step, the statistics (mean and standard deviation) of each of those histograms are calculated and used along with the actual class label of the instance being evaluated to construct a patch object and store it in the list of multiples, denoted , as demonstrated in Figure 8. In the fourth step, those histograms (generated from different area nodes) are concatenated with each other, the statistics of the resulting joined histogram are calculated, and a patch object is extracted using these statistics along with the actual class label of the instance being evaluated, as shown in Figure 8. The patch object constructed in this fourth step is stored in the list of singles denoted . Therefore, the result of the third and fourth steps is patch objects for each instance, where G is the total number of detected regions. Thus, the total number of patch objects in is the total number of training instances times the number of area nodes. Meanwhile, the list consists of a number of patch objects equal to the number of instances in the training set (one object per instance). The use of both local and global features has been shown to have potential to improve the classifier performance (Lisin et al., 2005; Lim and Galoogahi, 2010). Therefore, in this study, features generated from each of the detected regions (i.e., the list) as well as those resulting from the combination of multiple regions (i.e., the list) are used.

Figure 7:

Process of calculating the fitness value of a program evolved by the compound-GP method during the training phase.

Figure 7:

Process of calculating the fitness value of a program evolved by the compound-GP method during the training phase.

Figure 8:

How the detected regions of an image are used to extract three patch objects and add each of them to the list of multiples, and to extract only one patch object from the concatenated histograms and add it to the list of singles.

Figure 8:

How the detected regions of an image are used to extract three patch objects and add each of them to the list of multiples, and to extract only one patch object from the concatenated histograms and add it to the list of singles.

It is important to notice that the patch objects generated from each of the special node children are grouped together to form the and lists. In other words, each of the special node children has one of each of those two lists (C children × two lists). Moreover, each of the special node children has four classifiers, of two types: (1) two SVM classifiers, and (2) two kNN () classifiers. Only the SVM classifiers are used during the training process because the system is designed to evolve a program even when there is only one instance per class. The first SVM classifier is trained using the patch objects of the list and denoted . The second SVM classifier is trained using the objects of the list and denoted . Training those SVM classifiers represents the fifth step of the training procedure. In the sixth step, the performance of those SVM classifiers (ACC2) trained using the lists of patches of the corresponding branch is measured using the patch objects resulting from other branches. In the seventh step, the system measures the distinction of the detected regions (p-value) via the ANOVA test on the content of all lists. The last step of the training process is to calculate the fitness function value using the results of the first, sixth, and seventh steps.

In summary, the results of the training phase are two trained SVM classifiers and two lists of patches for each subtree (branch) of the special node. The lists of patches are used as the knowledge base for the two kNN classifiers of each subtree.

3.2.4  The Testing/Evaluation Procedure

The testing phase is quite different and less complicated than the training phase. In order to test an instance, the system feeds it to each subtree of the special node and performs the following steps. First, the system generates an LBP histogram from each of the detected regions and uses it to construct a patch object. Second, the constructed patch objects are then fed to SVM and kNN classifiers that were trained using the list, and the predicted class label of each of them is reported. Third, the generated histograms from the first step are then concatenated and used to produce a single patch object, which is then fed to SVM and kNN classifiers that were trained using the list, and the predicted class labels are also reported.

After repeating these three steps for each subtree of the special node, the system reports class labels, where C represents the total number of children of the special node, and 4 indicates four classifiers (two SVM and two kNN) associated with each child node. Adopting the voting approach, the system predicts the class label that has the majority of the votes. However, having an even number of classifiers may result in a situation where the votes are equally divided between the two classes. Such a situation is handled by relying on the closest instances (e.g., the smallest distance measured by all kNN classifiers).

4  Experimental Settings

In order to test the performance of the one-shot GP and compound-GP methods, a series of experiments were conducted that aimed at investigating different aspects. Generally, those experiments can be divided into four groups: (1) comparing the performance of the one-shot GP and compound-GP methods with the performance of the baseline methods; (2) checking the impact of the features extracted by each of the two methods (one-shot GP and compound-GP) on the performance of a number of classifiers compared to the use of handcrafted and two-tier GP extracted features; (3) investigating the ability of the two methods to handle the rotation variation; and (4) investigating the ability of the two methods to handle the scale variation.

This section provides more in-depth explanation of these experiments. The properties of the data sets that were used, parameter settings, baseline methods, and software characteristics are also discussed in this section.

4.1  Data Sets

The performance of the one-shot GP and compound-GP methods was evaluated using different types of data sets. The data sets can be categorised into four groups: three of them textures and the fourth object classification. Each data set in each group consists of only two classes (binary classification) of grayscale images. The following subsections provide detailed discussion of each of those four groups.

4.1.1  Group A

The instances of group A were taken from the Kylberg texture data set (Kylberg, 2011). The Kylberg texture data set consists of 28 classes, as shown in Figure 9. This data set comes in two flavours: (1) without rotation, and (2) with rotation. The instances of both groups are grayscale, each of size pixels.

Figure 9:

Sample of each of the 28 classes of the Kylberg texture data set.

Figure 9:

Sample of each of the 28 classes of the Kylberg texture data set.

Each class of the without-rotation group consists of 160 unique instances. We selected eight visually close classes of this group (textures without rotation) to form four data sets for binary classification. Textures-1 is the first set, made up of the stoneslab1 and wall1 classes. Textures-2 is the second set, made up of the rice2 and sesameseeds1 classes. The blanket1 and canvas1 classes form the third set, Textures-3. The fourth set, Textures-4, consists of the linseds1 and pearlsugar1 classes.

4.1.2  Group B

The data set of group B was taken from the KTH-Textures under varying Illumination, Pose, and Scale (KTH-TIPS) image data set (Bratko et al., 2006). The KTH-TIPS image data set consists of ten classes, as depicted in Figure 10, where each consists of 81 instances of size pixels.

Figure 10:

Sample of each class of the KTH-TIPS dataset.

Figure 10:

Sample of each class of the KTH-TIPS dataset.

We selected only two classes that are visually close to form the Textures-5 data set. This data set is more challenging than other texture data sets that were used in this study because of the scale variation of its instances, which imposes more difficulties for the model to handle.

4.1.3  Group C

The instances of group C were also taken from the Kylberg texture data set. However, the aim of this group’s data sets is to test whether the one-shot GP and compound-GP methods are invariant to rotation. Therefore, the classes of this group’s data sets were drawn from the with-rotation classes of Kylberg texture. Each class of the with-rotation group consists of 1,920 instances that are the same 160 instances of the without-rotation group rotated about the center in 12 different angles (). The instances are rotated between 0 and 330 degrees in 30-degree increments. An example of an instance of the rice2 class rotated at different angles is presented in Figure 11. For comparison purposes, the same images that were selected from the without-rotation group of the Kylberg texture data set to form Textures-1, Textures-2, Textures-3, and Textures-4 were selected from the with-rotation group to form the Textures-6, Textures-7, Textures-8, and Textures-9 data sets, respectively.

Figure 11:

Sample from the rice2 class of the Kylberg texture data set rotated about the center in 12 different angles taken from the with-rotation group.

Figure 11:

Sample from the rice2 class of the Kylberg texture data set rotated about the center in 12 different angles taken from the with-rotation group.

4.1.4  Group D

Like group B, group D consists of only one data set, which is the CBCL Faces data set (Heisele et al., 2000). Unlike the data sets of the previous groups, Faces is not texture-based, and the task is to discriminate between face and nonface instances. Therefore, the use of this data set allowed us to test the ability of the one-shot GP and compound-GP methods to handle a task other than texture classification.

Each instance of the CBCL Faces data set is pixels in size, where the face instances are hand-aligned to be relatively in the center of the example. Originally, there are face and nonface instances in the training set, and 472 face and nonface instances in the testing set. Clearly, the number of instances of the two classes is highly unbalanced; hence, we did not use the original division of the data and instead selected a nearly equal number of instances of each class. In other words, instances in total were selected from the two classes— faces and nonfaces—to form the faces data set in our experiments.

4.2  Data Set Preparation

Applying different image-processing techniques as a preprocessing step can significantly affect the performance of the model. Some of the well-known operations are histogram equalisation, quantisation, and convolution operators such as Gaussian blurring. However, different data sets require different processing schemes, and thus can be even harder if the instances of the same data set are captured in an uncontrolled environment.

The total number of instances of each class was divided equally between the training and testing sets. Moreover, the original instances were used without applying any image preprocessing in order to investigate the ability of the one-shot GP and compound-GP methods to handle the shifting of pixel values. However, each instance of the Kylberg texture data set was resampled (resized) to pixels in our experiments in order to reduce the computational costs.

Apart from the conventional-GP method, all other GP methods operate on raw pixel values and automatically detect and extract features. However, conventional-GP and all the non-GP methods require a prior step to detect and extract feature vectors, which needs to be handled by a domain expert in order to design highly discriminative features. Thus, the features of all texture-based data sets were extracted from 10 regions (Zhang et al., 2003), as shown in Figure 12a. The mean and standard deviation statistics of each of the four quadrants (AEQH, EBFQ, HQGD, and QFCG), the central quarter (IJKL), the horizontal lines (HF and PN), the vertical lines (EG and MO), and the entire image (ABCD) were calculated to form a feature vector consisting of 20 values. Similarly, the mean and standard deviation of the eyes (LMFD), nose (JKON), mouth (PQSR), and the four quadrants (ABED, BCFE, DEHG, and EFIH) were calculated for each of the faces data set instances to construct a feature vector consisting of 14 values. The regions of the faces data set were designed based on the work of Bhowan et al. (2009), as shown in Figure 12b.

Figure 12:

Regions of extracted features of (a) the texture data set, and (b) the faces data set.

Figure 12:

Regions of extracted features of (a) the texture data set, and (b) the faces data set.

4.3  Baseline Methods

In order to check the effectiveness of the proposed methods, a number of GP and non-GP methods were evaluated on the experimental data sets.

4.3.1  GP-based Methods

The one-shot GP and compound-GP methods were compared with two GP-based methods. Conventional-GP, the first method, has a function set made up of the four arithmetic operators and . Those operators have their regular meaning apart from the operator, which is protected to return zero if the second variable (denominator) is zero. The terminal set, on the other hand, consists of rand, which is a randomly generated double-precision float value between and (inclusive), and Fi, where i represents the index of the feature. As mentioned earlier, this method relies on domain-specific handcrafted features. The fitness measure of conventional-GP in both the training and testing phases is accuracy, which is formally defined as
formula
17
where and are the number of true positives, true negatives, false positives, and false negatives, respectively.

The two-tier GP method (Al-Sahaf et al., 2012b) is made up of two tiers, each specified to perform a specific task. The upper part of the program’s tree (first tier) represents the classification part, which consists of the four arithmetic operators (similar to conventional-GP) and if-then-else. Unlike other operators, the if-then-else operation has three children, returning the value of the second child if the value of the first child is negative and the value of the third child otherwise. The second tier, which occupies the lower part of the evolved program’s tree, represents the aggregation part, consisting of special nodes to perform the feature extraction task. Unlike the conventional-GP method, the two-tier GP method operates directly on the image raw pixel values, and no preprocessing is required.

In both the conventional-GP and two-tier GP methods, the program output space is divided into two parts, each of which corresponds to a group of instances of the same class label: negative, and positive including the zero value. Therefore, an instance is classified as belonging to a group (e.g., foreground) if the value of the root node is negative; otherwise, it is classified as belonging to another group (e.g., background).

4.3.2  Non-GP Methods

The developed methods are compared to six non-GP methods:

  • Naïve Bayes (NB) (John and Langley, 1995), a probabilistic classifier based on the use of Bayes’s theorem

  • Support vector machines (SVM) (Cortes and Vapnik, 1995), trained using the sequential minimal optimisation (SOM) algorithm invented by Platt (1999)

  • Naïve Bayes/decision trees (NBTree) (Kohavi, 1996), a hybridised method that combines decision trees with the Naïve Bayes classifier. The latter represents the leaves of the tree.

  • Adaptive boosting M1 (AdaBoostM1) (Freund and Schapire, 1996), an adaptive method that relies on misclassified instances by previous classifiers to improve the subsequent ones

  • K (KStar) (Cleary and Trigg, 1995), an instance-based method that uses an entropy-based distance measure to predict the class label of an instance based upon the similar instances of the training set

  • Non-nested generalized (NNge) (Martin, 1995), an instance-based classifier that uses a non-nested exemplar, which works in a similar way to the nearest neighbour method.

4.4  Evaluation

To evaluate each of the four GP-based methods (conventional-GP, two-tier GP, one-shot GP, and compound-GP), a specified number of instances of each class were randomly selected from the total number of instances available in the training set. The best evolved program using the selected instances at the end of the run was tested against the unseen data (testing set). Because of the stochastic nature of GP, the same process was independently executed 50 times using a different starting point (seed value) each time, and only the average performance is reported. The non-GP methods, on the other hand, were trained using the same instances but without repeating the execution multiple times (deterministic methods).

Moreover, because of the impact of the selected instances on the performance of the evolved classifier, the 50 runs of each GP-based method and the single execution of the non-GP methods were repeated 20 times using different instances each time. Therefore, the total number of independent runs on a single data set is [4 GP methods × 50 runs × 20 repetitions] + [6 non-GP methods × 1 run × 20 repetitions] = . The standard deviation over the 20 repetitions (i.e., 20 average performances) is reported.

This procedure was further repeated ten times using training sets of different sizes starting from the minimum number (only one instance per class) and increasing by one instance every time (the largest is ten instances per class). However, the smallest number of instances per class that can be used to evolve a program by the one-shot GP method is two (one representative and one or more nonrepresentative); therefore, in the case of this method, the process was repeated nine times instead of ten. The ten repetitions make the total number of executions on each data set [[ runs × 3 methods × 10 sets] + [ runs × 1 method × 9 sets] GP methods + [120 run × 10 sets] non-GP methods] = .

4.5  Feature Extraction

The two new GP methods have their own mechanisms to perform feature extraction; hence, they can also be used for automatic feature extraction. The impact of the features detected and extracted by one-shot GP and compound-GP on the performance of six different classifiers is also investigated in this study. The classifiers are the non-GP baseline methods discussed in Section 4.3. To measure the goodness of the features extracted by one-shot GP and compound-GP, the handcrafted features (see Section 4.2) and those extracted by two-tier GP (Al-Sahaf et al., 2012a) are used.

In the case of the one-shot GP method, the mean and standard deviation values were calculated for each LBP histogram resulting from each histogram node. As discussed in Section 3.1, each evolved program has two histogram nodes; therefore, the feature vector of each instance consists of four values.

Similarly, the features extracted by the compound-GP method represent the calculated statistics (mean and standard deviation) of the resulting LBP histograms. However, the program evolved by compound-GP generates a number of histograms for each instance. Moreover, some histograms are generated from the area nodes, while others result from the concatenation of histograms as described in Section 3.2. In other words, the patch objects of (list of singles) and (list of multiples) are used as the extracted features. As it is hard to guess which of the two lists is better than the other, we used each of them in isolation from the other as well as the combination of the two.

4.6  Parameter Settings

In this study, four GP methods were used. For comparison purposes, the settings of those methods’ parameters are kept identical in all the experiments, as listed in Table 1. It is important to notice that some of the parameters are not applicable in the case of one-shot GP because of the restrictions of the evolved program by this method.

Table 1:
The GP parameters of all experiments.
ParameterValueConventional-GPTwo-Tier GPOne-Shot GPCompound-GP
Crossover rate 0.80 ✓ ✓ ✓ ✓ 
Mutation rate 0.19 ✓ ✓ ✓ ✓ 
Elitism rate 0.01 ✓ ✓ ✓ ✓ 
Population size 200 ✓ ✓ ✓ ✓ 
Generations 20 ✓ ✓ ✓ ✓ 
Tree depth 2-10 ✓ ✓ ✗ ✓ 
Selection type Tournament ✓ ✓ ✓ ✓ 
Tournament size ✓ ✓ ✓ ✓ 
Initial population Ramped half-and-half ✓ ✓ ✗ ✓ 
ParameterValueConventional-GPTwo-Tier GPOne-Shot GPCompound-GP
Crossover rate 0.80 ✓ ✓ ✓ ✓ 
Mutation rate 0.19 ✓ ✓ ✓ ✓ 
Elitism rate 0.01 ✓ ✓ ✓ ✓ 
Population size 200 ✓ ✓ ✓ ✓ 
Generations 20 ✓ ✓ ✓ ✓ 
Tree depth 2-10 ✓ ✓ ✗ ✓ 
Selection type Tournament ✓ ✓ ✓ ✓ 
Tournament size ✓ ✓ ✓ ✓ 
Initial population Ramped half-and-half ✓ ✓ ✗ ✓ 

4.7  Implementation

The GP-based methods were implemented using the platform provided by the Evolutionary Computation Java-based (ECJ) package (Luke, 2013). The implementation of the non-GP methods was taken from the Waikato Environment for Knowledge Analysis (WEKA) package (Hall et al., 2009).

5  Results and Discussion

The results of the experiments are reported and discussed in this section. The performances of one-shot GP, compound-GP, and all the baseline methods in terms of accuracy are presented in the first subsection. The goodness of the features extracted by one-shot GP and compound-GP are compared to the handcrafted areas and those extracted by two-tier GP in the second subsection. The third subsection discusses the training and testing times of the four GP-based methods used in this study. The fourth subsection shows the complexity of the evolved program in terms of the average size per generation of the four GP-based methods.

5.1  Accuracy

The results of this experiment are presented in Tables 25. Each table aggregates the results of data sets of one group. The names of the data sets appear alongside the tables, and the total number of instances per class that were used in the training set are shown in the size column. Each table is divided into two parts, the first listing the results of the non-GP methods, and the second, the results of the GP-based methods. The result of the one-shot GP method is missing from the first row of all tables (indicated by N/A) because the minimum number of instances required by this method is two of each class.

Table 2:
Results of the group A data sets.
Non-GP MethodsGP-based Methods
SizeABoostM1KStarNBNBTreeNNgeSVMConven.Two-TierOne-ShotCompound
Textures-1 99.4 ± 0.5 61.1 ± 7.1  57.0 ± 5.8  63.7 ± 8.3  52.5 ± 6.9  52.5 ± 6.9  54.1 ± 3.5  51.0 ± 0.8  N/A 96.5 ± 1.7 
 99.4 ± 0.3↓⇓ 67.3 ± 12.6↑⇑ 68.7 ± 15.1↑⇑ 61.3 ± 12.2↑⇑ 63.4 ± 11.5↑⇑ 62.6 ± 11.4↑⇑ 55.4 ± 3.8↑⇑ 51.9 ± 1.1↑⇑ 90.7 ± 1.3 97.1 ± 1.0 
 99.4 ± 0.3↓⇓ 71.1 ± 12.3↑⇑ 75.8 ± 17.7↑⇑ 68.0 ± 18.2↑⇑ 74.0 ± 15.8↑⇑ 73.0 ± 14.4↑⇑ 57.1 ± 3.7↑⇑ 52.4 ± 1.1↑⇑ 90.6 ± 1.1 97.5 ± 0.6 
 99.4 ± 0.3↓⇓ 70.0 ± 11.0↑⇑ 82.2 ± 17.6↑⇑ 79.5 ± 19.6↑⇑ 83.3 ± 16.3↑⇑ 80.0 ± 12.7↑⇑ 58.3 ± 3.9↑⇑ 53.2 ± 1.4↑⇑ 91.0 ± 0.8 97.6 ± 0.4 
 99.4 ± 0.3↓⇓ 70.0 ± 8.2 ↑⇑ 86.5 ± 15.8↑⇑ 77.7 ± 17.4↑⇑ 89.3 ± 14.9↑⇑ 86.4 ± 11.8↑⇑ 59.1 ± 3.8↑⇑ 53.4 ± 1.2↑⇑ 92.1 ± 0.5 97.6 ± 0.4 
 99.4 ± 0.3↓⇓ 69.0 ± 6.4 ↑⇑ 90.8 ± 12.8↑⇑ 90.1 ± 12.8↑⇑ 94.5 ± 9.7 ↓⇑ 89.8 ± 8.2 ↑⇑ 60.2 ± 3.6↑⇑ 53.2 ± 1.2↑⇑ 92.9 ± 0.4 97.6 ± 0.3 
 99.4 ± 0.2↓⇓ 68.9 ± 5.1 ↑⇑ 95.0 ± 7.9 ↓⇑ 89.8 ± 9.0 ↑⇑ 97.7 ± 2.6  94.0 ± 4.6 ↓⇑ 60.7 ± 3.3↑⇑ 53.7 ± 1.2↑⇑ 93.2 ± 0.6 97.7 ± 0.2 
 99.4 ± 0.1↓⇓ 69.0 ± 4.4 ↑⇑ 97.5 ± 1.6  88.0 ± 8.1 ↑⇑ 98.9 ± 1.3 ↓⇓ 94.7 ± 3.7 ↓⇑ 61.2 ± 2.5↑⇑ 53.9 ± 1.2↑⇑ 93.4 ± 0.5 97.7 ± 0.2 
 99.4 ± 0.1↓⇓ 69.3 ± 4.2 ↑⇑ 97.2 ± 1.8 ↓⇑ 88.0 ± 9.6 ↑⇑ 99.1 ± 0.9 ↓⇓ 93.9 ± 4.4  61.1 ± 2.3↑⇑ 54.5 ± 0.9↑⇑ 93.7 ± 0.5 97.7 ± 0.1 
 10 99.4 ± 0.1↓⇓ 70.8 ± 4.6 ↑⇑ 96.3 ± 3.3 ↓⇓ 88.4 ± 8.8 ↑⇑ 99.1 ± 0.8 ↓⇓ 94.4 ± 3.9 ↓⇑ 61.1 ± 2.9↑⇑ 54.5 ± 1.1↑⇑ 94.0 ± 0.4 97.7 ± 0.1 
Textures-2 52.3 ± 11.3  97.4 ± 1.9  74.7 ± 7.8  96.3 ± 2.9  69.7 ± 9.8  69.7 ± 9.8  53.8 ± 2.2  50.3 ± 0.6  N/A 100.0 ± 0.0 
 79.6 ± 25.6↑⇑ 98.2 ± 2.2↑⇑ 92.1 ± 9.6↑⇑ 99.8 ± 0.6↑⇑ 95.0 ± 9.5↑⇑ 95.6 ± 6.9↑⇑ 59.7 ± 4.0↑⇑ 51.1 ± 0.8↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 92.3 ± 18.9↑⇑ 99.8 ± 0.3↑⇑ 95.9 ± 6.6↑⇑ 100.0 ± 0.0 99.1 ± 2.2↑⇑ 98.8 ± 1.3↑⇑ 65.6 ± 5.7↑⇑ 51.7 ± 0.9↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.1  99.1 ± 2.0↑⇑ 100.0 ± 0.1  99.9 ± 0.2↑⇑ 99.5 ± 1.1↑⇑ 70.1 ± 5.7↑⇑ 52.2 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.1  99.3 ± 2.5↑⇑ 100.0 ± 0.0 100.0 ± 0.0 99.8 ± 0.4↑⇑ 73.0 ± 5.0↑⇑ 52.3 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.1  99.8 ± 0.6↑⇑ 100.0 ± 0.0 100.0 ± 0.0 99.9 ± 0.3↑⇑ 74.7 ± 4.3↑⇑ 52.4 ± 0.9↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.0 99.4 ± 2.0↑⇑ 100.0 ± 0.0 100.0 ± 0.0 99.9 ± 0.3↑⇑ 77.5 ± 3.3↑⇑ 52.6 ± 1.1↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.0 99.5 ± 1.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 99.9 ± 0.2↑⇑ 78.0 ± 3.6↑⇑ 53.0 ± 1.0↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.0 99.7 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.1  78.1 ± 3.2↑⇑ 53.0 ± 0.9↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 10 100.0 ± 0.0  100.0 ± 0.0 99.9 ± 0.2↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 78.7 ± 3.8↑⇑ 53.6 ± 0.8↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
Textures-3 57.7 ± 24.9  90.8 ± 4.2 74.8 ± 9.8  90.8 ± 4.5 66.3 ± 14.2  66.3 ± 14.2  67.4 ± 4.5  51.0 ± 1.1  N/A 89.4 ± 8.7 
 83.6 ± 16.7↓⇑ 90.8 ± 4.8↓⇑ 85.3 ± 9.7↓⇑ 91.9 ± 3.5 90.3 ± 8.1 ↓⇑ 87.7 ± 10.3↓⇑ 80.4 ± 4.9  53.0 ± 1.2↑⇑ 79.3 ± 3.1 92.0 ± 2.3 
 89.0 ± 4.6 ↓⇑ 93.0 ± 3.4 87.2 ± 7.5↓⇑ 91.5 ± 3.1 93.3 ± 3.5↓⇓ 92.8 ± 4.9  87.0 ± 2.7↓⇑ 54.7 ± 1.6↑⇑ 79.3 ± 2.4 92.2 ± 2.3 
 90.3 ± 2.1 ↓⇑ 93.0 ± 2.9 89.1 ± 6.3↓⇑ 92.1 ± 2.1 93.0 ± 3.3  94.3 ± 3.3↓⇓ 89.2 ± 1.6↓⇑ 55.8 ± 1.7↑⇑ 80.4 ± 2.1 92.2 ± 2.1 
 90.3 ± 2.2 ↓⇑ 93.0 ± 3.0 89.4 ± 4.6↓⇑ 92.3 ± 2.4 92.3 ± 2.7  94.8 ± 2.1↓⇓ 90.5 ± 0.9↓⇑ 56.7 ± 1.8↑⇑ 81.9 ± 1.7 92.4 ± 1.8 
 90.4 ± 2.2 ↓⇑ 93.6 ± 2.2↓⇓ 89.2 ± 4.1↓⇑ 91.6 ± 2.6 92.2 ± 2.8  94.5 ± 2.3↓⇓ 90.7 ± 0.9↓⇑ 58.1 ± 1.4↑⇑ 82.8 ± 1.2 92.3 ± 1.8 
 90.3 ± 2.3 ↓⇑ 93.8 ± 1.8↓⇓ 88.0 ± 4.4↓⇑ 91.7 ± 2.5 92.0 ± 2.6  94.1 ± 2.6↓⇓ 91.0 ± 0.9↓⇑ 58.7 ± 1.5↑⇑ 84.1 ± 1.4 92.4 ± 1.7 
 90.5 ± 2.5 ↓⇑ 93.8 ± 1.9↓⇓ 88.9 ± 3.5↓⇑ 92.4 ± 2.3 91.9 ± 2.5  93.8 ± 2.3↓⇓ 91.2 ± 1.1↓⇑ 59.1 ± 1.4↑⇑ 84.1 ± 1.3 92.4 ± 1.6 
 90.7 ± 2.6 ↓⇑ 93.8 ± 2.0↓⇓ 89.1 ± 3.6↓⇑ 92.3 ± 2.2 91.9 ± 2.1  93.6 ± 2.2 ↓⇓ 91.4 ± 1.1↓⇑ 60.1 ± 1.1↑⇑ 84.6 ± 1.5 92.5 ± 1.6 
 10 90.6 ± 2.6 ↓⇑ 93.6 ± 2.0↓⇓ 89.6 ± 3.2↓⇑ 92.4 ± 2.4 92.0 ± 2.0 ↓⇑ 93.0 ± 2.6  91.4 ± 1.1↓⇑ 60.7 ± 1.0↑⇑ 85.0 ± 1.6 92.8 ± 1.4 
Textures-4 53.7 ± 7.0  72.2 ± 7.5  67.3 ± 7.0  73.3 ± 7.2  57.7 ± 16.6  57.7 ± 16.6  50.4 ± 1.3  50.0 ± 0.5  N/A 95.1 ± 3.2 
 79.1 ± 13.6↑⇑ 74.3 ± 7.4↑⇑ 66.8 ± 8.4↑⇑ 80.5 ± 6.6  78.8 ± 8.0 ↑⇑ 76.9 ± 8.2 ↑⇑ 51.5 ± 1.6↑⇑ 50.3 ± 0.5↑⇑ 81.9 ± 4.1 95.7 ± 2.3 
 87.6 ± 8.5 ↓⇑ 76.0 ± 5.9↑⇑ 74.8 ± 7.1↑⇑ 84.0 ± 6.8 ↓⇑ 81.2 ± 7.5  81.2 ± 7.6  52.0 ± 1.7↑⇑ 50.5 ± 0.5↑⇑ 79.6 ± 5.4 96.0 ± 2.4 
 87.5 ± 8.1 ↓⇑ 77.2 ± 6.1↑⇑ 79.6 ± 7.9  76.4 ± 13.3↑⇑ 84.0 ± 7.2 ↓⇑ 82.6 ± 6.8 ↓⇑ 52.5 ± 1.6↑⇑ 50.4 ± 0.6↑⇑ 79.6 ± 5.3 96.1 ± 2.1 
 87.5 ± 8.7 ↓⇑ 76.8 ± 6.1↑⇑ 83.8 ± 6.5↓⇑ 84.2 ± 5.1 ↓⇑ 85.5 ± 6.1 ↓⇑ 85.5 ± 5.7 ↓⇑ 52.7 ± 1.6↑⇑ 50.3 ± 0.4↑⇑ 81.7 ± 3.6 97.1 ± 1.2 
 87.8 ± 6.5 ↓⇑ 77.5 ± 6.4↑⇑ 83.2 ± 6.3  80.8 ± 12.0↑⇑ 87.0 ± 5.8 ↓⇑ 86.6 ± 4.8 ↓⇑ 53.5 ± 1.7↑⇑ 50.6 ± 0.5↑⇑ 82.9 ± 3.7 97.3 ± 0.9 
 87.5 ± 5.5 ↓⇑ 77.6 ± 6.3↑⇑ 83.4 ± 4.9  86.3 ± 5.5 ↓⇑ 89.5 ± 4.6 ↓⇑ 87.7 ± 4.4 ↓⇑ 54.4 ± 2.1↑⇑ 50.7 ± 0.5↑⇑ 84.4 ± 3.0 97.6 ± 0.6 
 88.4 ± 4.1 ↓⇑ 77.6 ± 6.9↑⇑ 83.1 ± 4.6↑⇑ 87.7 ± 4.6 ↓⇑ 89.9 ± 4.2 ↓⇑ 87.2 ± 3.5 ↓⇑ 54.8 ± 1.2↑⇑ 50.6 ± 0.5↑⇑ 85.5 ± 2.7 97.7 ± 0.6 
 88.3 ± 3.7 ↓⇑ 77.4 ± 6.5↑⇑ 84.1 ± 4.4↑⇑ 86.6 ± 4.4  90.6 ± 4.2 ↓⇑ 87.9 ± 4.4 ↓⇑ 55.1 ± 1.7↑⇑ 50.6 ± 0.5↑⇑ 86.4 ± 2.3 97.7 ± 0.5 
 10 87.5 ± 4.0  77.6 ± 6.1↑⇑ 84.7 ± 3.7↑⇑ 87.4 ± 4.7  90.8 ± 4.0 ↓⇑ 87.5 ± 5.0  55.0 ± 2.0↑⇑ 50.7 ± 0.6↑⇑ 87.1 ± 1.7 97.9 ± 0.4 
Non-GP MethodsGP-based Methods
SizeABoostM1KStarNBNBTreeNNgeSVMConven.Two-TierOne-ShotCompound
Textures-1 99.4 ± 0.5 61.1 ± 7.1  57.0 ± 5.8  63.7 ± 8.3  52.5 ± 6.9  52.5 ± 6.9  54.1 ± 3.5  51.0 ± 0.8  N/A 96.5 ± 1.7 
 99.4 ± 0.3↓⇓ 67.3 ± 12.6↑⇑ 68.7 ± 15.1↑⇑ 61.3 ± 12.2↑⇑ 63.4 ± 11.5↑⇑ 62.6 ± 11.4↑⇑ 55.4 ± 3.8↑⇑ 51.9 ± 1.1↑⇑ 90.7 ± 1.3 97.1 ± 1.0 
 99.4 ± 0.3↓⇓ 71.1 ± 12.3↑⇑ 75.8 ± 17.7↑⇑ 68.0 ± 18.2↑⇑ 74.0 ± 15.8↑⇑ 73.0 ± 14.4↑⇑ 57.1 ± 3.7↑⇑ 52.4 ± 1.1↑⇑ 90.6 ± 1.1 97.5 ± 0.6 
 99.4 ± 0.3↓⇓ 70.0 ± 11.0↑⇑ 82.2 ± 17.6↑⇑ 79.5 ± 19.6↑⇑ 83.3 ± 16.3↑⇑ 80.0 ± 12.7↑⇑ 58.3 ± 3.9↑⇑ 53.2 ± 1.4↑⇑ 91.0 ± 0.8 97.6 ± 0.4 
 99.4 ± 0.3↓⇓ 70.0 ± 8.2 ↑⇑ 86.5 ± 15.8↑⇑ 77.7 ± 17.4↑⇑ 89.3 ± 14.9↑⇑ 86.4 ± 11.8↑⇑ 59.1 ± 3.8↑⇑ 53.4 ± 1.2↑⇑ 92.1 ± 0.5 97.6 ± 0.4 
 99.4 ± 0.3↓⇓ 69.0 ± 6.4 ↑⇑ 90.8 ± 12.8↑⇑ 90.1 ± 12.8↑⇑ 94.5 ± 9.7 ↓⇑ 89.8 ± 8.2 ↑⇑ 60.2 ± 3.6↑⇑ 53.2 ± 1.2↑⇑ 92.9 ± 0.4 97.6 ± 0.3 
 99.4 ± 0.2↓⇓ 68.9 ± 5.1 ↑⇑ 95.0 ± 7.9 ↓⇑ 89.8 ± 9.0 ↑⇑ 97.7 ± 2.6  94.0 ± 4.6 ↓⇑ 60.7 ± 3.3↑⇑ 53.7 ± 1.2↑⇑ 93.2 ± 0.6 97.7 ± 0.2 
 99.4 ± 0.1↓⇓ 69.0 ± 4.4 ↑⇑ 97.5 ± 1.6  88.0 ± 8.1 ↑⇑ 98.9 ± 1.3 ↓⇓ 94.7 ± 3.7 ↓⇑ 61.2 ± 2.5↑⇑ 53.9 ± 1.2↑⇑ 93.4 ± 0.5 97.7 ± 0.2 
 99.4 ± 0.1↓⇓ 69.3 ± 4.2 ↑⇑ 97.2 ± 1.8 ↓⇑ 88.0 ± 9.6 ↑⇑ 99.1 ± 0.9 ↓⇓ 93.9 ± 4.4  61.1 ± 2.3↑⇑ 54.5 ± 0.9↑⇑ 93.7 ± 0.5 97.7 ± 0.1 
 10 99.4 ± 0.1↓⇓ 70.8 ± 4.6 ↑⇑ 96.3 ± 3.3 ↓⇓ 88.4 ± 8.8 ↑⇑ 99.1 ± 0.8 ↓⇓ 94.4 ± 3.9 ↓⇑ 61.1 ± 2.9↑⇑ 54.5 ± 1.1↑⇑ 94.0 ± 0.4 97.7 ± 0.1 
Textures-2 52.3 ± 11.3  97.4 ± 1.9  74.7 ± 7.8  96.3 ± 2.9  69.7 ± 9.8  69.7 ± 9.8  53.8 ± 2.2  50.3 ± 0.6  N/A 100.0 ± 0.0 
 79.6 ± 25.6↑⇑ 98.2 ± 2.2↑⇑ 92.1 ± 9.6↑⇑ 99.8 ± 0.6↑⇑ 95.0 ± 9.5↑⇑ 95.6 ± 6.9↑⇑ 59.7 ± 4.0↑⇑ 51.1 ± 0.8↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 92.3 ± 18.9↑⇑ 99.8 ± 0.3↑⇑ 95.9 ± 6.6↑⇑ 100.0 ± 0.0 99.1 ± 2.2↑⇑ 98.8 ± 1.3↑⇑ 65.6 ± 5.7↑⇑ 51.7 ± 0.9↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.1  99.1 ± 2.0↑⇑ 100.0 ± 0.1  99.9 ± 0.2↑⇑ 99.5 ± 1.1↑⇑ 70.1 ± 5.7↑⇑ 52.2 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.1  99.3 ± 2.5↑⇑ 100.0 ± 0.0 100.0 ± 0.0 99.8 ± 0.4↑⇑ 73.0 ± 5.0↑⇑ 52.3 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.1  99.8 ± 0.6↑⇑ 100.0 ± 0.0 100.0 ± 0.0 99.9 ± 0.3↑⇑ 74.7 ± 4.3↑⇑ 52.4 ± 0.9↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.0 99.4 ± 2.0↑⇑ 100.0 ± 0.0 100.0 ± 0.0 99.9 ± 0.3↑⇑ 77.5 ± 3.3↑⇑ 52.6 ± 1.1↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.0 99.5 ± 1.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 99.9 ± 0.2↑⇑ 78.0 ± 3.6↑⇑ 53.0 ± 1.0↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 100.0 ± 0.0  100.0 ± 0.0 99.7 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.1  78.1 ± 3.2↑⇑ 53.0 ± 0.9↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 10 100.0 ± 0.0  100.0 ± 0.0 99.9 ± 0.2↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 78.7 ± 3.8↑⇑ 53.6 ± 0.8↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
Textures-3 57.7 ± 24.9  90.8 ± 4.2 74.8 ± 9.8  90.8 ± 4.5 66.3 ± 14.2  66.3 ± 14.2  67.4 ± 4.5  51.0 ± 1.1  N/A 89.4 ± 8.7 
 83.6 ± 16.7↓⇑ 90.8 ± 4.8↓⇑ 85.3 ± 9.7↓⇑ 91.9 ± 3.5 90.3 ± 8.1 ↓⇑ 87.7 ± 10.3↓⇑ 80.4 ± 4.9  53.0 ± 1.2↑⇑ 79.3 ± 3.1 92.0 ± 2.3 
 89.0 ± 4.6 ↓⇑ 93.0 ± 3.4 87.2 ± 7.5↓⇑ 91.5 ± 3.1 93.3 ± 3.5↓⇓ 92.8 ± 4.9  87.0 ± 2.7↓⇑ 54.7 ± 1.6↑⇑ 79.3 ± 2.4 92.2 ± 2.3 
 90.3 ± 2.1 ↓⇑ 93.0 ± 2.9 89.1 ± 6.3↓⇑ 92.1 ± 2.1 93.0 ± 3.3  94.3 ± 3.3↓⇓ 89.2 ± 1.6↓⇑ 55.8 ± 1.7↑⇑ 80.4 ± 2.1 92.2 ± 2.1 
 90.3 ± 2.2 ↓⇑ 93.0 ± 3.0 89.4 ± 4.6↓⇑ 92.3 ± 2.4 92.3 ± 2.7  94.8 ± 2.1↓⇓ 90.5 ± 0.9↓⇑ 56.7 ± 1.8↑⇑ 81.9 ± 1.7 92.4 ± 1.8 
 90.4 ± 2.2 ↓⇑ 93.6 ± 2.2↓⇓ 89.2 ± 4.1↓⇑ 91.6 ± 2.6 92.2 ± 2.8  94.5 ± 2.3↓⇓ 90.7 ± 0.9↓⇑ 58.1 ± 1.4↑⇑ 82.8 ± 1.2 92.3 ± 1.8 
 90.3 ± 2.3 ↓⇑ 93.8 ± 1.8↓⇓ 88.0 ± 4.4↓⇑ 91.7 ± 2.5 92.0 ± 2.6  94.1 ± 2.6↓⇓ 91.0 ± 0.9↓⇑ 58.7 ± 1.5↑⇑ 84.1 ± 1.4 92.4 ± 1.7 
 90.5 ± 2.5 ↓⇑ 93.8 ± 1.9↓⇓ 88.9 ± 3.5↓⇑ 92.4 ± 2.3 91.9 ± 2.5  93.8 ± 2.3↓⇓ 91.2 ± 1.1↓⇑ 59.1 ± 1.4↑⇑ 84.1 ± 1.3 92.4 ± 1.6 
 90.7 ± 2.6 ↓⇑ 93.8 ± 2.0↓⇓ 89.1 ± 3.6↓⇑ 92.3 ± 2.2 91.9 ± 2.1  93.6 ± 2.2 ↓⇓ 91.4 ± 1.1↓⇑ 60.1 ± 1.1↑⇑ 84.6 ± 1.5 92.5 ± 1.6 
 10 90.6 ± 2.6 ↓⇑ 93.6 ± 2.0↓⇓ 89.6 ± 3.2↓⇑ 92.4 ± 2.4 92.0 ± 2.0 ↓⇑ 93.0 ± 2.6  91.4 ± 1.1↓⇑ 60.7 ± 1.0↑⇑ 85.0 ± 1.6 92.8 ± 1.4 
Textures-4 53.7 ± 7.0  72.2 ± 7.5  67.3 ± 7.0  73.3 ± 7.2  57.7 ± 16.6  57.7 ± 16.6  50.4 ± 1.3  50.0 ± 0.5  N/A 95.1 ± 3.2 
 79.1 ± 13.6↑⇑ 74.3 ± 7.4↑⇑ 66.8 ± 8.4↑⇑ 80.5 ± 6.6  78.8 ± 8.0 ↑⇑ 76.9 ± 8.2 ↑⇑ 51.5 ± 1.6↑⇑ 50.3 ± 0.5↑⇑ 81.9 ± 4.1 95.7 ± 2.3 
 87.6 ± 8.5 ↓⇑ 76.0 ± 5.9↑⇑ 74.8 ± 7.1↑⇑ 84.0 ± 6.8 ↓⇑ 81.2 ± 7.5  81.2 ± 7.6  52.0 ± 1.7↑⇑ 50.5 ± 0.5↑⇑ 79.6 ± 5.4 96.0 ± 2.4 
 87.5 ± 8.1 ↓⇑ 77.2 ± 6.1↑⇑ 79.6 ± 7.9  76.4 ± 13.3↑⇑ 84.0 ± 7.2 ↓⇑ 82.6 ± 6.8 ↓⇑ 52.5 ± 1.6↑⇑ 50.4 ± 0.6↑⇑ 79.6 ± 5.3 96.1 ± 2.1 
 87.5 ± 8.7 ↓⇑ 76.8 ± 6.1↑⇑ 83.8 ± 6.5↓⇑ 84.2 ± 5.1 ↓⇑ 85.5 ± 6.1 ↓⇑ 85.5 ± 5.7 ↓⇑ 52.7 ± 1.6↑⇑ 50.3 ± 0.4↑⇑ 81.7 ± 3.6 97.1 ± 1.2 
 87.8 ± 6.5 ↓⇑ 77.5 ± 6.4↑⇑ 83.2 ± 6.3  80.8 ± 12.0↑⇑ 87.0 ± 5.8 ↓⇑ 86.6 ± 4.8 ↓⇑ 53.5 ± 1.7↑⇑ 50.6 ± 0.5↑⇑ 82.9 ± 3.7 97.3 ± 0.9 
 87.5 ± 5.5 ↓⇑ 77.6 ± 6.3↑⇑ 83.4 ± 4.9  86.3 ± 5.5 ↓⇑ 89.5 ± 4.6 ↓⇑ 87.7 ± 4.4 ↓⇑ 54.4 ± 2.1↑⇑ 50.7 ± 0.5↑⇑ 84.4 ± 3.0 97.6 ± 0.6 
 88.4 ± 4.1 ↓⇑ 77.6 ± 6.9↑⇑ 83.1 ± 4.6↑⇑ 87.7 ± 4.6 ↓⇑ 89.9 ± 4.2 ↓⇑ 87.2 ± 3.5 ↓⇑ 54.8 ± 1.2↑⇑ 50.6 ± 0.5↑⇑ 85.5 ± 2.7 97.7 ± 0.6 
 88.3 ± 3.7 ↓⇑ 77.4 ± 6.5↑⇑ 84.1 ± 4.4↑⇑ 86.6 ± 4.4  90.6 ± 4.2 ↓⇑ 87.9 ± 4.4 ↓⇑ 55.1 ± 1.7↑⇑ 50.6 ± 0.5↑⇑ 86.4 ± 2.3 97.7 ± 0.5 
 10 87.5 ± 4.0  77.6 ± 6.1↑⇑ 84.7 ± 3.7↑⇑ 87.4 ± 4.7  90.8 ± 4.0 ↓⇑ 87.5 ± 5.0  55.0 ± 2.0↑⇑ 50.7 ± 0.6↑⇑ 87.1 ± 1.7 97.9 ± 0.4 

In order to check if the average performances of one-shot GP and compound-GP are statistically significant compared to the performance of each of the baseline methods, a Wilcoxon signed-ranks test (Wilcoxon, 1945; Demšar, 2006) was used. The methods were compared in pairs, and the significance level of the test was set to 5%. The and symbols indicate that the performance of the one-shot GP method compared to that of the other method is significantly worse or better, respectively. The and symbols indicate that the performance of the compound-GP method compared to that of the other method is significantly worse or better, respectively. The result for the method with the highest performance among all other comparative methods appears in boldface type. However, in case more than one method achieved 100% accuracy, no results for those methods are boldfaced.

5.1.1  Group A Data Sets

The results of the data sets of group A are presented in Table 2; the data sets are Textures-1, Textures-2, Textures-3, and Textures-4.

The first block of Table 2 shows the results of the methods on the Textures-1 data set. Compound-GP scored the second best performance on this data set after the AdaBoostM1 method. The one-shot GP method also showed good performance and scored third when the number of instances was less than six.

The results of the Textures-2 data set are presented in the second block of Table 2. This data set represents one of the easiest; most of the methods, apart from conventional-GP and two-tier GP, scored above 99% when there were four or more instances of each class in the training set. However, the use of only one instance was enough to achieve 100% accuracy by the compound-GP method, and 99.9% accuracy using two instances in the case of one-shot GP.

For Textures-3, all the methods, apart from two-tier GP, achieved reasonably good accuracy above 80% when there were three or more instances of each class in the training set as shown in the third block of Table 2. Moreover, the compound-GP method scored either the highest or in the top three ranked performances among other methods. Although the one-shot GP showed the second lowest performance among the comparative methods on this data set, this method achieved on average 79.3% accuracy using only two instances per class.

The results on Textures-4 data set are presented in the last block of Table 2. Apart from KStar, conventional-GP, and two-tier GP, all other methods achieved on average over 80% accuracy. Moreover, the compound-GP method significantly outperformed all other methods on this data set. The compound-GP method achieved 95.1% accuracy using only one instance per class, which is significantly better than the highest achieved results by other methods even when there were 10 instances per class in the training set (NNge = 90.8%).

5.1.2  Group B Data Set

The results of the Textures-5 data set are presented in Table 3. This data set represents a more challenging task compared to all other texture-based data sets because of the variation in illumination, scale, and pose of its instances. The results show that one-shot GP and compound-GP significantly outperformed all other methods on this data set. Moreover, these two methods achieved on average over 90% accuracy even when there were two instances in the training set. This shows that the programs evolved by the two new methods are invariant (to some extent) to those variations.

Table 3:
Results of the group B data set.
Non-GP MethodsGP-based Methods
SizeABoostM1KStarNBNBTreeNNgeSVMConven.Two-TierOne-ShotCompound
Textures-5 70.3 ± 24.6  66.2 ± 10.7  67.9 ± 11.8  63.7 ± 12.5  64.9 ± 20.1  64.9 ± 20.1  58.5 ± 5.0  49.8 ± 1.0  N/A 91.4 ± 14.3 
 73.4 ± 17.3↑⇑ 71.5 ± 12.4↑⇑ 71.5 ± 13.5↑⇑ 69.8 ± 14.6↑⇑ 73.4 ± 14.8↑⇑ 69.0 ± 16.1↑⇑ 55.9 ± 6.8↑⇑ 51.1 ± 1.6↑⇑ 91.3 ± 8.8 91.6 ± 13.1 
 73.5 ± 15.1↑⇑ 72.0 ± 14.2↑⇑ 81.5 ± 10.3↑⇑ 62.8 ± 15.7↑⇑ 77.0 ± 13.1↑⇑ 69.1 ± 18.1↑⇑ 54.5 ± 6.4↑⇑ 51.9 ± 1.7↑⇑ 91.4 ± 8.2 91.2 ± 12.2 
 74.9 ± 15.4↑⇑ 72.3 ± 14.3↑⇑ 83.9 ± 9.2 ↑⇑ 62.0 ± 16.0↑⇑ 76.0 ± 13.2↑⇑ 69.7 ± 17.8↑⇑ 54.9 ± 6.8↑⇑ 52.2 ± 1.6↑⇑ 91.3 ± 7.6 90.7 ± 11.7 
 76.7 ± 16.2↑⇑ 72.4 ± 14.0↑⇑ 85.1 ± 7.8 ↑⇑ 69.2 ± 17.2↑⇑ 76.2 ± 12.5↑⇑ 70.6 ± 17.4↑⇑ 55.3 ± 6.6↑⇑ 52.0 ± 2.2↑⇑ 91.4 ± 7.1 91.8 ± 10.6 
 76.8 ± 15.4↑⇑ 72.8 ± 13.1↑⇑ 85.2 ± 8.2 ↑⇑ 69.2 ± 17.9↑⇑ 77.6 ± 13.2↑⇑ 71.5 ± 17.7↑⇑ 54.8 ± 6.2↑⇑ 52.5 ± 2.5↑⇑ 92.3 ± 6.7 91.9 ± 10.6 
 76.6 ± 15.4↑⇑ 74.3 ± 13.1↑⇑ 87.0 ± 6.5 ↑⇑ 73.7 ± 17.0↑⇑ 82.9 ± 7.9 ↑⇑ 73.7 ± 16.9↑⇑ 54.0 ± 6.8↑⇑ 53.1 ± 2.2↑⇑ 92.7 ± 6.2 92.5 ± 9.9 
 77.2 ± 16.0↑⇑ 75.4 ± 12.1↑⇑ 87.2 ± 6.2 ↑⇑ 76.0 ± 16.7↑⇑ 84.3 ± 8.0 ↑⇑ 74.6 ± 17.2↑⇑ 52.9 ± 6.8↑⇑ 53.2 ± 2.1↑⇑ 93.2 ± 6.3 93.1 ± 9.2 
 77.7 ± 16.3↑⇑ 77.3 ± 11.6↑⇑ 87.9 ± 4.3 ↑⇑ 75.4 ± 17.3↑⇑ 85.2 ± 7.9 ↑⇑ 75.9 ± 16.3↑⇑ 53.0 ± 6.8↑⇑ 53.2 ± 2.1↑⇑ 93.6 ± 5.3 93.5 ± 8.5 
 10 77.7 ± 15.3↑⇑ 77.6 ± 11.2↑⇑ 88.5 ± 4.5 ↑⇑ 78.2 ± 15.2↑⇑ 85.4 ± 8.0 ↑⇑ 77.6 ± 14.9↑⇑ 52.0 ± 6.7↑⇑ 53.3 ± 2.3↑⇑ 94.0 ± 4.7 94.1 ± 7.9 
Non-GP MethodsGP-based Methods
SizeABoostM1KStarNBNBTreeNNgeSVMConven.Two-TierOne-ShotCompound
Textures-5 70.3 ± 24.6  66.2 ± 10.7  67.9 ± 11.8  63.7 ± 12.5  64.9 ± 20.1  64.9 ± 20.1  58.5 ± 5.0  49.8 ± 1.0  N/A 91.4 ± 14.3 
 73.4 ± 17.3↑⇑ 71.5 ± 12.4↑⇑ 71.5 ± 13.5↑⇑ 69.8 ± 14.6↑⇑ 73.4 ± 14.8↑⇑ 69.0 ± 16.1↑⇑ 55.9 ± 6.8↑⇑ 51.1 ± 1.6↑⇑ 91.3 ± 8.8 91.6 ± 13.1 
 73.5 ± 15.1↑⇑ 72.0 ± 14.2↑⇑ 81.5 ± 10.3↑⇑ 62.8 ± 15.7↑⇑ 77.0 ± 13.1↑⇑ 69.1 ± 18.1↑⇑ 54.5 ± 6.4↑⇑ 51.9 ± 1.7↑⇑ 91.4 ± 8.2 91.2 ± 12.2 
 74.9 ± 15.4↑⇑ 72.3 ± 14.3↑⇑ 83.9 ± 9.2 ↑⇑ 62.0 ± 16.0↑⇑ 76.0 ± 13.2↑⇑ 69.7 ± 17.8↑⇑ 54.9 ± 6.8↑⇑ 52.2 ± 1.6↑⇑ 91.3 ± 7.6 90.7 ± 11.7 
 76.7 ± 16.2↑⇑ 72.4 ± 14.0↑⇑ 85.1 ± 7.8 ↑⇑ 69.2 ± 17.2↑⇑ 76.2 ± 12.5↑⇑ 70.6 ± 17.4↑⇑ 55.3 ± 6.6↑⇑ 52.0 ± 2.2↑⇑ 91.4 ± 7.1 91.8 ± 10.6 
 76.8 ± 15.4↑⇑ 72.8 ± 13.1↑⇑ 85.2 ± 8.2 ↑⇑ 69.2 ± 17.9↑⇑ 77.6 ± 13.2↑⇑ 71.5 ± 17.7↑⇑ 54.8 ± 6.2↑⇑ 52.5 ± 2.5↑⇑ 92.3 ± 6.7 91.9 ± 10.6 
 76.6 ± 15.4↑⇑ 74.3 ± 13.1↑⇑ 87.0 ± 6.5 ↑⇑ 73.7 ± 17.0↑⇑ 82.9 ± 7.9 ↑⇑ 73.7 ± 16.9↑⇑ 54.0 ± 6.8↑⇑ 53.1 ± 2.2↑⇑ 92.7 ± 6.2 92.5 ± 9.9 
 77.2 ± 16.0↑⇑ 75.4 ± 12.1↑⇑ 87.2 ± 6.2 ↑⇑ 76.0 ± 16.7↑⇑ 84.3 ± 8.0 ↑⇑ 74.6 ± 17.2↑⇑ 52.9 ± 6.8↑⇑ 53.2 ± 2.1↑⇑ 93.2 ± 6.3 93.1 ± 9.2 
 77.7 ± 16.3↑⇑ 77.3 ± 11.6↑⇑ 87.9 ± 4.3 ↑⇑ 75.4 ± 17.3↑⇑ 85.2 ± 7.9 ↑⇑ 75.9 ± 16.3↑⇑ 53.0 ± 6.8↑⇑ 53.2 ± 2.1↑⇑ 93.6 ± 5.3 93.5 ± 8.5 
 10 77.7 ± 15.3↑⇑ 77.6 ± 11.2↑⇑ 88.5 ± 4.5 ↑⇑ 78.2 ± 15.2↑⇑ 85.4 ± 8.0 ↑⇑ 77.6 ± 14.9↑⇑ 52.0 ± 6.7↑⇑ 53.3 ± 2.3↑⇑ 94.0 ± 4.7 94.1 ± 7.9 

5.1.3  Group C Data Sets

Table 4 presents the results on data sets of the third group, which consists of the Textures-6, Textures-7, Textures-8, and Textures-9 data sets.

Table 4:
Results of the group C data sets.
Non-GP MethodsGP-based Methods
SizeABoostM1KStarNBNBTreeNNgeSVMConven.Two-TierOne-ShotCompound
Textures-6 93.6 ± 5.4  61.9 ± 5.6  53.1 ± 5.0  61.5 ± 6.9  49.5 ± 4.0  49.5 ± 4.0  50.4 ± 0.8  50.2 ± 0.2  N/A 98.2 ± 1.0 
 94.2 ± 5.4  67.7 ± 7.9↑⇑ 65.2 ± 7.2↑⇑ 63.4 ± 6.4 ↑⇑ 55.4 ± 4.3↑⇑ 55.1 ± 4.3↑⇑ 50.7 ± 0.8↑⇑ 50.3 ± 0.3↑⇑ 93.7 ± 1.0 98.7 ± 0.2 
 94.7 ± 5.3↓⇑ 70.5 ± 4.8↑⇑ 63.4 ± 7.6↑⇑ 62.4 ± 7.2 ↑⇑ 57.9 ± 3.7↑⇑ 59.2 ± 5.2↑⇑ 50.9 ± 0.8↑⇑ 50.4 ± 0.2↑⇑ 93.3 ± 0.7 98.8 ± 0.2 
 95.2 ± 5.2↓⇑ 72.4 ± 7.5↑⇑ 62.2 ± 7.9↑⇑ 65.0 ± 11.2↑⇑ 59.1 ± 3.6↑⇑ 60.2 ± 5.8↑⇑ 51.5 ± 0.9↑⇑ 50.5 ± 0.3↑⇑ 93.5 ± 0.8 98.8 ± 0.2 
 95.7 ± 5.1↓⇑ 72.3 ± 6.0↑⇑ 59.3 ± 6.4↑⇑ 65.0 ± 11.1↑⇑ 61.7 ± 4.0↑⇑ 61.0 ± 5.8↑⇑ 51.5 ± 1.2↑⇑ 50.5 ± 0.4↑⇑ 94.4 ± 0.4 98.8 ± 0.2 
 96.3 ± 4.9↓⇑ 73.4 ± 7.7↑⇑ 56.8 ± 2.3↑⇑ 65.8 ± 13.7↑⇑ 64.7 ± 6.4↑⇑ 64.0 ± 7.3↑⇑ 51.5 ± 1.2↑⇑ 50.6 ± 0.4↑⇑ 95.0 ± 0.2 98.8 ± 0.1 
 96.8 ± 4.6↓⇑ 75.6 ± 7.1↑⇑ 58.1 ± 2.7↑⇑ 67.0 ± 14.3↑⇑ 67.0 ± 6.5↑⇑ 64.3 ± 6.8↑⇑ 51.4 ± 1.5↑⇑ 50.7 ± 0.3↑⇑ 95.3 ± 0.3 98.8 ± 0.1 
 97.3 ± 4.3↓⇑ 78.7 ± 8.9↑⇑ 58.5 ± 3.1↑⇑ 67.5 ± 14.6↑⇑ 69.5 ± 8.9↑⇑ 66.0 ± 8.2↑⇑ 51.5 ± 1.8↑⇑ 50.6 ± 0.4↑⇑ 95.5 ± 0.2 98.8 ± 0.1 
 97.8 ± 3.8↓⇑ 79.0 ± 9.1↑⇑ 58.9 ± 3.2↑⇑ 63.7 ± 16.8↑⇑ 70.7 ± 10.0↑⇑ 66.0 ± 7.6↑⇑ 51.5 ± 1.8↑⇑ 50.8 ± 0.4↑⇑ 95.8 ± 0.3 98.8 ± 0.1 
 10 98.3 ± 3.2↓⇑ 81.3 ± 7.4↑⇑ 60.2 ± 3.7↑⇑ 65.6 ± 18.8↑⇑ 70.6 ± 9.0↑⇑ 66.4 ± 7.1↑⇑ 51.5 ± 1.9↑⇑ 51.0 ± 0.3↑⇑ 96.0 ± 0.3 98.8 ± 0.1 
Textures-7 49.6 ± 0.8  97.6 ± 2.4  73.3 ± 7.5  97.8 ± 4.0  66.5 ± 9.4  66.5 ± 9.4  56.8 ± 2.2  51.1 ± 0.4  N/A 100.0 ± 0.0 
 67.6 ± 24.4↑⇑ 99.2 ± 0.7↑⇑ 99.1 ± 2.4↑⇑ 99.9 ± 0.3↑⇑ 97.6 ± 3.4↑⇑ 93.2 ± 9.3↑⇑ 66.7 ± 6.5↑⇑ 51.4 ± 0.4↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 77.8 ± 25.2↑⇑ 99.9 ± 0.2↑⇑ 99.5 ± 0.9↑⇑ 100.0 ± 0.0 100.0 ± 0.1  99.9 ± 0.3↑⇑ 76.1 ± 4.3↑⇑ 52.1 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 80.3 ± 24.8↑⇑ 100.0 ± 0.0↓⇑ 99.8 ± 0.3↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0↓⇑ 79.6 ± 2.0↑⇑ 52.5 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 82.7 ± 24.2↑⇑ 100.0 ± 0.0 99.9 ± 0.2↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 82.0 ± 2.0↑⇑ 53.1 ± 0.8↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 85.2 ± 23.2↑⇑ 100.0 ± 0.0 99.1 ± 4.1↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 82.7 ± 2.3↑⇑ 53.2 ± 0.8↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 87.7 ± 21.9↑⇑ 100.0 ± 0.0 99.8 ± 0.6↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 83.8 ± 2.6↑⇑ 53.6 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 90.1 ± 20.3↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 85.1 ± 2.4↑⇑ 54.1 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 92.6 ± 18.1↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0↑⇑ 100.0 ± 0.0 100.0 ± 0.0 86.3 ± 2.3↑⇑ 54.4 ± 0.6↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 10 95.1 ± 15.2↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0↑⇑ 100.0 ± 0.0 100.0 ± 0.0 86.7 ± 2.6↑⇑ 54.8 ± 0.8↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
Textures-8 57.7 ± 30.3  89.0 ± 4.7 67.5 ± 8.8  87.2 ± 6.2  69.6 ± 12.5  69.6 ± 12.5  70.0 ± 2.1  50.9 ± 0.5  N/A 80.7 ± 8.1 
 77.1 ± 26.4 90.0 ± 3.7↓⇓ 91.0 ± 5.2↓⇓ 90.8 ± 4.6↓⇓ 78.2 ± 9.9 ↓⇑ 79.9 ± 11.7↓⇑ 78.5 ± 2.8↓⇑ 52.2 ± 0.7↑⇑ 74.4 ± 4.7 84.4 ± 5.4 
 93.6 ± 1.4↓⇓ 92.2 ± 3.4↓⇓ 93.0 ± 2.5↓⇓ 92.5 ± 1.6↓⇓ 85.7 ± 6.7  85.4 ± 11.0 84.9 ± 2.5 53.4 ± 0.6↑⇑ 75.4 ± 2.9 86.5 ± 4.6 
 93.7 ± 1.4↓⇓ 92.7 ± 3.3↓⇓ 93.3 ± 0.9↓⇓ 93.5 ± 1.4↓⇓ 89.3 ± 6.4 ↓⇓ 88.0 ± 10.0  87.4 ± 1.3 54.1 ± 0.8↑⇑ 75.9 ± 2.7 86.3 ± 4.3 
 93.8 ± 1.3↓⇓ 93.0 ± 2.9↓⇓ 92.4 ± 2.4↓⇓ 93.7 ± 1.5↓⇓ 91.1 ± 5.8 ↓⇓ 89.7 ± 8.6 ↓⇓ 88.7 ± 1.4↓⇓ 55.0 ± 1.1↑⇑ 77.2 ± 2.7 86.8 ± 2.4 
 93.8 ± 1.3 ↓⇓ 93.6 ± 2.6↓⇓ 91.1 ± 3.5↓⇓ 94.0 ± 1.3↓⇓ 93.1 ± 4.9 ↓⇓ 91.4 ± 7.4 ↓⇓ 89.0 ± 1.4↓⇓ 55.9 ± 1.1↑⇑ 79.0 ± 2.3 87.8 ± 1.8 
 93.9 ± 1.2 ↓⇓ 93.7 ± 2.5↓⇓ 93.0 ± 1.7↓⇓ 94.1 ± 1.0↓⇓ 94.3 ± 3.9↓⇓ 92.8 ± 6.4 ↓⇓ 89.7 ± 1.1↓⇓ 56.7 ± 1.1↑⇑ 80.2 ± 2.6 87.1 ± 1.8 
 93.9 ± 1.2 ↓⇓ 93.9 ± 2.3↓⇓ 92.6 ± 1.7↓⇓ 94.0 ± 1.2↓⇓ 94.9 ± 3.7↓⇓ 94.2 ± 5.1 ↓⇓ 90.0 ± 1.0↓⇓ 57.3 ± 0.9↑⇑ 80.8 ± 2.3 87.4 ± 1.5 
 93.9 ± 1.1 ↓⇓ 94.1 ± 2.0↓⇓ 89.1 ± 4.0↓⇓ 94.3 ± 1.0↓⇓ 95.4 ± 3.4 ↓⇓ 95.4 ± 3.8↓⇓ 90.6 ± 1.0↓⇓ 57.7 ± 1.1↑⇑ 81.8 ± 2.2 87.5 ± 1.2 
 10 94.0 ± 1.1 ↓⇓ 94.1 ± 1.9↓⇓ 91.1 ± 2.3↓⇓ 94.4 ± 0.8↓⇓ 95.9 ± 3.0 ↓⇓ 96.0 ± 3.3↓⇓ 90.7 ± 0.9↓⇓ 58.2 ± 0.8↑⇑ 82.3 ± 1.9 87.5 ± 1.4 
Textures-9 48.5 ± 9.4  83.1 ± 5.7  76.1 ± 6.9  80.5 ± 6.1  70.6 ± 15.2  70.6 ± 15.2  50.4 ± 1.0  50.0 ± 0.3  N/A 90.5 ± 5.0 
 91.4 ± 14.0 83.8 ± 6.9↓⇑ 71.5 ± 8.6  86.1 ± 4.3↓⇑ 90.3 ± 3.2 ↓⇑ 90.1 ± 2.1 ↓⇑ 51.3 ± 1.1↑⇑ 50.1 ± 0.3↑⇑ 71.4 ± 6.4 92.0 ± 2.5 
 97.0 ± 0.8↓⇓ 89.7 ± 2.9↓⇑ 78.6 ± 10.1↓⇑ 85.1 ± 8.0↓⇑ 92.3 ± 3.3  92.1 ± 1.9  52.8 ± 2.1↑⇑ 50.4 ± 0.2↑⇑ 69.6 ± 5.5 92.4 ± 2.0 
 97.0 ± 0.8↓⇓ 91.3 ± 3.4↓⇑ 71.6 ± 8.5 ↓⇑ 89.7 ± 7.5↓⇑ 94.0 ± 3.2 ↓⇓ 92.9 ± 1.9  54.4 ± 2.7↑⇑ 50.5 ± 0.4↑⇑ 69.0 ± 4.6 92.3 ± 1.5 
 97.1 ± 0.9↓⇓ 92.2 ± 2.0↓⇑ 74.4 ± 11.1↓⇑ 91.1 ± 6.1↓⇑ 94.9 ± 2.3 ↓⇓ 93.5 ± 1.7  56.3 ± 3.5↑⇑ 50.5 ± 0.4↑⇑ 71.1 ± 3.9 93.0 ± 1.6 
 97.2 ± 0.9↓⇓ 93.2 ± 2.3 78.7 ± 9.7 ↓⇑ 93.4 ± 3.2 95.5 ± 1.5 ↓⇓ 94.1 ± 1.4 ↓⇓ 57.6 ± 3.8↑⇑ 50.7 ± 0.4↑⇑ 73.3 ± 2.9 93.1 ± 1.5 
 97.2 ± 1.0↓⇓ 93.0 ± 2.6 81.4 ± 9.7 ↓⇑ 92.9 ± 4.2 95.8 ± 1.4 ↓⇓ 94.6 ± 1.4 ↓⇓ 58.2 ± 3.1↑⇑ 50.7 ± 0.5↑⇑ 75.8 ± 2.8 93.3 ± 1.5 
 97.3 ± 1.0↓⇓ 93.1 ± 1.9 84.1 ± 9.5 ↓⇑ 93.3 ± 4.1 96.2 ± 1.1 ↓⇓ 94.7 ± 1.5 ↓⇓ 59.6 ± 3.3↑⇑ 50.7 ± 0.6↑⇑ 77.4 ± 2.7 93.6 ± 1.5 
 97.4 ± 1.0↓⇓ 93.2 ± 1.8 84.8 ± 11.9↓⇑ 93.8 ± 3.0 96.4 ± 0.9 ↓⇓ 95.2 ± 1.2 ↓⇓ 59.4 ± 3.3↑⇑ 50.8 ± 0.5↑⇑ 79.4 ± 2.8 93.5 ± 1.2 
 10 97.4 ± 1.0↓⇓ 93.2 ± 2.0 86.6 ± 9.8 ↓⇑ 94.4 ± 2.3↓⇓ 96.4 ± 0.9 ↓⇓ 95.6 ± 1.0 ↓⇓ 60.4 ± 3.3↓⇑ 50.9 ± 0.4↓⇑ 80.4 ± 2.8 93.6 ± 1.1 
Non-GP MethodsGP-based Methods
SizeABoostM1KStarNBNBTreeNNgeSVMConven.Two-TierOne-ShotCompound
Textures-6 93.6 ± 5.4  61.9 ± 5.6  53.1 ± 5.0  61.5 ± 6.9  49.5 ± 4.0  49.5 ± 4.0  50.4 ± 0.8  50.2 ± 0.2  N/A 98.2 ± 1.0 
 94.2 ± 5.4  67.7 ± 7.9↑⇑ 65.2 ± 7.2↑⇑ 63.4 ± 6.4 ↑⇑ 55.4 ± 4.3↑⇑ 55.1 ± 4.3↑⇑ 50.7 ± 0.8↑⇑ 50.3 ± 0.3↑⇑ 93.7 ± 1.0 98.7 ± 0.2 
 94.7 ± 5.3↓⇑ 70.5 ± 4.8↑⇑ 63.4 ± 7.6↑⇑ 62.4 ± 7.2 ↑⇑ 57.9 ± 3.7↑⇑ 59.2 ± 5.2↑⇑ 50.9 ± 0.8↑⇑ 50.4 ± 0.2↑⇑ 93.3 ± 0.7 98.8 ± 0.2 
 95.2 ± 5.2↓⇑ 72.4 ± 7.5↑⇑ 62.2 ± 7.9↑⇑ 65.0 ± 11.2↑⇑ 59.1 ± 3.6↑⇑ 60.2 ± 5.8↑⇑ 51.5 ± 0.9↑⇑ 50.5 ± 0.3↑⇑ 93.5 ± 0.8 98.8 ± 0.2 
 95.7 ± 5.1↓⇑ 72.3 ± 6.0↑⇑ 59.3 ± 6.4↑⇑ 65.0 ± 11.1↑⇑ 61.7 ± 4.0↑⇑ 61.0 ± 5.8↑⇑ 51.5 ± 1.2↑⇑ 50.5 ± 0.4↑⇑ 94.4 ± 0.4 98.8 ± 0.2 
 96.3 ± 4.9↓⇑ 73.4 ± 7.7↑⇑ 56.8 ± 2.3↑⇑ 65.8 ± 13.7↑⇑ 64.7 ± 6.4↑⇑ 64.0 ± 7.3↑⇑ 51.5 ± 1.2↑⇑ 50.6 ± 0.4↑⇑ 95.0 ± 0.2 98.8 ± 0.1 
 96.8 ± 4.6↓⇑ 75.6 ± 7.1↑⇑ 58.1 ± 2.7↑⇑ 67.0 ± 14.3↑⇑ 67.0 ± 6.5↑⇑ 64.3 ± 6.8↑⇑ 51.4 ± 1.5↑⇑ 50.7 ± 0.3↑⇑ 95.3 ± 0.3 98.8 ± 0.1 
 97.3 ± 4.3↓⇑ 78.7 ± 8.9↑⇑ 58.5 ± 3.1↑⇑ 67.5 ± 14.6↑⇑ 69.5 ± 8.9↑⇑ 66.0 ± 8.2↑⇑ 51.5 ± 1.8↑⇑ 50.6 ± 0.4↑⇑ 95.5 ± 0.2 98.8 ± 0.1 
 97.8 ± 3.8↓⇑ 79.0 ± 9.1↑⇑ 58.9 ± 3.2↑⇑ 63.7 ± 16.8↑⇑ 70.7 ± 10.0↑⇑ 66.0 ± 7.6↑⇑ 51.5 ± 1.8↑⇑ 50.8 ± 0.4↑⇑ 95.8 ± 0.3 98.8 ± 0.1 
 10 98.3 ± 3.2↓⇑ 81.3 ± 7.4↑⇑ 60.2 ± 3.7↑⇑ 65.6 ± 18.8↑⇑ 70.6 ± 9.0↑⇑ 66.4 ± 7.1↑⇑ 51.5 ± 1.9↑⇑ 51.0 ± 0.3↑⇑ 96.0 ± 0.3 98.8 ± 0.1 
Textures-7 49.6 ± 0.8  97.6 ± 2.4  73.3 ± 7.5  97.8 ± 4.0  66.5 ± 9.4  66.5 ± 9.4  56.8 ± 2.2  51.1 ± 0.4  N/A 100.0 ± 0.0 
 67.6 ± 24.4↑⇑ 99.2 ± 0.7↑⇑ 99.1 ± 2.4↑⇑ 99.9 ± 0.3↑⇑ 97.6 ± 3.4↑⇑ 93.2 ± 9.3↑⇑ 66.7 ± 6.5↑⇑ 51.4 ± 0.4↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 77.8 ± 25.2↑⇑ 99.9 ± 0.2↑⇑ 99.5 ± 0.9↑⇑ 100.0 ± 0.0 100.0 ± 0.1  99.9 ± 0.3↑⇑ 76.1 ± 4.3↑⇑ 52.1 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 80.3 ± 24.8↑⇑ 100.0 ± 0.0↓⇑ 99.8 ± 0.3↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0↓⇑ 79.6 ± 2.0↑⇑ 52.5 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 82.7 ± 24.2↑⇑ 100.0 ± 0.0 99.9 ± 0.2↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 82.0 ± 2.0↑⇑ 53.1 ± 0.8↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 85.2 ± 23.2↑⇑ 100.0 ± 0.0 99.1 ± 4.1↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 82.7 ± 2.3↑⇑ 53.2 ± 0.8↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 87.7 ± 21.9↑⇑ 100.0 ± 0.0 99.8 ± 0.6↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 83.8 ± 2.6↑⇑ 53.6 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 90.1 ± 20.3↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0 85.1 ± 2.4↑⇑ 54.1 ± 0.7↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 92.6 ± 18.1↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0↑⇑ 100.0 ± 0.0 100.0 ± 0.0 86.3 ± 2.3↑⇑ 54.4 ± 0.6↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
 10 95.1 ± 15.2↑⇑ 100.0 ± 0.0 100.0 ± 0.0 100.0 ± 0.0↑⇑ 100.0 ± 0.0 100.0 ± 0.0 86.7 ± 2.6↑⇑ 54.8 ± 0.8↑⇑ 100.0 ± 0.0 100.0 ± 0.0 
Textures-8 57.7 ± 30.3  89.0 ± 4.7 67.5 ± 8.8  87.2 ± 6.2  69.6 ± 12.5  69.6 ± 12.5  70.0 ± 2.1  50.9 ± 0.5  N/A 80.7 ± 8.1 
 77.1 ± 26.4 90.0 ± 3.7↓⇓ 91.0 ± 5.2↓⇓ 90.8 ± 4.6↓⇓ 78.2 ± 9.9 ↓⇑ 79.9 ± 11.7↓⇑ 78.5 ± 2.8↓⇑ 52.2 ± 0.7↑⇑ 74.4 ± 4.7 84.4 ± 5.4 
 93.6 ± 1.4↓⇓ 92.2 ± 3.4↓⇓ 93.0 ± 2.5↓⇓ 92.5 ± 1.6↓⇓ 85.7 ± 6.7  85.4 ± 11.0 84.9 ± 2.5 53.4 ± 0.6↑⇑ 75.4 ± 2.9 86.5 ± 4.6 
 93.7 ± 1.4↓⇓ 92.7 ± 3.3↓⇓ 93.3 ± 0.9↓⇓ 93.5 ± 1.4↓⇓ 89.3 ± 6.4 ↓⇓ 88.0 ± 10.0  87.4 ± 1.3 54.1 ± 0.8↑⇑ 75.9 ± 2.7 86.3 ± 4.3 
 93.8 ± 1.3↓⇓ 93.0 ± 2.9↓⇓ 92.4 ± 2.4↓⇓ 93.7 ± 1.5↓⇓ 91.1 ± 5.8 ↓⇓ 89.7 ± 8.6 ↓⇓ 88.7 ± 1.4↓⇓ 55.0 ± 1.1↑⇑ 77.2 ± 2.7 86.8 ± 2.4 
 93.8 ± 1.3 ↓⇓ 93.6 ± 2.6↓⇓ 91.1 ± 3.5↓⇓ 94.0 ± 1.3↓⇓ 93.1 ± 4.9 ↓⇓ 91.4 ± 7.4 ↓⇓ 89.0 ± 1.4↓⇓ 55.9 ± 1.1↑⇑ 79.0 ± 2.3 87.8 ± 1.8 
 93.9 ± 1.2 ↓⇓ 93.7 ± 2.5↓⇓ 93.0 ± 1.7↓⇓ 94.1 ± 1.0↓⇓ 94.3 ± 3.9↓⇓ 92.8 ± 6.4 ↓⇓ 89.7 ± 1.1↓⇓ 56.7 ± 1.1↑⇑ 80.2 ± 2.6 87.1 ± 1.8 
 93.9 ± 1.2 ↓⇓ 93.9 ± 2.3↓⇓ 92.6 ± 1.7↓⇓ 94.0 ± 1.2↓⇓ 94.9 ± 3.7↓⇓ 94.2 ± 5.1 ↓⇓ 90.0 ± 1.0↓⇓ 57.3 ± 0.9↑⇑ 80.8 ± 2.3 87.4 ± 1.5 
 93.9 ± 1.1 ↓⇓ 94.1 ± 2.0↓⇓ 89.1 ± 4.0↓⇓ 94.3 ± 1.0↓⇓ 95.4 ± 3.4 ↓⇓ 95.4 ± 3.8↓⇓ 90.6 ± 1.0↓⇓ 57.7 ± 1.1↑⇑ 81.8 ± 2.2 87.5 ± 1.2 
 10 94.0 ± 1.1 ↓⇓ 94.1 ± 1.9↓⇓ 91.1 ± 2.3↓⇓ 94.4 ± 0.8↓⇓ 95.9 ± 3.0 ↓⇓ 96.0 ± 3.3↓⇓ 90.7 ± 0.9↓⇓ 58.2 ± 0.8↑⇑ 82.3 ± 1.9 87.5 ± 1.4 
Textures-9 48.5 ± 9.4  83.1 ± 5.7  76.1 ± 6.9  80.5 ± 6.1  70.6 ± 15.2  70.6 ± 15.2  50.4 ± 1.0  50.0 ± 0.3  N/A 90.5 ± 5.0 
 91.4 ± 14.0 83.8 ± 6.9↓⇑ 71.5 ± 8.6  86.1 ± 4.3↓⇑ 90.3 ± 3.2 ↓⇑ 90.1 ± 2.1 ↓⇑ 51.3 ± 1.1↑⇑ 50.1 ± 0.3↑⇑ 71.4 ± 6.4 92.0 ± 2.5 
 97.0 ± 0.8↓⇓ 89.7 ± 2.9↓⇑ 78.6 ± 10.1↓⇑ 85.1 ± 8.0↓⇑ 92.3 ± 3.3  92.1 ± 1.9  52.8 ± 2.1↑⇑ 50.4 ± 0.2↑⇑ 69.6 ± 5.5 92.4 ± 2.0 
 97.0 ± 0.8↓⇓ 91.3 ± 3.4↓⇑ 71.6 ± 8.5 ↓⇑ 89.7 ± 7.5↓⇑ 94.0 ± 3.2 ↓⇓ 92.9 ± 1.9  54.4 ± 2.7↑⇑ 50.5 ± 0.4↑⇑ 69.0 ± 4.6 92.3 ± 1.5 
 97.1 ± 0.9↓⇓ 92.2 ± 2.0↓⇑ 74.4 ± 11.1↓⇑ 91.1 ± 6.1↓⇑ 94.9 ± 2.3 ↓⇓ 93.5 ± 1.7  56.3 ± 3.5↑⇑ 50.5 ± 0.4↑⇑ 71.1 ± 3.9 93.0 ± 1.6 
 97.2 ± 0.9↓⇓ 93.2 ± 2.3 78.7 ± 9.7 ↓⇑ 93.4 ± 3.2 95.5 ± 1.5 ↓⇓ 94.1 ± 1.4 ↓⇓ 57.6 ± 3.8↑⇑ 50.7 ± 0.4↑⇑ 73.3 ± 2.9 93.1 ± 1.5 
 97.2 ± 1.0↓⇓ 93.0 ± 2.6 81.4 ± 9.7 ↓⇑ 92.9 ± 4.2 95.8 ± 1.4 ↓⇓ 94.6 ± 1.4 ↓⇓ 58.2 ± 3.1↑⇑ 50.7 ± 0.5↑⇑ 75.8 ± 2.8 93.3 ± 1.5 
 97.3 ± 1.0↓⇓ 93.1 ± 1.9 84.1 ± 9.5 ↓⇑ 93.3 ± 4.1 96.2 ± 1.1 ↓⇓ 94.7 ± 1.5 ↓⇓ 59.6 ± 3.3↑⇑ 50.7 ± 0.6↑⇑ 77.4 ± 2.7 93.6 ± 1.5 
 97.4 ± 1.0↓⇓ 93.2 ± 1.8 84.8 ± 11.9↓⇑ 93.8 ± 3.0 96.4 ± 0.9 ↓⇓ 95.2 ± 1.2 ↓⇓ 59.4 ± 3.3↑⇑ 50.8 ± 0.5↑⇑ 79.4 ± 2.8 93.5 ± 1.2 
 10 97.4 ± 1.0↓⇓ 93.2 ± 2.0 86.6 ± 9.8 ↓⇑ 94.4 ± 2.3↓⇓ 96.4 ± 0.9 ↓⇓ 95.6 ± 1.0 ↓⇓ 60.4 ± 3.3↓⇑ 50.9 ± 0.4↓⇑ 80.4 ± 2.8 93.6 ± 1.1 

The results of the Textures-6 data set (which represents the rotated version of Textures-1) show that compound-GP and one-shot GP respectively scored the first and third best performances, as shown in the first block of Table 4. The two new methods significantly outperformed all other methods, apart from AdaBoostM1, compared to one-shot GP on this data set. Moreover, apart from KStar, all comparative methods showed a significant drop in performance compared to Textures-1, while the two new methods showed nearly consistent performance on the two data sets.

Apart from AdaBoostM1, most of the methods achieved similar accuracy on Textures-7 to Textures-2, as presented in the second block of Table 4. The one-shot GP and compound-GP methods achieved 100% accuracy even when the number of available instances was relatively small (less than three instances per class).

Similarly, the comparative methods showed nearly consistent or slightly lower performance on the rotated version Textures-8 of the Textures-3 data set, as presented in the third block of Table 4.

The last block of Table 4 shows the results of Textures-9, which represents the rotated version of the Textures-4 data set. While compound-GP maintained its performance, the performance of one-shot GP greatly dropped compared to Textures-4. Similar to compound-GP, other methods also showed a nearly consistent performance on this data set. Noticeably, the AdaBoostM1 method showed a considerably better performance on this data set compared to the performance of this method on Textures-4.

5.1.4  Group D Data Set

Table 5 shows the results of the experiment on the faces data set. Both one-shot GP and compound-GP achieved better accuracy than all other methods on this data set when the number of instances was smaller than four per class. Meanwhile, two-tier GP and NB started to compete when the number of training instances increased. Apart from NB, the compound-GP method significantly outperformed all other methods on this data set. The one-shot GP method, on the other hand, significantly outperformed NBTree, SVM, and conventional-GP in all the nine different sizes, and in some cases, compared to AdaBoostM1, KStar, NNge, and the two-tier GP methods.

Table 5:
Results of the group D data set.
Non-GP MethodsGP-based Methods
SizeABoostM1KStarNBNBTreeNNgeSVMConven.Two-TierOne-ShotCompound
Faces 56.1 ± 8.2  61.2 ± 9.0  57.3 ± 7.6  61.7 ± 9.3  57.6 ± 9.0  57.7 ± 9.2  55.2 ± 2.7  55.9 ± 1.9  N/A 67.8 ± 10.0 
 55.4 ± 10.0↑⇑ 60.8 ± 9.2↑⇑ 64.9 ± 8.8 59.1 ± 11.6↑⇑ 61.4 ± 11.8↑⇑ 62.8 ± 12.3↑⇑ 57.6 ± 3.4↑⇑ 60.9 ± 2.9↑⇑ 67.6 ± 6.3 68.6 ± 9.7 
 57.6 ± 9.6 ↑⇑ 63.6 ± 9.0↑⇑ 67.4 ± 11.0  58.3 ± 11.4↑⇑ 64.2 ± 12.9↑⇑ 64.9 ± 12.3↑⇑ 58.6 ± 3.3↑⇑ 63.2 ± 2.7↑⇑ 68.1 ± 4.6 70.4 ± 5.2 
 63.3 ± 10.8↑⇑ 65.3 ± 8.5↑⇑ 71.3 ± 10.2 57.6 ± 10.7↑⇑ 64.8 ± 13.1↑⇑ 63.4 ± 16.0↑⇑ 59.6 ± 3.4↑⇑ 65.1 ± 2.6↑⇑ 68.1 ± 4.9 70.6 ± 5.4 
 64.5 ± 11.4↑⇑ 67.0 ± 8.2  73.2 ± 10.2 65.0 ± 10.8↑⇑ 66.2 ± 12.3↑⇑ 63.9 ± 12.1↑⇑ 60.7 ± 4.7↑⇑ 66.7 ± 2.5↑⇑ 68.6 ± 4.1 72.8 ± 2.5 
 66.9 ± 11.1↑⇑ 68.8 ± 7.6  73.6 ± 9.2 60.0 ± 11.2↑⇑ 68.2 ± 11.6  63.6 ± 11.5↑⇑ 61.5 ± 4.5↑⇑ 68.1 ± 2.0  69.3 ± 3.7 73.5 ± 2.3 
 66.3 ± 11.2↑⇑ 69.6 ± 7.5  75.4 ± 7.6 63.8 ± 9.2 ↑⇑ 69.0 ± 12.3  61.8 ± 12.5↑⇑ 61.7 ± 4.8↑⇑ 69.2 ± 1.3  69.4 ± 3.7 74.9 ± 2.6 
 68.6 ± 10.8  70.1 ± 7.3  76.9 ± 6.9↓⇓ 66.1 ± 9.3 ↑⇑ 70.4 ± 11.2  62.6 ± 12.8↑⇑ 61.9 ± 4.6↑⇑ 70.2 ± 1.7  70.0 ± 3.1 75.4 ± 2.1 
 69.8 ± 8.7  70.3 ± 7.1  77.2 ± 6.7↓⇓ 61.4 ± 8.9 ↑⇑ 71.8 ± 9.9 ↓⇑ 62.3 ± 10.8↑⇑ 62.0 ± 4.2↑⇑ 71.1 ± 1.6  70.4 ± 2.5 76.0 ± 1.7 
 10 72.2 ± 7.7 ↓⇑ 70.3 ± 6.9  77.5 ± 6.9↓⇓ 66.0 ± 9.5 ↑⇑ 73.2 ± 9.3 ↓⇑ 62.7 ± 9.7 ↑⇑ 62.6 ± 3.6↑⇑ 71.1 ± 1.7  70.8 ± 2.4 76.6 ± 1.3 
Non-GP MethodsGP-based Methods
SizeABoostM1KStarNBNBTreeNNgeSVMConven.Two-TierOne-ShotCompound
Faces 56.1 ± 8.2  61.2 ± 9.0  57.3 ± 7.6  61.7 ± 9.3  57.6 ± 9.0  57.7 ± 9.2  55.2 ± 2.7  55.9 ± 1.9  N/A 67.8 ± 10.0 
 55.4 ± 10.0↑⇑ 60.8 ± 9.2↑⇑ 64.9 ± 8.8 59.1 ± 11.6↑⇑ 61.4 ± 11.8↑⇑ 62.8 ± 12.3↑⇑ 57.6 ± 3.4↑⇑ 60.9 ± 2.9↑⇑ 67.6 ± 6.3 68.6 ± 9.7 
 57.6 ± 9.6 ↑⇑ 63.6 ± 9.0↑⇑ 67.4 ± 11.0  58.3 ± 11.4↑⇑ 64.2 ± 12.9↑⇑ 64.9 ± 12.3↑⇑ 58.6 ± 3.3↑⇑ 63.2 ± 2.7↑⇑ 68.1 ± 4.6 70.4 ± 5.2 
 63.3 ± 10.8↑⇑ 65.3 ± 8.5↑⇑ 71.3 ± 10.2 57.6 ± 10.7↑⇑ 64.8 ± 13.1↑⇑ 63.4 ± 16.0↑⇑ 59.6 ± 3.4↑⇑ 65.1 ± 2.6↑⇑ 68.1 ± 4.9 70.6 ± 5.4 
 64.5 ± 11.4↑⇑ 67.0 ± 8.2  73.2 ± 10.2 65.0 ± 10.8↑⇑ 66.2 ± 12.3↑⇑ 63.9 ± 12.1↑⇑ 60.7 ± 4.7↑⇑ 66.7 ± 2.5↑⇑ 68.6 ± 4.1 72.8 ± 2.5 
 66.9 ± 11.1↑⇑ 68.8 ± 7.6  73.6 ± 9.2 60.0 ± 11.2↑⇑ 68.2 ± 11.6  63.6 ± 11.5↑⇑ 61.5 ± 4.5↑⇑ 68.1 ± 2.0  69.3 ± 3.7 73.5 ± 2.3 
 66.3 ± 11.2↑⇑ 69.6 ± 7.5  75.4 ± 7.6 63.8 ± 9.2 ↑⇑ 69.0 ± 12.3  61.8 ± 12.5↑⇑ 61.7 ± 4.8↑⇑ 69.2 ± 1.3  69.4 ± 3.7 74.9 ± 2.6 
 68.6 ± 10.8  70.1 ± 7.3  76.9 ± 6.9↓⇓ 66.1 ± 9.3 ↑⇑ 70.4 ± 11.2  62.6 ± 12.8↑⇑ 61.9 ± 4.6↑⇑ 70.2 ± 1.7  70.0 ± 3.1 75.4 ± 2.1 
 69.8 ± 8.7  70.3 ± 7.1  77.2 ± 6.7↓⇓ 61.4 ± 8.9 ↑⇑ 71.8 ± 9.9 ↓⇑ 62.3 ± 10.8↑⇑ 62.0 ± 4.2↑⇑ 71.1 ± 1.6  70.4 ± 2.5 76.0 ± 1.7 
 10 72.2 ± 7.7 ↓⇑ 70.3 ± 6.9  77.5 ± 6.9↓⇓ 66.0 ± 9.5 ↑⇑ 73.2 ± 9.3 ↓⇑ 62.7 ± 9.7 ↑⇑ 62.6 ± 3.6↑⇑ 71.1 ± 1.7  70.8 ± 2.4 76.6 ± 1.3 

5.1.5  Summary

The results show that both one-shot GP and compound-GP successfully evolved programs using only a few instances that can generalise well to unseen data. Compared to non-GP and GP-based methods, one-shot GP and compound-GP achieved significantly better or comparable results in most cases. However, in some situations the two new methods, especially one-shot GP, showed significantly worse performance, for instance, on the Textures-1 data set compared to the performance of AdaBoostM1.

5.2  Feature Extraction

As highlighted in Section 4, the goodness of the features detected and extracted by the one-shot GP and compound-GP methods was investigated via feeding those features to six different classifiers (the non-GP methods that were used in the first experiment). The performance of those classifiers on the handcrafted features and those extracted by the two-tier GP method was compared to the use of one-shot GP and compound-GP extracted features.

The results of each of the six classifiers on each of the data sets using four different sets of features are represented by a single line chart. Moreover, the results of all six classifiers are aligned on a single row for each data set. The y-axis and x-axis of each chart represent the average accuracy and number of instances per class in the training set, respectively. Because of space limitations, only the results of the data set of group B are presented in this section; the rest are presented in Figure 20 in the Appendix.

On the Textures-5 data set, the features extracted by the one-shot GP and compound-GP methods significantly improved the performance of all six classifiers over both handcrafted and two-tier GP features (see Figure 13). As mentioned in Section 4, this data set was more challenging than other texture-based data sets because of illumination, scale, and pose variations of its instances.

Figure 13:

Average performance of the experimental methods on the Textures-5 data set using four different sets of features.

Figure 13:

Average performance of the experimental methods on the Textures-5 data set using four different sets of features.

5.3  Training and Testing Times

We also measured the average training and testing times in order to highlight the cost of evolving a program by the one-shot GP and compound-GP methods. The results are presented in blocks of line charts, each of which shows the average time required to evolve or evaluate a program by each of the four GP methods. Each row of blocks represents either the training or the testing phase, while each column presents the results of a single data set (see Figure 14). Similar to the plots in the previous section, the x-axis represents the number of instances per class in the training set, and the y-axis represents the time in seconds. Only the results for the data sets of group A are presented here; the rest are presented in Figure 21 in the Appendix.

Figure 14:

Average training and testing time of the four GP-based methods on the Textures-1, Textures-2, Textures-3, and Textures-4 data sets.

Figure 14:

Average training and testing time of the four GP-based methods on the Textures-1, Textures-2, Textures-3, and Textures-4 data sets.

The results show that both the one-shot GP and compound-GP methods take significantly longer to evolve and evaluate/test a program than conventional-GP and two-tier GP. Moreover, conventional-GP is the fastest method among the four GP methods, followed by two-tier GP with a slightly slower speed. This large gap between the two new and the baseline methods was expected, for the following reasons:

  • Feature detection and extraction. Apart from conventional-GP, the other three GP-based methods perform feature detection and extraction at the lower part (near the leaves) of the evolved program. Performing those operations increases the complexity of the evolved program in terms of memory and computation costs. Moreover, in the case of two-tier GP, there are only four simple operations (minimum, maximum, mean, and standard deviation) that can be used to perform feature extraction. However, this operation is more complicated in the case of the one-shot GP and compound-GP methods. The complication results from the calculation of the LBP code of each pixel in each of the detected regions, which requires applying a threshold operation, checking if the calculated code is uniform, and accumulating it with other codes to form a histogram.

  • Wrapped classifiers. In the case of both conventional-GP and two-tier GP, the aim is to evolve a GP-based classifier. Thus, both of those methods do not have any wrapped classifier that needs to be trained. Meanwhile, the one-shot GP and compound-GP methods have a different number and type of wrapped classifiers. The one-shot GP method uses a simple kNN classifier, and compound-GP consists of two SVM and two kNN classifiers for each of the children of the special node (the root of the evolved program’s tree). Training and evaluating those wrapped classifiers introduced extra complexities that need to be handled.

  • Fitness function. The fitness function of conventional-GP and two-tier GP is simple and does not require extra calculations. However, the fitness function of one-shot GP and compound-GP is complex and requires calculating more parameters, such as the overlapping ratio of the detected regions ().

  • Termination criteria. In the case of one-shot GP and compound-GP, the system is forced to proceed until the maximum number of generations is reached. Meanwhile, conventional-GP and two-tier GP can terminate once an ideal program has been found.

5.4  Program Size

Here we investigate the complexity of the program evolved by each of the GP-based methods by average program size. The results are presented in line plots, where each row corresponds to one of the data sets, and each column represents the number of instances per class in the training set (see Figure 15). The y-axis and x-axis represent the number of nodes and generation, respectively. Each block contains four lines, one for each of the four GP methods. Only the results for the data sets of group B are presented here; the rest are presented in Figure 22 in the Appendix.

Figure 15:

Average program size per generation of the four GP-based methods on the Textures-5 data set.

Figure 15:

Average program size per generation of the four GP-based methods on the Textures-5 data set.

The results for conventional-GP and two-tier GP show that when there were fewer than four instances per class, these two methods terminated early and before the maximum number of generations was reached. This was expected, as both of those methods rely on the accuracy alone as a goodness measure. However, this does not occur in the case of one-shot GP and compound-GP because other components of the fitness measures of these two methods force the system to proceed.

The results show that one-shot GP has a constant program size that is not affected by the size of the training set or by generation (progress of the run). This was expected owing to the restriction of the program size of the one-shot GP method. The size is 35 nodes, which are one controller, two histogram, eight area nodes, and twenty-four terminal nodes.

The compound-GP method, on the other hand, evolves programs of different sizes, only restricted by the maximum depth of the tree parameter. The results show that on average the method started with a large program that got reduced in later stages (subsequent generations). The main reason for this behaviour is the overlapping ratio () component of the fitness function, which forces the system to detect distinctive regions with minimal overlapping.

6  Further Analyses

Two evolved programs by each of the one-shot GP and compound-GP methods are investigated in this section. The first example is taken from those programs that were evolved on one of the texture-based data sets, and the second example is a program that was evolved to discriminate between face and nonface instances.

6.1  One-Shot GP Examples

The first example of an evolved program by the one-shot GP method on the Textures-2 data set is presented in Figure 16. The tree representation of this program, shown in Figure 16a, is made up of one controller, two histogram, and eight area nodes. The position of each of those eight regions is highlighted in Figure 16b on one example of each class; the enlarged cut-outs are presented below each image. This program was evolved using the minimum allowed number of instances (two per class) by one-shot GP, and it achieved 100% accuracy on the unseen data of this data set. A closer look at the enlarged cut-outs reveals that the regions of the rice instance have less texture than those of the corresponding sesameseeds instance.

Figure 16:

An evolved program by the one-shot GP method on the Textures-2 data set. (a) Tree representation. (b) Detected regions.

Figure 16:

An evolved program by the one-shot GP method on the Textures-2 data set. (a) Tree representation. (b) Detected regions.

The example presented in Figure 17 shows an evolved program by the one-shot GP method on the faces data set. This program achieved 78.3% accuracy using only two instances of each class in the training set. The program detected the regions around both eyes, eyebrows, and cheeks. Those regions (especially around the eyes and cheeks) are similar to those designed by a domain expert, which shows the ability of the system to automatically detect such important regions.

Figure 17:

An evolved program by the one-shot GP method on the faces data set. (a) Tree representation. (b) Detected regions.

Figure 17:

An evolved program by the one-shot GP method on the faces data set. (a) Tree representation. (b) Detected regions.

6.2  Compound-GP Examples

The tree representation of an evolved program by the compound-GP method on the Textures-2 data set is shown in Figure 18a. This program was evolved using only one instance of each class and scored 100% accuracy on the unseen data of this data set. The regions detected by this program are shown in Figure 18b. The evolved program shows that regions of different sizes and shapes were detected, and the cut-outs of the two instances show clear differences in the texture, especially the small ones.

Figure 18:

An evolved program by the compound-GP method on the Textures-2 data set. (a) Tree representation. (b) Detected regions.

Figure 18:

An evolved program by the compound-GP method on the Textures-2 data set. (a) Tree representation. (b) Detected regions.

Figure 19 shows an evolved program by the compound-GP method on the faces data set. The program achieved 78.0% accuracy using only one instance per class. The tree representation shows that nine regions were detected by this program, as depicted in Figure 19a. These regions are highlighted in Figure 19b, which shows some interesting regions such as the mouth, three regions around the left eye and forehead, two regions detecting the left cheek, and three detecting the right cheek. This example shows that the detected regions have common features with those that were designed by a domain expert.

Figure 19:

An evolved program by the compound-GP method on the faces data set. (a) Tree representation. (b) Detected regions.

Figure 19:

An evolved program by the compound-GP method on the faces data set. (a) Tree representation. (b) Detected regions.

6.3  Comments on the Number of Examples

An important question applicable to both methods is why using a few instances can be sufficient to evolve a model with reasonably good performance. The answer can be the similarity between instances belonging to the same class. That is, instances belonging to one class must have distinctive features to those of other classes; otherwise, they must be grouped together. For example, the instances of each texture-based class have a special repetitive pattern or structure, and detecting this structure represents the main task of the texture synthesis field (Pietroni et al., 2010; Galerne et al., 2011). Similarly, all instances of the faces data set have similar features in relatively fixed positions (eyes, nose, cheeks, etc.). Therefore, allowing the system to detect distinctive regions from one or a few instances can be sufficient to generalise to unseen data. Thus, the assumption is that the same pattern or structure is shared by all instances of one class.

7  Conclusions and Future Work

This study investigated the one-shot GP and compound GP methods. The main aim of those two methods is to evolve a GP-based program for the task of binary classification in images using only one or a few instances per class. Moreover, neither of the two methods relies on the concept of learning by knowledge transfer, where some instances from related domains can be used to assist the process of evolving a model. Using 10 data sets of different flavours, and compared against two other GP and six non-GP methods, the results revealed that both of these new methods (one-shot GP and compound-GP) were able to evolve good programs capable of performing image classification. Furthermore, the evolved programs either outperformed all other competitor methods or achieved performance (i.e., accuracy) comparable to the best of those other methods in most of the studied cases.

Some of the data sets used in this study were aimed at testing the ability of the programs evolved by one-shot GP and compound-GP to handle illumination, rotation, and scale variations. Generally, the results showed that the programs evolved by those two methods maintained their performance or slightly dropped when one or more of those variations occurred. In other words, both new methods are capable of evolving (to some extent) illumination, rotation, and scale invariant programs.

The impact of the features detected and extracted by one-shot GP and compound-GP on the performance of classifiers such as AdaBoostM1, NB, NBTree, SVM, KStar, and NNeg was also investigated in this study. The results were compared against the use of handcrafted features and those were extracted by the two-tier GP method (Al-Sahaf et al., 2012a). The results showed that the features of one-shot GP and compound-GP have positive impact on the performance of most of the experimental classifiers in a large number of cases. However, in other cases, those features slightly degraded the performance of some classifiers.

In order to address the interpretability aspect, two examples each of the programs evolved by one-shot GP and compound-GP were discussed in detail. The discussions revealed that the evolved programs are easy to interpret and unlike other methods that build a black box model.

Despite the ability of the one-shot GP and compound-GP methods to evolve good programs using a small number of examples, a closer look at the complexity of the programs evolved by these two methods reveals their drawbacks. The methods (especially compound-GP) take considerably longer to evolve a good program than other GP-based methods, specifically conventional-GP and two-tier GP. Moreover, the size of the evolved program by compound-GP is larger than those evolved by conventional-GP, two-tier GP, and one-shot GP. The size of the program evolved by one-shot GP is fixed and introduces an extra parameter that needs to be set. Although the features extracted by one-shot GP and compound-GP are not biased to a specific classifier (as the results suggest), this may vary when the wrapped classifiers are replaced by other classifiers.

In the future we plan to investigate the possibility of extending both the one-shot GP and compound-GP methods to perform multiclass image classification using a limited number of instances of each class in the training set. Reducing the complexity of the evolved programs by use of these two methods represents another direction that is worth investigating. We also plan to study the impact of using different classifiers (i.e., wrapped) on the performance of the evolved programs and on the goodness of the extracted features by the one-shot GP and compound-GP methods.

References

Abdulhamid
,
F.
,
Neshatian
,
K.
, and
Zhang
,
M.
(
2011
).
Image recognition using genetic programming with loop structures
. In
Proceedings of the 26th International Conference on Image and Vision Computing New Zealand
, pp.
553
558
.
Ahonen
,
T.
,
Hadid
,
A.
, and
Pietikäinen
,
M.
(
2006
).
Face description with local binary patterns: Application to face recognition
.
IEEE Transactions on Pattern Analysis and Machine Intelligence
,
28
(
12
):
2037
2041
.
Al-Sahaf
,
H.
,
Song
,
A.
,
Neshatian
,
K.
, and
Zhang
,
M.
(
2012a
).
Extracting image features for classification by two-tier genetic programming
. In
Proceedings of the IEEE Congress on Evolutionary Computation
, pp.
1
8
.
Al-Sahaf
,
H.
,
Song
,
A.
,
Neshatian
,
K.
, and
Zhang
,
M.
(
2012b
).
Two-tier genetic programming: Towards raw pixel-based image classification
.
Expert Systems with Applications
,
39
(
16
):
12291
12301
.
Al-Sahaf
,
H.
,
Zhang
,
M.
, and
Johnston
,
M.
(
2013a
).
Binary image classification using genetic programming based on local binary patterns
. In
Proceedings of the 28th International Conference of Image and Vision Computing New Zealand
, pp.
220
225
.
Al-Sahaf
,
H.
,
Zhang
,
M.
, and
Johnston
,
M.
(
2013b
).
A one-shot learning approach to image classification using genetic programming
. In
Proceedings of the 26th Australian Joint Conference on Artificial Intelligence
, pp.
110
122
.
Lecture Notes in Computer Science
, Vol.
8272
.
Al-Sahaf
,
H.
,
Zhang
,
M.
, and
Johnston
,
M.
(
2014a
).
Genetic programming evolved filters from a small number of instances for multiclass texture classification
. In
Proceedings of the 29th International Conference on Image and Vision Computing New Zealand
, pp.
84
89
.
Al-Sahaf
,
H.
,
Zhang
,
M.
, and
Johnston
,
M.
(
2014b
).
Genetic programming for multiclass texture classification using a small number of instances
. In
Proceedings of the 10th International Conference on Simulated Evolution and Learning
, pp.
335
346
.
Lecture Notes in Computer Science
, Vol.
8886
.
Albukhanajer
,
W.
,
Briffa
,
J.
, and
Jin
,
Y.
(
2014
).
Evolutionary multiobjective image feature extraction in the presence of noise
.
IEEE Transactions on Cybernetics
, PP
(99):1
12
.
Atkins
,
D. L.
,
Neshatian
,
K.
, and
Zhang
,
M.
(
2011
).
A domain independent genetic programming approach to automatic feature extraction for image classification
. In
Proceedings of the IEEE Congress on Evolutionary Computation
, pp.
238
245
.
Bhowan
,
U.
,
Zhang
,
M.
, and
Johnston
,
M.
(
2009
).
Genetic programming for image classification with unbalanced data
. In
Proceedings of the 24th International Conference on Image and Vision Computing New Zealand
, pp.
316
321
.
Bratko
,
A.
,
Cormack
,
G. V.
,
Filipic
,
B.
,
Lynam
,
T. R.
, and
Zupan
,
B.
(
2006
).
Spam filtering using statistical data compression models
.
Journal of Machine Learning Research
,
6:2673
2698
.
Chang
,
C.-W.
,
Ho
,
C.-C.
, and
Chen
,
J.-H.
(
2012
).
ADHD classification by a texture analysis of anatomical brain MRI data
.
Frontiers in Systems Neuroscience
,
6
(
66
):
1
13
.
Cleary
,
J. G.
, and
Trigg
,
L. E.
(
1995
).
K*: An instance-based learner using an entropic distance measure
. In
Proceedings of the 12th International Conference on Machine Learning
, pp.
108
114
.
Cortes
,
C.
, and
Vapnik
,
V.
(
1995
).
Support-vector networks
.
Machine Learning
,
20
(
3
):
273
297
.
Demšar
,
J.
(
2006
).
Statistical comparisons of classifiers over multiple data sets
.
Journal of Machine Learning Research
,
7:1
30
.
Dhurandhar
,
A.
, and
Dobra
,
A.
(
2008
).
Probabilistic characterization of random decision trees
.
Journal of Machine Learning Research
,
9:2321
2348
.
Downey
,
C.
, and
Zhang
,
M.
(
2009
).
Multiclass object classification for computer vision using linear genetic programming
. In
Proceedings of the 24th International Conference on Image and Vision Computing New Zealand
, pp.
73
78
.
Fan
,
Z.-G.
,
Wang
,
K.-A.
, and
Lu
,
B.-L.
(
2004
).
Feature selection for fast image classification with support vector machines
. In
Proceedings of the Conference on Neural Information Processing
, pp.
1026
1031
.
Lecture Notes in Computer Science
, Vol.
3316
.
Fei-Fei
,
L.
,
Fergus
,
R.
, and
Perona
,
P.
(
2006
).
One-shot learning of object categories
.
IEEE Transactions on Pattern Analysis and Machine Intelligence
,
28
(
4
):
594
611
.
Fix
,
E.
, and
Hodges
,
J.
(
1951
).
Discriminatory analysis–nonparametric discrimination: Consistency properties
.
Technical Report 4, USAF School of Aviation Medicine
,
Randolf Field, Texas
.
Freund
,
Y.
, and
Schapire
,
R. E.
(
1996
).
Experiments with a new boosting algorithm
. In
Proceedings of the 13th International Conference on Machine Learning
, pp.
148
156
.
Fu
,
W.
,
Johnston
,
M.
, and
Zhang
,
M.
(
2011
).
Genetic programming for edge detection based on accuracy of each training image
. In
Proceedings of the 24th International Conference on Advances in Artificial Intelligence
, pp.
301
310
.
Fu
,
W.
,
Johnston
,
M.
, and
Zhang
,
M.
(
2012
).
Automatic construction of invariant features using genetic programming for edge detection
. In
AI 2012: Advances in Artificial Intelligence
, pp.
144
155
.
Lecture Notes in Computer Science
, Vol.
7691
.
Galerne
,
B.
,
Gousseau
,
Y.
, and
Morel
,
J. M.
(
2011
).
Random phase textures: Theory and synthesis
.
IEEE Transactions on Image Processing
,
20
(
1
):
257
267
.
Geurts
,
P.
,
Ernst
,
D.
, and
Wehenkel
,
L.
(
2006
).
Extremely randomized trees
.
Machine Learning
,
63
(
1
):
3
42
.
Guo
,
Z.
,
Zhang
,
L.
, and
Zhang
,
D.
(
2010
).
Rotation invariant texture classification using LBP variance (LBPV) with global matching
.
Pattern Recognition
,
43
(
3
):
706
719
.
Hall
,
M.
,
Frank
,
E.
,
Holmes
,
G.
,
Pfahringer
,
B.
,
Reutemann
,
P.
, and
Witten
,
I. H.
(
2009
).
The WEKA data mining software: An update
.
SIGKDD Explorations Newsletter
,
11
(
1
):
10
18
.
Heisele
,
B.
,
Poggio
,
T.
, and
Pontil
,
M.
(
2000
).
Face detection in still gray images
.
A.I.
Memo
1687
,
Center for Biological and Computational Learning, MIT, Cambridge
,
Massachusetts
.
Hindmarsh
,
S.
,
Andreae
,
P.
, and
Zhang
,
M.
(
2012
).
Genetic programming for improving image descriptors generated using the scale-invariant feature transform
. In
Proceedings of the 27th Conference on Image and Vision Computing New Zealand
, pp.
85
90
.
Ishikawa
,
T.
, and
Mogi
,
K.
(
2011
).
Visual one-shot learning as an “anti-camouflage device”: A novel morphing paradigm
.
Cognitive Neurodynamics
,
5
(
3
):
231
239
.
Jain
,
A.
, and
Chandrasekaran
,
B.
(
1982
).
Dimensionality and sample size considerations in pattern recognition practice
. In
P. R.
Krishnaiah
and
L. N.
Kanal
(Eds.),
Handbook of statistics 2: Classification, pattern recognition and reduction of dimensionality
, pp.
835
855
.
Amsterdam
:
Elsevier
.
John
,
G. H.
, and
Langley
,
P.
(
1995
).
Estimating continuous distributions in Bayesian classifiers
. In
Proceedings of the 11th Conference on Uncertainty in Artificial Intelligence
, pp.
338
345
.
Kohavi
,
R.
(
1996
).
Scaling up the accuracy of naive Bayes classifiers: A decision-tree hybrid
. In
Proceedings of the 2nd International Conference on Knowledge Discovery and Data Mining
, pp.
202
207
.
Koza
,
J. R.
(
1992
).
Genetic programming: On the programming of computers by means of natural selection
.
Cambridge, MA
:
MIT Press
.
Kylberg
,
G.
(
2011
).
The Kylberg texture dataset v. 1.0. External Report (Blue series) 35, Centre for Image Analysis, Swedish University of Agricultural Sciences and Uppsala University, Uppsala, Sweden
.
Liddle
,
T.
,
Johnston
,
M.
, and
Zhang
,
M.
(
2010
).
Multi-objective genetic programming for object detection
. In
Proceedings of the IEEE Congress on Evolutionary Computation
, pp.
1
8
.
Lim
,
K.-L.
, and
Galoogahi
,
H.
(
2010
).
Shape classification using local and global features
. In
Proceedings of the 4th Pacific-Rim Symposium on Image and Video Technology
, pp.
115
120
.
Lisin
,
D. A.
,
Mattar
,
M. A.
,
Blaschko
,
M. B.
,
Learned-Miller
,
E. G.
, and
Benfield
,
M. C.
(
2005
).
Combining local and global image features for object class recognition
. In
Proceedings of the IEEE Computer Society Conference on Computer Vision and Pattern Recognition
, pp.
47
55
.
Liu
,
F. T.
,
Ting
,
K. M.
, and
Fan
,
W.
(
2005
).
Maximizing tree diversity by building complete-random decision trees
. In
Proceedings of the 9th Pacific-Asia Conference on Advances in Knowledge Discovery and Data Mining
, pp.
605
610
.
Lecture Notes in Computer Science
, Vol.
3518
.
Liu
,
L.
,
Zhao
,
L.
,
Long
,
Y.
,
Kuang
,
G.
, and
Fieguth
,
P.
(
2012
).
Extended local binary patterns for texture classification
.
Image and Vision Computing
,
30
(
2
):
86
99
.
Lu
,
D.
, and
Weng
,
Q.
(
2007
).
A survey of image classification methods and techniques for improving classification performance
.
International Journal of Remote Sensing
,
28
(
5
):
823
870
.
Luke
,
S.
(
2013
).
Essentials of metaheuristics
, 2nd ed.
Raleigh, NC
:
Lulu
.
Martin
,
B.
(
1995
).
Instance-based learning: Nearest neighbor with generalization
. Unpublished master’s thesis,
University of Waikato, Hamilton, New Zealand
.
Miller
,
E.
,
Matsakis
,
N.
, and
Viola
,
P.
(
2000
).
Learning from one example through shared densities on transforms
. In
Proceedings of the IEEE Conference on Computer Vision and Pattern Recognition
, pp.
464
471
.
Nguyen
,
D. T.
,
Ogunbona
,
P. O.
, and
Li
,
W.
(
2013
).
A novel shape-based non-redundant local binary pattern descriptor for object detection
.
Pattern Recognition
,
46
(
5
):
1485
1500
.
Ojala
,
T.
,
Pietikäinen
,
M.
, and
Harwood
,
D.
(
1994
).
Performance evaluation of texture measures with classification based on Kullback discrimination of distributions
. In
Proceedings of the 12th IAPR International Conference on Pattern Recognition
, pp.
582
585
.
Ojala
,
T.
,
Pietikäinen
,
M.
, and
Harwood
,
D.
(
1996
).
A comparative study of texture measures with classification based on feature distributions
.
Pattern Recognition
,
29
(
1
):
51
59
.
Ojala
,
T.
,
Pietikäinen
,
M.
, and
Mäenpää
,
T.
(
2000
).
Gray scale and rotation invariant texture classification with local binary patterns
. In
Proceedings of the Conference on Computer Vision
, pp.
404
420
.
Lecture Notes in Computer Science
, Vol.
1842
.
Ojala
,
T.
,
Pietikäinen
,
M.
, and
Mäenpää
,
T.
(
2002
).
Multiresolution gray-scale and rotation invariant texture classification with local binary patterns
.
IEEE Transactions on Pattern Analysis and Machine Intelligence
,
24
(
7
):
971
987
.
Olague
,
G.
, and
Trujillo
,
L.
(
2011
).
Evolutionary-computer-assisted design of image operators that detect interest points using genetic programming
.
Image Vision Computing
,
29
(
7
):
484
498
.
Perez
,
C. B.
, and
Olague
,
G.
(
2009
).
Evolutionary learning of local descriptor operators for object recognition
. In
Proceedings of the 11th Annual Conference on Genetic and Evolutionary Computation
, pp.
1051
1058
.
Pietikäinen
,
M.
,
Hadid
,
A.
,
Zhao
,
G.
, and
Ahonen
,
T.
(
2011
).
Local binary patterns for still images
. In
Computer vision using local binary patterns
, pp.
13
47
.
New York
:
Springer
.
Pietroni
,
N.
,
Cignoni
,
P.
,
Otaduy
,
M.
, and
Scopigno
,
R.
(
2010
).
Solid-texture synthesis: A survey
.
IEEE Computer Graphics and Applications
,
30
(
4
):
74
89
.
Platt
,
J. C.
(
1999
).
Fast training of support vector machines using sequential minimal optimization
. In
B.
Schölkopf
,
C.J.C.
Burges
, and
A.J.
Smola
(Eds.),
Advances in kernel methods
, pp.
185
208
.
Cambridge, MA
:
MIT Press
.
Raudys
,
S. J.
, and
Jain
,
A. K.
(
1991
).
Small sample size effects in statistical pattern recognition: Recommendations for practitioners
.
IEEE Transactions on Pattern Analysis and Machine Intelligence
,
13
(
3
):
252
264
.
Rifkin
,
R.
, and
Klautau
,
A.
(
2004
).
In defense of one-vs-all classification
.
Journal of Machine Learning Research
,
5:101
141
.
Rodner
,
E.
, and
Denzler
,
J.
(
2011
).
Learning with few examples for binary and multiclass classification using regularization of randomized trees
.
Pattern Recognition Letters
,
32
(
2
):
244
251
.
Salakhutdinov
,
R.
,
Tenenbaum
,
J. B.
, and
Torralba
,
A.
(
2012
).
One-shot learning with a hierarchical nonparametric Bayesian model
.
JMLR Proceedings
,
27:195
206
.
Smart
,
W. R.
, and
Zhang
,
M.
(
2003
).
Classification strategies for image classification in genetic programming
. In
Proceedings of the International Conference on Image and Vision Computing New Zealand
, pp.
402
407
.
Song
,
A.
, and
Ciesielski
,
V.
(
2004
).
Texture analysis by genetic programming
. In
Proceedings of the IEEE Congress on Evolutionary Computation
, pp.
2092
2099
.
Szeliski
,
R.
(
2010
).
Computer vision: Algorithms and applications
.
New York
:
Springer
.
Tan
,
X.
,
Chen
,
S.
,
Zhou
,
Z.-H.
, and
Zhang
,
F.
(
2006
).
Face recognition from a single image per person: A survey
.
Pattern Recognition
,
39
(
9
):
1725
1745
.
Wang
,
L.
, and
He
,
D.-C.
(
1990
).
Texture classification using texture spectrum
.
Pattern Recognition
,
23
(
8
):
905
910
.
Wilcoxon
,
F.
(
1945
).
Individual comparisons by ranking methods
.
Biometrics Bulletin
,
1
(
6
):
80
83
.
Yang
,
B.
, and
Chen
,
S.
(
2013
).
A comparative study on local binary pattern (LBP) based face recognition: LBP histogram versus LBP image
.
Neurocomputing
,
120:365
379
.
Zhang
,
M.
,
Andreae
,
P.
, and
Bhowan
,
U.
(
2004
).
A two phase genetic programming approach to object detection
. In
Proceedings of the Conference on Knowledge-Based Intelligent Information and Engineering Systems
, pp.
224
231
.
Lecture Notes in Computer Science
, Vol.
3215
.
Zhang
,
M.
, and
Ciesielski
,
V.
(
1999
).
Genetic programming for multiple class object detection
. In
Proceedings of the 12th Australian Joint Conference on Artificial Intelligence
, pp.
180
192
.
Lecture Notes in Computer Science
, Vol.
1747
.
Zhang
,
M.
,
Ciesielski
,
V.
, and
Andreae
,
P.
(
2003
).
A domain-independent window approach to multiclass object detection using genetic programming
.
EURASIP Journal on Advances in Signal Processing
,
2003
(
8
):
841
859
.
Zhang
,
M.
, and
Johnston
,
M.
(
2009
).
A variant program structure in tree-based genetic programming for multiclass object classification
. In
S.
Cagnoni
(Ed.),
Evolutionary image analysis and signal processing
, pp.
55
72
.
Berlin
:
Springer. Studies in Computational Intelligence
, Vol.
213
.
Zhang
,
M.
, and
Smart
,
W.
(
2004
).
Multiclass object classification using genetic programming
. In
Proceedings of the Conference on Applications of Evolutionary Computing
, pp.
369
378
.
Lecture Notes in Computer Science
, Vol.
3005
.

Note

1

The initial versions of the two methods were presented by Al-Sahaf et al. (2013b) and Al-Sahaf et al. (2013a) with very limited investigations. This paper extends them with completely new results and thorough investigations.

Appendix

A.1  Feature Extraction

The average performance on feature extraction of the experimental methods on the data sets of groups A, C, and D, using four different sets of features, is shown in Figure 20.

A.1.1  Group A Data Sets

Apart from AdaBoostM1, the use of one-shot GP and compound-GP extracted features showed significant improvement in the performance of the classifiers when there were fewer than six instances per class in the training set.

On Textures-2, on the other hand, all six classifiers achieved perfect performance using the features extracted by the one-shot GP and compound-GP methods. Apart from KStar and NBTree, it is clear that the new features have large positive impact on the performance of the other four classifiers when there are fewer than four instances per class in the training set.

The results of the experiment on Textures-3 showed that the features of compound-GP slightly lowered the performance of all six methods, and the features of one-shot GP had a large negative impact on the performance of those classifiers. However, all six classifiers achieved significantly better performance using the features of the two new methods compared to those extracted by two-tier GP.

The features extracted by one-shot GP showed improvement in the performance of all the classifiers apart from the AdaBoostM1 classifier with handcrafted features. The features extracted by the compound-GP method, on the other hand, showed positive impact and significantly improved the performance of all six classifiers over the use of both the handcrafted and two-tier features.

A.1.2  Group C Data sets

The results showed that the six classifiers maintained their performances when the features of one-shot GP and compound-GP were used on Textures-6 compared to Textures-1. Meanwhile, apart from AdaBoostM1, the use of handcrafted features had a significant negative impact on the performance of those classifiers.

Similarly, the features extracted by both one-shot GP and compound-GP showed insensitivity to rotation on Textures-7. Also, a nearly consistent performance was achieved by all six classifiers when the handcrafted and two-tier features were used.

Comparing the performance of the six classifiers on Textures-8 and Textures-3, the classifiers showed consistent or slightly improved performance with the handcrafted features, while the compound-GP features lowered the performance of almost all the six classifiers. The features extracted by one-shot GP, on the other hand, showed similar behaviour to the handcrafted features; however, the gap between the two was significant. The inconsistency in the performance that the compound-GP features showed was expected because of obtaining the same behaviour in the first experiment on this data set.

On Textures-9, compared to Textures-4, the six classifiers maintained their performance when the one-shot GP and compound-GP extracted features were used. The handcrafted features showed positive improvement in the performance of all six classifiers compared to that achieved on Textures-4.

A.1.3  Group D Data set

Apart from NB, the features from the one-shot GP and compound-GP methods improved the performance of the other five classifiers on this data set. Although the two-tier GP extracted features showed improvement in the performance of those classifiers, this improvement was still not as good as those introduced by the two new methods (one-shot GP and compound-GP). The handcrafted features showed, in most cases, the worst performance on this data set.

A.1.4  Summary

The results of this experiment showed that the features extracted by the two new methods improved the performance of the six classifiers in most cases. However, those features also showed an inconsistency in other cases, especially Textures-3 and its rotated version, Textures-8. Most important, the features detected by the one-shot-GP and compound-GP methods are not biased to a specific classifier, and are invariant to rotation, illumination, and scale variations to some extent.

A.2  Training and Testing Times

The average training and testing times for the four GP-based methods on the data sets of groups B, C, and D are shown in Figure 21.

A.3  Program Size

The average program size per generation for the four GP-based methods on the data sets of groups A, C, and D is shown in Figure 22.