A DSL for Swarm Intelligence Algorithms

The search process begins with the initialization of a population of individuals. Initializing the population with a diverse and representative set of solutions that effectively cover the solution space is recommended.

Population initialization generates an initial set of candidate solutions. This can be formalized as a function $f:n\to S_0$, where $n\in {\mathbb{Z}}_{>1}$ is the size of the population, and $S_0=\{s_1,s_2,\mathrm{\dots },s_n\}$ is the resulting set of solutions.

Usually, random number generation methods are used to initialize the population. Random number generation can be generated from any probability distribution depending on the problem.

Individuals in the population can be organized so that it is possible to manipulate the dissemination of information throughout the population [3]. Individuals can be grouped into neighborhoods, limiting their access to information to the assigned neighborhood. Although this method is popular in the PSO community, it can be generalized to other population-based metaheuristics.

A topology function can be any function $f:P\to T$ that, given the population of individuals $P$ as input, produces as output the set of neighborhood $T=\{N_1,N_2,\mathrm{\dots },N_n\}$ where $N_k=\{1,2,\mathrm{\dots },n\}$ represents the set of individuals of a given neighborhood.

Usually, all individuals in the population have information about the entire population. This topology is termed globally oriented (GBest). In contrast, locally oriented (LBest) is defined when the adjacent population members are arranged in neighborhoods [21, 8].

Only LBest and GBest topologies were employed in this study. However, since the topology function is triggered in every iteration $i$, our approach remains valid even when the topology is dynamic, that is, the organization changes over the iterations.

In every iteration $i$, selected individuals update their solution by generating new candidate solutions based on the information provided by their neighborhood. Usually, one update per individual takes place in every generation. Others, like TLBO and ABC, perform multiple updates based on some selection mechanism. Thus, a pipeline where one or more updates occur can be generalized, i.e., in every iteration, a set of updates $U=\{u_1,u_2,\mathrm{\dots },u_n\}$ occurs sequentially.

Every update method $u_k$ in the pipeline can be defined by the couple $(f,g)$, where $f$ is the selection function and $g$ is the update function, that is, only selected individuals can generate new candidate solutions.

The selection process can be generalized by a function $f:P\to F$ such that, given the population $P$, it returns the selected individuals $F\subseteq P$. Examples of selection procedures include:

• $\mathrm{■}$

  All: All individuals are selected.

• $\mathrm{■}$

  Random: $k$ individuals are randomly selected.

• $\mathrm{■}$

  Probabilistic: $k$ individuals are selected based on some fixed probability or proportionally to their fitness, that is, better/worst-fitted individuals have higher chances of being selected.

• $\mathrm{■}$

  Rule-based: The selection of an individual is governed by a set of rules.

Then, the selected individuals engage in the process of updating their position (solution). The update process can be generalized by a higher order function $g:e\times r\to s_i$ where $s_i=(s_1,s_2,\mathrm{\dots },s_d)$ is the generated solution vector with $d$ dimensions, $e$ represents the function responsible for the calculation of candidate solutions and $r$ the recombination method.

To generate the solution vector, equations are applied using information about the search space collected by the neighborhood, for example, the best and worst solutions. The equations usually include random perturbations to promote exploration and exploitation of the search space.

The generated solution is then recombined using some specific method $r$, that is, applying the generated solution to $k\le n$ dimensions of the current solution of the individual $s_{i-1}$. This process is referred to as recombination. Usually, the generated solution is applied to all dimensions. Other methods include:

• $\mathrm{■}$

  Binomial: Based on a predefined probability, the dimensions will be randomly selected and updated with the new solution.

• $\mathrm{■}$

  Exponential: Starting with a randomly chosen index of the circularly arranged set of dimensions, adjacent indices are selected and updated with the new solution until we fail a probability roll [9].

• $\mathrm{■}$

  Random: A fixed number of dimensions are updated randomly.

• $\mathrm{■}$

  Probabilistic: An approach similar to the binomial method. However, a maximum of $k$ dimensions are updated.

The candidate solution generated $s_i$ from the update method is then evaluated. Some algorithms are elitist, discarding the candidate solution if it is not better than the individual’s best-known solution.

From the algorithms studied, a function evaluation is performed for every update, with FF representing the only gray area. In the proposal paper pseudocode [41], FF has an iterative process in that, in each generation, an individual calculates a new solution and performs function evaluations for every other individual with a better fitness value. However, in the MATLAB code [42], the author suggests that the update method is applied iteratively whenever the individual finds another one with better fitness, and at the end only one evaluation of the objective function evaluation is made.

In order to make our proposal more easily adaptable in parallel computing scenarios, this study assumes that each update method only undergoes one objective function evaluation per individual. This approach allows for the decoupling of the objective function evaluation from the update method, that is, the user provides the update pipeline, and internally the system takes care of the solution evaluation task after each update. Thus, parallel execution of the evaluation task and the update method can be enabled among individuals for every iteration $i$.

The search space statement is shown in Listing 2. It begins with the declaration of one or more variables. A variable can be a vector; in this case, the size should be specified. The lower and upper bounds of each variable are specified using real numbers.

When specifying the objective function, the goal of the optimization should be declared. That is, MINIMIZE or MAXIMIZE should be used to specify the optimization goal.

The search strategy statement is shown in Listing 3. First, the parameter declaration occurs and is optional since some algorithms do not require parameters. Parameters can be set statically, using numbers or integers, dynamically set using expressions, or, in addition, automatically set using AUTO. Then, the process described in Section 3 follows.

To perform parameter tuning, replace the static parameter expression with the automatic one as shown in Listing 4. Integer and real numbers are supported to define the boundaries of the search space where parameter tuning should occur. It is worth pointing out that when automatic parameters are defined, the statement TUNE UNTIL(...) must be specified, and the maximum number of generation (trials) should be provided, i.e. how many evaluations of the SI algorithm are allowed during parameter tuning.

The population initialization instruction follows the parameter declaration. The size expression defines the number of individuals of the population, while initialization instructs which method to use. Listing 5 shows the currently supported methods.

The topology of the population is optional. When specifying a Lbest topology, the default size of the neighborhoods is 2 when not provided by the user.

Before moving further, let us introduce the individual memory. It contains a set of properties that are managed internally throughout generations. It is made up of the following properties:

• $\mathrm{■}$

  POS: The current position of the individual.

• $\mathrm{■}$

  BEST: The best position the individual found.

• $\mathrm{■}$

  DELTA: The size of the last step taken by the individual, that is, the difference in position between the current and the previous position.

• $\mathrm{■}$

  FIT: The current fitness of the individual.

• $\mathrm{■}$

  IMPROVED: If the current position represents an improvement in fitness compared to the previous one.

• $\mathrm{■}$

  TRIALS: The number of trials that an individual has performed without improving its fitness.

• $\mathrm{■}$

  NDIMS: The number of dimensions that compose the position vector.

• $\mathrm{■}$

  INDEX: The index of the individual in the population.

For the update pipeline, the selection, update, and recombination methods are supported. In the selection expression, the selectors in Listing 6 can be optionally specified. If specific selectors are provided, WHERE and ORDER BY must be omitted; otherwise, these clauses can be used with individual properties in the comparison expression.

Since in some algorithms, the update method can have several instructions, helper variables can be specified as needed. For example, in PSO, velocity can be defined as a helper variable to aid in position calculation. The position of the individual, POS, is always required in the update method, as it defines the new position of the individual in the search space. However, with the statement WHEN, specific conditions can be defined to update the individual. For example, to update the individual position only if the new position is better than the previous position.

By default, search space helper variables are also available allowing the use of context-specific search space variables. MAX\_GEN and CURR\_GEN return the maximum and current generation, respectively. The same logic is also applied to MAX\_EVALS and CURR\_EVAL.

Both helper and POS are defined using expression where mathematical operations can be performed using information derived from the population. In addition, the constructs reference, aggregation, utility_function, and perturbation are allowed as shown in Listing 7.

In SI algorithms, the common requirement for calculating a candidate’s position is to use the information provided by the population or neighborhood. Thus, reference can be used for this purpose. Here, when SWARM_BEST or SWARM_WORST is used without specifying the size, the best or worst individual in the neighborhood is returned, respectively. Otherwise, the $k$ best/worst will be returned. In addition, the UNIQUE clause ensures that individuals are selected without duplication on the update method. Random and roulette selection can be done with or without replacement.

Although in this proposal SUM, AVG, MIN, and MAX are the aggregation operators proposed, additional ones could be added. However, utility functions MAP and REDUCE are supported and can be used to specify more complex aggregation operations.

In fact, complex logic is sometimes required in SI algorithms. FILTER, MAP, and REDUCE provide a way to execute operations on an expression that evaluates into a collection. FILTER constructs a new collection by including only the elements of the original collection for which a specified expression evaluates to true. MAP transforms each collection element using expression, producing a new collection of transformed values. REDUCE computes a single result for the collection elements using the acc parameter as the aggregator of results.

The individual and its properties can be accessed in the key parameter. For example, for an operation performed on a collection of individuals, if individual is defined as the name of the parameter key, the expression individual.fit gives the fitness of the individual being evaluated.

DISTANCE calculates the euclidean distance between two expressions, for example, the positions of two individuals. REPEAT returns a list of the first expression parameter repeated the number of times specified by the second expression.

Finally, perturbations can be used to define the new position of the individual. These are the identical probabilistic distributions allowed in the initialization step. However, here, the size of the random number generation can be specified while in initialization its by definition given by the number of dimensions of the search space.

Listing 8 shows the termination criteria statement. EVALUATIONS and GENERATION define the maximum allowed number of evaluations and generations, respectively. FITNESS defines the minimum or maximum fitness value that must be achieved before termination. If more than one condition is specified, the termination will occur whenever one of them is reached.

To illustrate the expressiveness and practical utility of the proposed DSL, we present implementations of GWO and BB using SDL. Both algorithms are applied to the Sphere function, a well-known benchmark in continuous optimization.

The Sphere function is defined by:

where $𝐱\in {ℝ}^d$ and $-5.12\le x_i\le 5.12$ for all $i=1,\mathrm{\dots },d$. It is a simple, convex, and continuous function with a single global minimum of $f({𝐱}^{\ast })=0$, at ${𝐱}^{\ast }=0,\mathrm{\dots },0$.

As shown in Listings 9 and 10, with 13 and 17 lines of SDL for BB and GWO respectively, it was possible to express not only the algorithms but also the objective function, showing the prototyping capabilities of such DSL.

Due to space constraints, the implementation of the remaining algorithms used in this study is available at: https://github.com/kafm/swarmist/tree/main/examples. These examples illustrate the expressiveness and practicality of the proposed SDL. Each algorithm can be implemented in a concise and readable manner, with high-level constructs that clearly capture the intended behavior demonstrating the language’s effectiveness in reducing boilerplate and improving clarity.

Another key aspect of such approach is that we can create hybrid algorithms, but using building blocks from other algorithms. For instance, we can apply the binomial crossover from DE to BB as shown in Listing 11.

To demonstrate the feasibility of the proposal DSL, an example implementation was developed and is available on GitHub: https://github.com/kafm/swarmist. Although built using Python, the same principles can be used to port the DSL to other programming languages.

Lark [30] was used as the parsing library. A complete machine-readable grammar for SDL in EBNF format can be found at https://github.com/kafm/swarmist/blob/main/swarmist/sdl/grammar.py, which defines every nonterminal, token, and production rule needed for parsing, thus satisfying the requirement for a formal and unambiguous DSL specification.

For parameter tuning, the example implementation used Optuna [1], however, different implementations can use different frameworks or methods.

This implementation was then used to perform the following experiments: 1) comparative results with traditional implementations; and 2) parameter tuning performance evaluation.

We used benchmark functions of the CEC-2017 competition (F1 to F20) [40] with 30 dimensions for all experiments. Opfunu [36], a Python library that implements these benchmark functions, was used. In addition, we set the termination criteria to 2500 epochs and the population size was set to 40 individuals for all algorithms.

The SDL proposed in this study leverages high-level constructs to abstract common SI mechanisms. This abstraction facilitates implementation by reducing the need for imperative code and enabling modular composition of algorithms. In practice, this led to more concise, readable, and reusable definitions.

Although the current work focuses on the definition and execution of algorithms, further extensibility could enhance the long-term utility of the language. For example, the ability to persist and reuse complete algorithm definitions would allow practitioners to encapsulate algorithmic logic once and reuse it across different problems. Listing 12 illustrates a hypothetical SDL syntax for persisting an algorithm, while Listing 13 shows how such an algorithm could be reused.

A similar mechanism could also apply to lower-level abstractions, such as reusable expressions for parameter adaptation or recombination strategies. This would further promote the construction of hybrid algorithms by mixing building blocks at different abstraction levels, ultimately improving the language’s expressiveness and extensibility.

Based on these insights, we hypothesize that SDL could support the emergence of an evolving, reusable library of SI algorithm components. This collection, combined with automatic tuning and composition mechanisms, could form the basis for automated algorithm design tailored to specific problem classes.

Although these capabilities were not addressed in this study, they represent promising directions for future work. However, their implementation involves complex design challenges that will require further investigation.

Learning a new language may not be ideal for practitioners, and one may argue that visual interfaces may be preferred over DSLs. However, the textual nature of SDL offers precise version-controlled specifications that improve systematic design and auditing of optimization models.