Fitness Dependent Optimizer: Inspired by the Bee Swarming Reproductive Process

In plain words

Optimization means finding the input that gives the best score for some function, for example the lowest error or the lowest cost. A common family of methods copies how animals search together: many simple agents spread out, share what they find, and move toward good spots. This paper proposes one such method, the Fitness Dependent Optimizer (FDO), inspired by how honeybee swarms pick a new nest.

In FDO, each agent is a "scout bee" that sits at one candidate solution. On every round, the agent's step length and direction are based on how good the current best candidate is compared with the agent's own score, plus some randomness. This is different from the usual swarm methods, which keep a velocity that is updated from memory. FDO also remembers the last step that helped an agent, and tries it again if the new step fails.

The authors report that FDO works better than several well-known swarm and evolutionary methods on standard test functions and on two engineering-style examples. These comparisons come from the authors' own experiments, so treat them as claims to check.

TL;DR

• FDO is a swarm optimizer that replaces PSO-style velocity with a step scaled by a fitness-derived weight §III §IV.
• Per agent it needs a fitness weight, a random factor and a stored pace; the paper says the only parameter to tune is the weight factor wf §IV §V.1.
• Author-reported: best or competitive results against PSO, GA, DA on 19 classical functions and against DA, WOA, SSA on 10 CEC-2019 functions, with 30 runs §V tab. 2 tab. 3.
• The official code is an Apache-2.0 MATLAB port with several differences from the paper; see Paper vs code before implementing.

Problem

Nature-inspired metaheuristics can get stuck in local optima, and they have few guarantees on hard multimodal problems §I. The paper argues that no single algorithm is best on every problem (the No Free Lunch argument) and that a new method is worth proposing when it helps on some problems §I. It also argues that PSO-based updates need several coefficients that are tuned by hand, while FDO needs only one §IV.

Method

FDO is presented as a population of N scout bees that search a bounded box. The procedure is given in the pseudocode below and in Figure 3 fig. 3.

1. Initialisation. Scouts start at random positions inside the bounds §IV. The initial pace of each scout is not stated fig. 3.
2. Best scout. In each iteration the paper selects the global best scout once §IV.
3. Fitness weight. For each scout, the weight is the ratio of the best fitness to the scout's own fitness, minus the weight factor wf eq. 2. The paper says the weight should lie in [0, 1] §IV. The text says wf controls how the weight behaves, and that wf = 0 gives the more stable search §IV.
4. Zero fitness. When the scout's own fitness is 0, the weight is set to 0 instead of dividing by zero §IV fig. 3.
5. Random factor. The paper names r as a random number in [-1, 1] and says a Lévy flight is used for it, because its distribution gives more stable movement §IV.
6. Pace. The pace depends on the weight and r eq. 3 eq. 4 eq. 5. If the weight is 0 or 1, the pace is the scout's position times r eq. 3. Otherwise the pace is the distance to the best scout times the weight, with the sign chosen by the sign of r eq. 4 eq. 5.
7. Candidate move. The new position is the old position plus the pace eq. 1. If it improves the fitness, it is accepted and the pace is saved fig. 3.
8. Second try. If the candidate is not better, the scout tries the position plus its previously saved pace, when one exists §IV fig. 3. If that is better, it is accepted.
9. Otherwise the scout stays where it is fig. 3.
10. Maximisation. Two changes are needed: Equation 6 replaces Equation 2, and the comparisons are inverted §IV.

# Fitness Dependent Optimizer, minimisation  [alg. 1] [fig. 3]
# Input:  objective f; bounds lower, upper; n scouts; T iterations; wf
# Output: best position found and its fitness; dims = problem dimension

def fdo(f, n, T, wf, lower, upper):
    # Random start inside the box  [§IV]
    positions = random_uniform(lower, upper, shape=(n, dims))  # (n, dims)
    # Saved pace per scout, empty until its first accepted move  [fig. 3]
    paces = [None] * n
    for t in range(T):
        # Best scout of this iteration, taken once per iteration  [§IV]
        best = positions[argmin(f(positions))]
        for i in range(n):
            # Weight is 0 when the scout's own fitness is zero  [fig. 3]
            if f(positions[i]) == 0:
                weight = 0
            else:
                # Eq. 2 as printed, with an absolute value  [eq. 2]
                weight = abs(f(best) / f(positions[i])) - wf
            # Random number in [-1, 1]  [§IV]
            r = random_uniform(-1, 1)
            # Weight of 0 or 1 gives a pace from the position  [eq. 3]
            if weight == 0 or weight == 1:
                pace = positions[i] * r
            # Negative r flips the sign of the step  [eq. 4]
            elif r < 0:
                pace = (positions[i] - best) * weight * -1
            # Non-negative r keeps the sign  [eq. 5]
            else:
                pace = (positions[i] - best) * weight
            # Candidate from the new pace  [eq. 1]
            candidate = positions[i] + pace  # boundary rule not stated
            if f(candidate) < f(positions[i]):
                # Accept and keep this pace for reuse  [fig. 3]
                positions[i] = candidate
                paces[i] = pace
            elif paces[i] is not None:
                # Retry with the saved pace  [§IV] [fig. 3]
                candidate = positions[i] + paces[i]  # [eq. 1]
                if f(candidate) < f(positions[i]):
                    positions[i] = candidate
                # Otherwise keep the current position  [fig. 3]
    # Best scout after the last iteration  [§IV]
    best = positions[argmin(f(positions))]
    return best, f(best)

Key equations, as printed in the paper:

X_{i,t+1} = X_{i,t} + pace eq. 1

fw = \left| \frac{x^*_{t,\,fitness}}{x_{i,t,\,fitness}} \right| - wf eq. 2

Here x^*_{t} is the best scout and x_{i,t} the current scout. Equation 2 applies to minimisation.

pace = x_{i,t} \cdot r \quad \text{if } fw = 1,\ fw = 0,\ \text{or } x_{i,t,\,fitness} = 0 eq. 3

pace = (x_{i,t} - x^*_{i,t}) \cdot fw \cdot (-1) \quad \text{if } r < 0 eq. 4

pace = (x_{i,t} - x^*_{i,t}) \cdot fw \quad \text{if } r \ge 0 eq. 5

fw = \left| \frac{x_{i,t,\,fitness}}{x^*_{t,\,fitness}} \right| - wf eq. 6

Equation 6 is the maximisation variant of Equation 2 §IV.

Sign of the step in Equations 4 and 5: at the scan resolution the signs are hard to read with certainty, so check against the PDF before coding. See Pitfalls.

Benchmark definitions, for reference:

f = \max \left( 20 \log |AF(\theta)| \right) eq. 8

AF(\theta) = \sum_{i=1}^{4} \cos[2\pi x_i (\cos\theta - \cos\theta_s)] + \cos[2.25 \times 2\pi (\cos\theta - \cos\theta_s)] eq. 9

These two equations define the antenna array objective, with \theta_s = 90^\circ §V.5A fig. 9 eq. 8 eq. 9.

f(\vec{x}) = \sum_{t=0}^{100} \left( y(t) - y_0(t) \right)^2 eq. 13

Equation 13 is the frequency-modulated sound fitting objective, with y(t) = a_1 \sin(w_1 t \theta + a_2 \sin(w_2 t \theta + a_3 \sin(w_3 t \theta))) eq. 11 and y_0(t) the target signal eq. 12 §V.5B.

Hyperparameters

Results

Author-reported. Setup: 19 classical functions (10-D, 30 scouts, 500 iterations, 30 runs) and 10 CEC-2019 functions (30 agents, 500 iterations) §V.1 §V.2. The PSO, GA and DA classical results are taken from the DA paper and not re-run §V.1; the CEC baselines (DA, WOA, SSA) were run by the authors with their published default parameters §V.2. Wilcoxon rank-sum tests are reported in tab. 4 and tab. 5 §V.3.

Classical benchmarks, mean and standard deviation over 30 runs tab. 2:

tab. 2 Source for all values. Read from the PDF table; the paper's own column order is FDO, DA, PSO, GA.

Authors' description of the classical results §V.1: FDO generally gives better results on TF1–TF6, other algorithms are better on TF7, FDO is poor on TF8 even though it beats PSO there, FDO beats DA and GA on TF9, and FDO outperforms DA, PSO and GA on TF14–TF17 and TF19.

CEC-2019 benchmarks, average and standard deviation over the runs tab. 3:

tab. 3 Source for all values. The CEC01 DA, WOA and SSA cells are printed in exponent form in the paper, as shown. The text reports FDO outperforms the other algorithms on CEC except CEC06 §V.2.

Wilcoxon rank-sum, FDO versus DA, classical benchmarks tab. 4:

tab. 4 Source. The text says TF2 is the only one above 0.05 and explains TF16 and TF18 as cases where DA gives the same value in all runs §V.3.

Wilcoxon rank-sum, FDO against DA, WOA and SSA, CEC-2019 tab. 5:

tab. 5 Source. The text says the differences are significant in all cases except CEC03 against DA and WOA, and CEC04 and CEC08 against WOA §V.3.

Real-world examples, author-reported:

• Antenna array §V.5A fig. 10: with 20 scouts over 200 iterations, the global best reaches its best value at iteration 78, at element positions {0.713, 1.595, 0.433, 0.130} §V.5A. Figure 10 shows the global best near -120 in the plot; this value is read from the figure and not stated in the text.
• FM sound synthesis §V.5B fig. 11: with 30 agents over 200 iterations, the parameters at iteration 200 are a1 = 0.974, w1 = -0.241, a2 = -4.3160, w2 = -0.0193, a3 = -0.5701, w3 = 4.937 §V.5B. The global best converges near its optimum from iteration 64 §V.5B. The paper gives no numeric objective value for this result.

Quantitative metrics (10 agents, 150 iterations) are shown only as figures fig. 4 fig. 5 fig. 6 fig. 7; no numbers are given for them §V.4.

Paper vs code

Code: MATLAB repository https://github.com/Jaza-Abdullah/FDO at code_commit ffd8a87e2e98770c6dd5652127d08246c84f7cd1, Apache-2.0. The paper does not link it. I found it by searching GitHub for "fitness dependent optimizer". Its owner matches author Jaza M. Abdullah, and the header of FDO.m names the paper and its DOI FDO.m. Citations below use paths relative to the repository root. I did not use the repository Tarik4Rashid4/FDO-matlab: it has no license file and its citation names a different author.

Discrepancies, each with both citations:

1. Weight special case. The code sets the weight to 0.2 when the best fitness is below 5% of the scout's fitness; the paper has no such rule FDO.m. The paper's weight is the absolute ratio minus wf eq. 2; the code uses the ratio with no absolute value and no sign handling FDO.m.
2. Zero fitness. The paper sets the weight to 0 when the scout's own fitness is zero fig. 3. The code only assigns a weight when the best fitness is non-zero FDO.m, and it divides by the scout's fitness without checking for zero FDO.m. A zero weight is never set in the code. When the best fitness is zero, the variable keeps its previous value FDO.m.
3. Pace for weight 0. The paper gives pace = position × r for weight 0 eq. 3. The code uses the distance to the best times r FDO.m.
4. Random factor scale. The paper uses r in [-1, 1] §IV. The code uses Levy(1), which is a Lévy step (exponent 3/2) multiplied by 0.01 FDO.m Levy.m. The code's Lévy generator cites Yang's 2014 book and a 2015 Springer paper Levy.m.
5. Best per agent. The paper selects the global best once per iteration §IV. The code recomputes the best inside the agent loop, so later agents see updated positions FDO.m.
6. Second try. The paper's second try is the position plus the saved pace, and the scout stays put on failure fig. 3. The code's second try adds the distance-weighted step as well as the saved pace FDO.m. On failure, the code moves the scout by its position times a Lévy step instead of keeping it still FDO.m.
7. Boundary handling. The paper says nothing about bounds. The code replaces any coordinate outside the bounds with the bound times a Lévy step FDO.m.
8. Benchmarks TF14–TF19. The paper defines these as 10-D composite functions on [-5, 5] tab. 8. The code's F14–F19 have dimensions 2, 4, 2, 2, 2 and 3, and different bounds Select_Functions.m. The paper's TF14–TF19 numbers cannot be reproduced from this code.
9. Shift positions. The paper gives shift positions for TF1–TF13 tab. 6 tab. 7. Select_Functions.m stores only bounds and dimensions Select_Functions.m. I did not find a shift in the code, but I did not read every function body.
10. Per-function wf. The paper sets wf = 1 for TF2 and TF6 §V.1. Main.m uses one fixed value, wf = 0.0 Main.m. The per-function settings are not in the repository.
11. Runs. The paper averages 30 runs §V.1. Main.m runs one optimisation of F1 Main.m.
12. Maximisation. The paper gives Equation 6 and a change to the comparisons for maximisation §IV. The code only minimises FDO.m.
13. Dimensions and bounds, TF1–TF13 and CEC. These match the paper's tables tab. 6 tab. 7 tab. 9 Select_Functions.m.

Pitfalls

• Eq. 13. The text says the fitness is "the summation of the square root" of the difference §V.5B. Equation 13 as printed is the sum of squared differences over t = 0 to 100 eq. 13. Implement the equation and check your numbers against the paper's figure before you rely on it.
• Signs in Eq. 4 and Eq. 5. As printed, the two equations give pace = (x − x*) × fw × (−1) for r < 0 and pace = (x − x*) × fw for r ≥ 0. The code gives the opposite sign for r ≥ 0 FDO.m. The printed signs are hard to read at the scan resolution, so check the PDF before coding.
• Negative fitness. TF8 has a minimum of −418.9829 tab. 7. The ratio f(best)/f(scout) can be negative when the two fitnesses have different signs. The paper's absolute value keeps the weight positive eq. 2; the code has no absolute value FDO.m.
• Zero fitness. The paper's zero rule fig. 3 is missing from the code. Use the paper's rule and say so if you port the code.
• Lévy step scale. The paper names a Lévy flight but gives no exponent or scale §IV. The code uses exponent 3/2 and a 0.01 scale Levy.m. Results depend on this choice.
• Tuned wf. The paper says wf is the only parameter to tune §IV. It is set per function §V.1, and those settings are not in the code. Expect to tune it on your own problem.
• Statistics. The classical PSO, GA and DA results come from another paper, not from the same runs §V.1. Compare with care.
• Figure labels. Figure 7 is labelled "FT9" and "TF17 in 10-D", while the text describes the 2-D experiment §V.4 fig. 7.
• Cost. The paper gives the per-iteration time as O(p·n + p·CF) and the space as O(p·CF + p·pace) §IV, where p is the population size, n the dimension and CF the cost of one objective evaluation.

Lineage

• Builds on: particle swarm optimisation, which the paper calls the base for its update style §I §IV. The paper states that FDO has no algorithmic link to the honey bee algorithm or to artificial bee colony §I.
• Compared against: PSO, GA and DA on the classical functions §V.1; DA, WOA and SSA on CEC-2019 §V.2.
• Superseded by: not known from this wiki.