IEEE Computational Intelligence Magazine - February 2023 - 26

meanwhile, lnðaÞ is protected and applied only when a > 0. In
addition, the internal nodes can also encode one of the BFs
listed in Table I. In such a case, the arity is equal to 2 and the first
outgoing edge points to a terminal node encoding an integer
value, which represents the BF parameter related to the dilation
intensity. The second outgoing edge points to a node encoding
a real value representing the actual input of the BF, i.e., the
coordinate of the point in the search space where the DF is
applied. Finally, the terminal nodes can also encode values
referring to the coordinate of the point in the search space
where the DF is applied, or arbitrary real values ranging in [0,1].
The use ofthese functional and terminal nodes can generate
trees encoding DFs that can potentially map points outside the
unit interval, leading the meta-heuristics to consider points outside
the feasible search space. To avoid this problem, GP4DFs
applies a control step after mapping the point of the original
search space into the dilated one by using the DFs encoded in
the candidate solutions. Specifically, only the decimals of the
values computed by the DF are considered to perform the mapping
onto the dilated landscape. For instance, let pi be the i-th
coordinate of the point p to be remapped and p0
i ¼ DFiðpiÞ¼
1:46, where DFi is the candidate DF for the i-th dimension,
thenp0
if the obtained p0
i ¼ 0:46 is considered by GP4DFs. It is worth noting that
i value is an even integer number greater than
1, then it is mapped to 0; otherwise, it is mapped to 1.
GP4DFs exploits a ðm þÞ evolutionary strategy to evolve
the individuals. Different from classic GP approaches, GP4DFs
employs a " warm " initialization strategy based on a knowledge-driven
approach to create halfofthe m individuals ofthe
population. First, 8 individuals are initialized using the 8 optimal
DFs found in [27] (lines 1 3 of Algorithm 1). Each DF is
assigned to a single individual and used to initialize all its subtrees,
that is, the same DF is used for all the D dimensions ofthe
search space. Such 8 DFs have been extracted by analyzing and
detecting unique evolved DFs on the benchmark functions
considered in [27]. For convenience ofthe reader, these DFs are
reported in Table S3 of the supplementary material, available
online. Then, the remaining m=2 8 individuals are initialized
by randomly selecting one ofthe possible BFs for each subtree,
i.e., each dimension ofthe search space (lines 4 5). The other
m=2 individuals are initialized by using the classic Ramped
Half-and-Half method (lines 6 7) [32]. For the initialization
ofeach tree, this approach randomly selects either the growth or
thefull initialization strategy. Thegrowth strategy builds a tree by
randomly selecting functional nodes and primitive nodes until a
maximum depth (10 in this work) is reached; then, only primitive
nodes are selected to complete the tree. Ifa primitive node
is selected, the tree will stop growing from that leaf; consequently,
the obtained tree will be composed of subtrees with
different depths. On the contrary, the full strategy selects only
functional nodes until the maximum depth is reached; then, the
primitive nodes are selected to complete the tree. The advantage
of using the Ramped Half-and-Half method is a greater
" variability " among the generated trees [38], compared to other
standard initialization strategies. Considering that GP4DFs uses
26 IEEE COMPUTATIONAL INTELLIGENCE MAGAZINE | FEBRUARY 2023
Algorithm 1. Pseudocode of GP4DFs.
10:
1: population = empty_population()
2: trees = initialize_knowledge_trees(number=8)
3: population.append(trees)
4: trees = initialize_BFs_trees(number=m/2 - 8)
5: population.append(trees)
6: trees = initialize_ramped_trees(number=m/2)
7: population.append(trees)
8: generation = 0
9: while generation < max_generation do
offspring = []
11: i=0
12:
13:
14:
15:
16:
17:
18:
19:
20:
21:
22:
23:
while i < lambda do
if rand_uni(min=0, max=1) < p_c then
p1 = select_random_parents(population)
p2 = select_random_parents(population)
child = one_point_crossover(p1, p2)
offspring.append(child)
else
p = select_random_parent(population)
child = mutation(p)
offspring.append(child)
i=i+1
evaluate_offspring()
24: j=0
25: m_plus_ = concatenate(population, offspring)
26:
27:
28:
29:
30:
31:
population = []
while j < m do
winner = tournament(m_plus_, n=5)
population.append(winner)
j=j+1
generation=generation+1
32: best_individual = find_best_individual(population)
33: return best_individual
a strongly typed GP, the terminal nodes of the individuals are
initialized according to the required type. In particular, integer
nodes are randomly extracted from the set ofall possible integer
terminal nodes, while real-valued nodes have a probability
equal to 0.5 to be generated as either the coordinate ofa point
ofthe search space, or a real-valued number randomly sampled
from a uniform distribution in the unit interval. Finally, the
height ofeach subtree encoding a DF is limited to 10 in order to
contain the bloat problem, which generally affects the GP
approaches.
The evolution ofGP4DFs works as follows: in each generation,
descendants are generated from the m parents using the
following strategy, which does not include any elitism mechanism
(lines 8 22): either the crossover or mutation is applied to generate
an individual. Specifically, these genetic operators are
selected using a mutually exclusive probability, i.e., pc þpm ¼ 1,
where pc and pm indicate the crossover probability and mutation
probability, respectively. In order to apply the crossover operator,
two parents are randomly selected from the m parents, and only
the first generated child is added to the offspring population (lines
13 18). Similarly, the mutation is applied to a randomly
IEEE Computational Intelligence Magazine - February 2023

Table of Contents for the Digital Edition of IEEE Computational Intelligence Magazine - February 2023
