The original DE algorithm, conceived in the 1990s, operates with a fixed population size. A population of candidate solutions, each encoding a possible answer to the optimization problem, is iteratively improved through mutation, crossover, and selection. This fixed-size design is elegant and easy to implement, but decades of research have shown that it is rarely the most efficient choice. Early in a search, a large population promotes exploration, allowing the algorithm to survey many regions of the solution space and avoid premature convergence on poor solutions. Later, once promising regions have been identified, a smaller population concentrates computational effort on refining the best candidates. Modern DE variants therefore adopt advanced strategies for reducing the population size during evolution, trading breadth for depth as the run progresses.

The Maribor team’s review is remarkable in its scope: the researchers analyzed 204 studies on population size reduction methods, providing both a structured overview of the field and an original experimental analysis. The methods they surveyed fall broadly into two families. Linear population size reduction (LPSR) shrinks the population at a constant rate from its initial size down to a small minimum, typically a handful of individuals, by the end of the run. Non-linear population size reduction (NLPSR) methods, by contrast, use non-uniform schedules, adaptive rules, or problem-dependent mechanisms to decide when and how quickly to remove individuals. The distinction sounds technical, but it captures a genuine design tension: should the population contract steadily and predictably, or should its size respond dynamically to the state of the search itself?

To move beyond a literature survey, the authors conducted a rigorous comparative analysis. They selected representative reduction methods and integrated each of them into jSO, a state-of-the-art DE variant that has performed strongly in international optimization competitions. This controlled design is important, because it isolates the effect of the population size strategy from other algorithmic choices. By plugging different reduction mechanisms into the same underlying algorithm, the researchers could attribute differences in performance to the reduction strategy alone rather than to a tangle of interacting components. The resulting experiments compared fifteen methods across a demanding test environment.

The benchmark of choice was the CEC 2024 suite, a collection of numerical optimization functions maintained for the IEEE Congress on Evolutionary Computation. These functions are deliberately crafted to stress different aspects of an optimizer: unimodal functions test the ability to converge quickly on a single basin, multimodal functions scatter many local optima to trap premature convergence, hybrid functions combine different landscape characteristics within a single problem, and composition functions blend several sub-functions into landscapes of daunting complexity. The team ran the experiments at problem dimensions of 10, 30, 50, and 100 variables, since the dimensionality of a problem profoundly changes how an optimizer behaves. High-dimensional problems, in particular, are notoriously difficult because the search space grows exponentially with the number of variables.

The statistical analysis relied on the Friedman test, a non-parametric method for ranking multiple algorithms across many problems. Applied to the fifteen methods, the test delivered a striking result: on 100-dimensional problems, ten non-linear population size reduction methods were ranked higher than the linear reduction method. This suggests that as problems grow more complex, the flexibility of non-linear schedules pays off, allowing the population to contract in ways that better match the evolving structure of the search. The per-function-family analysis reinforced this picture while adding nuance. Different reduction methods excelled on different function families and at different dimensions, with methods such as APDSDE, CS-DE, HARD-DE, DPSHADE, dynNP-DE, AGDE-MPP, and NLPSR variants each topping the rankings in specific configurations.

Crucially, however, the study found no single population size adjustment strategy that consistently dominates across all problem dimensions and function families. This is a recurring theme in evolutionary computation research, and the review confirms it with unusual thoroughness. A method that thrives on multimodal landscapes at moderate dimensionality may falter on composition functions at 100 dimensions. The practical implication for practitioners is clear: the choice of population size strategy should be treated as a problem-dependent design decision, informed by the characteristics of the optimization task at hand, rather than as a one-size-fits-all setting.

Benchmarks alone can be criticized as artificial, so the team also tested the methods on two real-world optimization problems. Here the results were notable: a non-linear population size reduction method achieved the top rank on both real-world problems. Real-world engineering problems often feature irregular landscapes, constraints, and noisy evaluations that synthetic benchmarks only approximate, so this result provides encouraging evidence that the insights from the CEC 2024 experiments carry over to practical applications. For engineers using DE to calibrate models, design components, or optimize industrial processes, the message is that modern non-linear reduction strategies deserve serious consideration.

Why does population size reduction work so well in the first place? The underlying logic involves both search dynamics and computational economics. Each generation, the algorithm evaluates every individual in the population, so the population size directly determines how many function evaluations are consumed per generation. A bloated population late in a run wastes evaluations on near-duplicate candidates that contribute little new information. Conversely, shrinking too aggressively early on can collapse diversity before the algorithm has mapped the landscape, causing it to converge on a local optimum. The art of a good reduction strategy lies in timing: preserving enough diversity long enough to explore, then concentrating resources precisely when refinement matters most. Non-linear schedules attempt to encode this timing more intelligently than a straight line can.

The review arrives at a moment when AI-based optimization is enjoying renewed attention, with scientists, engineers, and practitioners increasingly expected to be fluent in evolutionary computing techniques. By cataloguing 204 studies, subjecting fifteen representative methods to controlled experiments on a modern benchmark suite and real-world problems, and publishing the work open access under a Creative Commons licence, the Maribor group has produced both a reference work and a practical guide. The detailed appendices, including per-dimension performance tables and Friedman rank figures for every function family, give researchers the granular evidence needed to select and design reduction mechanisms. As optimization problems in science and industry continue to grow in scale and complexity, the study’s central lesson stands out: in differential evolution, how you shrink the swarm can matter as much as how you search with it.

Subject of Research: Population size reduction methods in the differential evolution optimization algorithm

Article Title: Population size reduction methods in differential evolution: a comprehensive review and experimental analysis

Article References: Brest, J., Popič, J., Pšeničnik, B., Bošković, B., & Sepesy Maučec, M. (2026). Population size reduction methods in differential evolution: a comprehensive review and experimental analysis. Artificial Intelligence Review. https://doi.org/10.1007/s10462-026-11712-5

Image Credits: AI Generated

DOI: 10.1007/s10462-026-11712-5

Keywords: differential evolution, evolutionary computation, numerical optimization, population size reduction, linear population size reduction, non-linear population size reduction, CEC 2024 benchmark, Friedman test, jSO algorithm, artificial intelligence, real-world optimization, University of Maribor

The core problem the researchers set out to solve is well known to anyone who has trained a multilayer perceptron. There is no analytical formula that tells a designer what the optimal architecture for a given dataset looks like, so practitioners fall back on rules of thumb, trial and error, or exhaustive grid searches. Even once an architecture is fixed, the standard training procedure, backpropagation of errors, relies on gradient descent, which is vulnerable to getting trapped in local minima of the error surface and can converge painfully slowly on difficult problems. These two weaknesses compound each other: a poorly chosen architecture can make the training landscape even harder to navigate, while a bad training run can make a good architecture look useless.

Neuroevolution, the field that applies evolutionary computation to neural network design, has spent more than three decades trying to break this deadlock. Landmark work such as Stanley and Miikkulainen’s NEAT, which evolved network topologies through augmenting them over generations, demonstrated that architectures themselves can be treated as evolvable objects. Since then, a long line of metaheuristics, including genetic algorithms, particle swarm optimization, grey wolf optimizers, whale optimizers, and artificial bee colonies, has been applied to everything from selecting hidden neurons to tuning connection weights. Reviews of this literature, including Ojha, Abraham, and Snášel’s survey of two decades of metaheuristic design of feedforward networks, note a persistent fragmentation: most methods optimize only one or two components of the network, leaving the rest to human judgment or to a separate training algorithm.

NN-IMODE takes aim at that fragmentation. It is built on differential evolution, a population-based optimizer introduced by Storn and Price in 1997 that evolves candidate solutions by generating mutant vectors from weighted differences of existing population members and crossing them with parent solutions. What makes the new approach distinctive is its improved multi-operator structure, drawing on the IMODE framework developed by Karam M. Sallam and colleagues at the 2020 IEEE Congress on Evolutionary Computation. Rather than committing to a single mutation strategy, the algorithm deploys several operators in parallel, each maintaining its own subpopulation, and lets the search process itself determine which operators earn a larger share of the population. This division of labor allows the algorithm to balance broad exploration of the search space against fine-grained exploitation of promising regions, a balance that the authors have studied extensively in their earlier work on metaheuristic behavior.

The technical heart of the method is a novel solution representation. Because NN-IMODE must encode discrete architectural choices, such as the number of hidden layers and the count of neurons in each layer, alongside continuous parameters, such as real-valued weights and biases, and categorical choices, such as which activation function each layer applies, a conventional fixed-length numeric vector will not suffice. The researchers designed an encoding that captures all of these elements within a single evolvable structure, so that a differential evolution operator acting on two candidate networks can blend not only their weights but also their architectural genes. This means that a network with two hidden layers and sigmoid activations can, in effect, breed with a network that has three hidden layers and rectified linear units, producing offspring that inherit and recombine traits from both parents.

Evaluating such a method requires a demanding experimental protocol, and the team put NN-IMODE through one of the more comprehensive benchmarks in this literature. The algorithm was tested on 21 benchmark datasets drawn from the UCI Machine Learning Repository, a standard public collection spanning domains from medical diagnosis to image recognition. The comparison set was formidable: Levenberg-Marquardt, the second-order gradient method that remains a workhorse for small multilayer perceptrons; Scaled Conjugate Gradient, another fast gradient-based trainer; Genetic Algorithms; Differential Evolution in its classic form; and hybrid combinations of these methods. Across this gauntlet, NN-IMODE achieved the highest classification accuracy and the lowest test error rates on 18 of the 21 datasets, a result the authors describe as establishing the method as a transformative approach in neuroevolution.

The significance of beating Levenberg-Marquardt and Scaled Conjugate Gradient deserves unpacking. Gradient-based trainers are extremely efficient when they work, but their performance is hostage to the error surface of the architecture they are given. By searching architectures and parameters jointly, NN-IMODE effectively reshapes the landscape it is searching, discarding architectures whose error surfaces are pathological and concentrating its evolutionary effort on network shapes that train well. The multi-operator mechanism adds a second layer of robustness, because no single mutation rule has to succeed on every dataset; operators that happen to suit a given problem’s structure are automatically amplified. This adaptivity is likely what allows the method to generalize across such a heterogeneous collection of datasets rather than excelling only on problems of one particular type.

The work also arrives at a moment of renewed interest in automated neural network design. Neural architecture search has produced striking results in deep learning, but its most celebrated successes rely on enormous computational budgets that put them out of reach for most laboratories. Metaheuristic approaches such as NN-IMODE occupy a complementary niche: they target feedforward networks of the kind used for tabular classification and regression, where a compact, well-tuned multilayer perceptron can still match or beat far larger models, and where the cost of an evolutionary search is measured in hours rather than weeks. The authors’ broader research program, which includes comparative studies of exploration-exploitation balance, initialization methods, chaos-enhanced metaheuristics, and pruning strategies for convolutional networks, positions this paper as the culmination of a systematic effort to understand how evolutionary search behaves on machine learning design problems.

Several caveats temper the enthusiasm. The benchmark datasets, while diverse, are mostly small to medium in scale, and the computational cost of evaluating a population of candidate networks, each of which must be trained and tested, remains substantial compared with a single gradient descent run. The study also reports no external funding, and the authors declare no competing interests, which speaks to its independence but also to the limits of the experimental scale. Whether the multi-operator machinery retains its advantage on very high-dimensional problems, or on architectures with many more layers than typical feedforward networks, is a question for future work. The authors suggest that the method paves the way for broader applications across artificial intelligence and machine learning, and the generality of the encoding scheme gives that claim some plausibility.

Still, the headline result is hard to dismiss. A single algorithm that decides how deep a network should be, how wide, which nonlinearities its neurons should apply, and what every weight and bias should be, and that does so well enough to outperform established training methods on most of two dozen datasets, is a meaningful step toward neural networks that design themselves. For decades, the separation between architecture design and parameter training has been treated as a natural division of labor between human engineers and learning algorithms. NN-IMODE suggests that the division is not a necessity but a habit, and that evolution, given the right representation and enough operators to work with, can handle the whole job at once. As automated machine learning continues its advance, methods of this kind may become the default way that everyday predictive models are built, with human designers specifying only the goal and the data.

Subject of Research: Simultaneous optimization of feedforward neural network architectures and parameters using an improved multi-operator differential evolution algorithm

Article Title: NN-IMODE: a novel approach for simultaneous optimization of architecture and parameters in feedforward neural networks

Article References: Ferhat, A., Zitouni, F., Sallam, K. M., Harous, S., Lakbichi, R., & Limane, A. (2026). NN-IMODE: a novel approach for simultaneous optimization of architecture and parameters in feedforward neural networks. Cluster Computing, 29(13), Article 756. https://doi.org/10.1007/s10586-026-06551-6

Image Credits: AI Generated

DOI: 10.1007/s10586-026-06551-6

Keywords: feedforward neural networks, differential evolution, neuroevolution, metaheuristics, neural network optimization, evolutionary computation, classification accuracy, multi-operator algorithms, UCI benchmark datasets, automated machine learning, backpropagation, architecture search

The problem the researchers address is known formally as the container relocation problem, a combinatorial optimisation challenge that has occupied operations researchers for decades. In its classic, static form, the setup is a yard bay represented as a grid of stacks and tiers, where a given set of containers sits waiting to be retrieved in a known order. Because the retrieval sequence is fixed and fully known in advance, algorithms can plan the entire sequence of relocations from beginning to end. That assumption, however, is precisely where the static model breaks down in practice. Real container terminals are living systems: new containers arrive continuously while others are being loaded onto vessels, and the exact arrival times of future containers are rarely known with certainty when decisions about the current retrieval must be made.

This messier, more realistic setting is called the dynamic container relocation problem, and it is the focus of the new study. In the dynamic variant, containers enter the bay over time and are retrieved as their departure moments arrive, meaning that a decision about where to place a container today affects how easily it can be retrieved tomorrow, in circumstances that cannot be fully predicted. Traditional optimisation methods, which typically require complete information about the problem instance before they can compute a solution, struggle in this environment. Exact methods and metaheuristics can produce excellent plans when the whole picture is visible, but when information about container arrivals is not known in advance, recomputing an optimised plan after every new arrival becomes computationally prohibitive in the fast-paced setting of a working terminal.

The practical alternative, and the starting point for this research, is a family of fast decision-making procedures known as relocation rules. A relocation rule is a constructive heuristic: rather than planning the entire operation in advance, it makes a good decision on the spot each time the crane needs to move a container. When a blocking container must be relocated, the rule evaluates the available empty slots in the bay and selects one according to some criterion, typically based on properties of the containers themselves, such as their retrieval priorities or expected departure times. Because each decision is made in a fraction of a second, relocation rules can respond immediately to new arrivals and changing conditions, which makes them well suited to the dynamic setting where plans cannot be fixed in advance.

There is a catch, however, and it is the reason the authors turned to automated methods. Relocation rules are highly domain specific. A rule that performs brilliantly on one configuration of stacks, one pattern of arrivals, or one distribution of container priorities may perform poorly on another. Human experts have designed many such rules by hand over the years, each encoding a particular intuition, for example about whether it is better to place a container on top of a box that will leave sooner or later. But designing effective rules manually is difficult and laborious, and there is no guarantee that human intuition captures the subtle statistical structure of the problem. The space of possible rules is vast, and the best-performing rules may combine problem features in ways no designer would think to try.

The study’s answer to this difficulty is genetic programming, an evolutionary computation technique that automatically breeds computer programs toward a desired behaviour. In genetic programming, candidate solutions are represented as tree-structured expressions that combine elementary functions and problem-specific variables, in this case the measurable properties of containers and stacks that a relocation decision can consider. A population of randomly generated rules is evaluated on a set of problem scenarios, the rules that achieve lower relocation counts are selected as parents, and new rules are created by mixing and mutating the expressions of successful individuals. Over many generations, this Darwinian process sculpts decision logic that no human wrote by hand, tailored precisely to the objective of minimising the number of relocations needed to clear the retrieval demands of the bay.

What makes this application particularly compelling is that the evolved rules are not black-box neural networks requiring specialised hardware. A genetic programming rule is a symbolic expression, readable in principle and executable in microseconds, which means it can be embedded directly into terminal operating software and consulted every time a crane must choose a slot for a relocated container. The rule effectively becomes a piece of distilled expertise, discovered by the evolutionary process rather than by a human analyst, and expressed in the same mathematical vocabulary that human-designed heuristics use. This transparency matters in industrial settings, where operators and software engineers need to understand and trust the logic that guides million-dollar equipment.

To find out whether machine-bred rules genuinely beat human craftsmanship, the researchers put their automatically generated relocation rules through a demanding trial. The evolved rules were compared against several manually designed relocation rules drawn from the literature, across a wide range of dynamic problem scenarios covering different bay sizes, stack configurations, and patterns of container arrivals and retrievals. The evaluation was therefore not a single head-to-head contest but a broad stress test designed to reveal whether the advantage of automated design holds generally or only under favourable conditions. The outcome was unambiguous: the automatically generated rules significantly outperformed their manually designed counterparts across the tested scenarios, demonstrating that the evolutionary approach consistently discovers decision logic superior to the accumulated intuition of human heuristic designers.

The significance of this result extends beyond the container yard. The dynamic container relocation problem is a representative example of a broad class of real-time scheduling and routing challenges in which decisions must be made under uncertainty, from vehicle dispatching to machine scheduling on factory floors. The study’s central lesson is that when the problem environment is too dynamic for full optimisation and too intricate for hand-crafted heuristics, automated heuristic design offers a third path: algorithms that manufacture fast, effective decision rules on demand, matched to the statistical texture of the specific operational environment. As global trade volumes continue to grow and terminals face relentless pressure to turn vessels around faster, the ability to automatically generate and refresh such rules could become a standard tool in the logistics engineer’s kit.

The work, published open access on 28 August 2026 and supported by funding from the Croatian Science Foundation, the European Union’s NextGenerationEU framework, the Spanish Government, and the Principality of Asturias, also highlights a quiet shift in how optimisation research is done. Rather than asking researchers to design better heuristics one at a time, the field is increasingly asking machines to explore the design space themselves, with humans defining the objective and the ingredients. In the case of the dynamic container relocation problem, that shift has already paid off with rules that move fewer containers, waste less crane time, and adapt gracefully to a world in which the next arrival is never certain. For an industry that moves the physical backbone of the global economy, even small percentage improvements in yard efficiency translate into enormous savings, and this study shows that evolution, simulated in software, can out-design the experts who built the field.

Subject of Research: Automated design of relocation rules using genetic programming for the dynamic container relocation problem

Article Title: Automated design of relocation rules for the dynamic container relocation problem

Article References: Automated design of relocation rules for the dynamic container relocation problem. (n.d.). https://doi.org/10.1007/s40747-026-02467-1

Image Credits: AI Generated

DOI: 10.1007/s40747-026-02467-1

Keywords: genetic programming, container relocation problem, dynamic container relocation problem, relocation rules, combinatorial optimisation, heuristics, container terminals, evolutionary computation, port logistics, automated heuristic design, operations research, artificial intelligence

The research, led by Huatian Gong of Nanyang Technological University together with Shuaian Wang, Dongping Song, Jiuh-Biing Sheu and Ran Yan, begins from an observation that will resonate with anyone who has tried to use an AI assistant for serious programming. If you simply ask a large language model to produce a complete heuristic for a combinatorial optimization problem in a single pass, the result usually fails. The model may misunderstand the input format, mishandle edge cases, or produce code that cannot run at all. The failure is not primarily a shortage of intelligence but a shortage of structure: the model is being asked to solve the mathematical problem and the software engineering problem simultaneously, with no verified contract separating the two.

The team’s answer is a framework called LACE, short for LLM-driven Algorithm Construction via Complementary Evolution. Its first ingredient is what the authors call the I-O-T-H interface, a formal problem contract with four components: an input schema, an output schema, a tool library, and a heuristic portfolio. The input and output schemas pin down exactly what data the heuristic receives and what it must return, eliminating an entire class of implementation errors. The tool library supplies verified building blocks, common routines such as evaluation functions and local search moves, so the model does not have to reinvent and re-verify basic machinery every time. The heuristic portfolio, finally, is the heart of the system: rather than betting everything on one algorithm, LACE maintains a collection of specialist heuristics, each of which may excel on a different subset of problem instances. With this contract in place, the language model’s capacity is redirected away from low-level plumbing and toward the high-level algorithmic reasoning where it genuinely adds value.

The second ingredient is the evolutionary engine. Under a strict runtime budget for each problem instance, LACE iteratively generates candidate heuristics, tests them, and selects a portfolio of specialists whose strengths cover heterogeneous cases. The word complementary is doing real work here. A single heuristic that performs well on average can be worse than a team of heuristics that each dominate on particular instance types, provided the system can decide which specialist to deploy. LACE’s complementary selection mechanism explicitly optimizes for coverage of the instance distribution rather than for a single champion, an approach that echoes the hyper-heuristics tradition in operations research but replaces human-designed selection rules with an automated, model-driven search. The framework uses four designer agents in its first stage and seven evolution operators in its second, all of which the authors have released openly.

The evaluation is unusually thorough. The researchers tested LACE on 36 classical problems drawn from CO-Bench, a benchmark suite designed to measure how well language model agents can search for algorithms on combinatorial optimization tasks. These problems span the canonical territory of the field, including routing, scheduling, packing and assignment variants that have accumulated decades of human algorithmic effort. On this suite, LACE achieved an average score of 0.945. The strongest existing LLM-based method reached 0.870, while direct prompting of a language model without any supporting framework managed only 0.571. The gap between the framework and bare prompting is the study’s central message: the gain comes from the architecture, not from a smarter model. The same underlying language model, given the right scaffolding, performs dramatically better than the same model asked to improvise.

Even more striking is the result on generalization. The team constructed four structurally new optimization problems that the models had never seen during development, the kind of novel variants that arise constantly in industry when a business’s constraints do not match any textbook problem. On these four problems, LACE reached scores between 0.97 and 0.99, while five existing LLM-based baselines failed to produce any feasible algorithm at all. This is the difference between a system that has memorized solutions to famous problems and one that can genuinely engineer an algorithm for an unfamiliar contract. For logistics and manufacturing, where bespoke constraints are the norm rather than the exception, that distinction is the whole ballgame.

The authors also examined robustness across different frontier language model backbones and found that LACE’s performance holds, with varying cost-efficiency trade-offs depending on which model powers the framework. This matters because it suggests the contribution is durable: as models improve or change, the interface-and-evolution architecture should continue to extract value from whatever model sits underneath. The ablation studies reinforce the point that both major components are essential. Removing the tool library degrades performance, and so does removing the complementary portfolio, confirming that verified building blocks and specialist diversity contribute independently to the framework’s success.

The transparency of the project is itself noteworthy. All code, including the designer agents, the evolution operators, the complementary-selection solver and the scripts reproducing every figure, is available under an MIT licence on GitHub and Zenodo, along with the instance sets for all 40 problems, the evolved heuristic portfolios and the per-instance results. A Colab notebook allows anyone to reproduce the reported results without local installation, and an interactive supplementary webpage presents all per-instance outcomes. In a field where claims of automated scientific discovery sometimes rest on opaque pipelines, this level of openness invites scrutiny and reuse in equal measure. The work was supported by Singapore’s Agency for Science, Technology and Research, the Japan Science and Technology Agency, the Ministry of Education of Singapore and the UK Engineering and Physical Sciences Research Council.

The broader significance extends beyond the benchmark numbers. Algorithm design has long been a bottleneck at the intersection of operations research, computer science and industry: the mathematics of a problem may be well understood, yet translating that understanding into a fast, reliable solver remains skilled manual labor. The LACE results indicate that a well-structured division of labor between human-designed contracts and machine-generated heuristics can compress that labor dramatically. The verified interface acts as the human contribution, encoding what a correct solution looks like, while the evolutionary search acts as the machine contribution, exploring the space of algorithmic strategies far faster than a human team could. It is a template that seems likely to spread to neighboring domains, from constraint programming to simulation optimization, wherever a problem can be specified precisely enough to form a contract.

There are, of course, caveats worth keeping in view. The benchmark scores measure performance within defined runtime budgets on defined instance distributions, and real-world deployments will bring messier data, shifting constraints and integration challenges that no offline benchmark fully captures. The framework still depends on capable language models, with all their costs and failure modes, and the complementary selection adds computational overhead of its own. Yet the direction of travel is clear and the evidence is strong. What the study demonstrates is that the discovery of effective algorithms for hard combinatorial problems, long considered a craft reserved for a small community of experts, can be automated to a substantial degree. If the pattern holds as models and frameworks improve, the heuristics quietly running the world’s supply chains, hospitals and grids may increasingly be designed not by a lone expert over months, but by an evolving portfolio of machine-discovered specialists in days.

Subject of Research: Automated design of complementary heuristics for combinatorial optimization using large language models

Article Title: Large language models discover complementary heuristics for combinatorial optimization

Article References: Gong, H., Wang, S., Song, D., Sheu, J.-B., & Yan, R. (2026). Large language models discover complementary heuristics for combinatorial optimization. Nature Machine Intelligence. https://doi.org/10.1038/s42256-026-01307-8

Image Credits: AI Generated

DOI: 10.1038/s42256-026-01307-8

Keywords: large language models, combinatorial optimization, heuristics, algorithm design, LACE framework, CO-Bench, evolutionary computation, hyper-heuristics, Nature Machine Intelligence, automated scientific discovery, operations research, artificial intelligence

The class of problems in question, multimodal multi-objective optimization problems, or MMOPs, are widely regarded as one of the toughest tests for evolutionary algorithms. The difficulty is twofold. First, the optimizer must approximate the Pareto front in objective space, balancing competing goals. Second, it must simultaneously locate and preserve multiple equivalent Pareto-optimal subsets in decision space—distinct sets of design variables that deliver the same quality of trade-offs. An algorithm that collapses onto just one of these regions may find a perfectly good solution while missing an entire family of alternatives that could be more practical, cheaper to manufacture, or easier to implement in a given context.

The dominant strategy for preserving this diversity is niching, a family of techniques borrowed from evolutionary computation in which the population is deliberately divided into subpopulations, each encouraged to explore a different region of the search space. Classic approaches include fitness sharing, crowding, speciation, and clustering-based division. The catch, as the authors note, is that nearly all of these methods depend on a niching parameter—typically a radius, a neighborhood size, or a number of clusters—that determines how aggressively the population is split. Set the parameter too small and the algorithm fragments into tiny groups that converge slowly; set it too large and distinct optima merge, causing whole solution families to be lost. Because the right value varies from problem to problem and is unknown in advance, practitioners have long faced an awkward trial-and-error process.

Li, Guan, and Peng’s answer is a multi-objective particle swarm optimizer built around what they call parameter-free automatic clustering, abbreviated AC-MOPSO. Particle swarm optimization, first introduced by Eberhart and Kennedy in 1995, simulates a flock of candidate solutions—particles—that fly through the search space, each pulled toward its own best-found position and toward the best position discovered by its neighbors. The method is fast and simple, but in multimodal terrain a naive swarm tends to stampede toward whichever optimum it encounters first. The new algorithm counters this by partitioning the swarm into multiple subpopulations directly in decision space, so that each cluster can search in parallel around a different candidate region and track a different set of Pareto-optimal solutions.

The crucial innovation lies in how the clusters are formed. Rather than asking the user to specify a radius or a cluster count, the algorithm derives its structure from the data itself, drawing on ideas from parameter-free clustering research—most notably the first-neighbor-relations approach introduced by Sarfraz, Sharma, and Stiefelhagen at the 2019 IEEE Conference on Computer Vision and Pattern Recognition. In that framework, similarity relations between nearest neighbors are used to decide which points belong together, eliminating the need for a distance threshold. Transplanted into the optimization setting, this means the swarm continuously reorganizes itself: as particles move and the geometry of the population shifts, the clustering adapts automatically, forming subpopulations where the data supports them and dissolving them when they are no longer warranted.

Once the subpopulations are established, each one operates as a semi-independent search unit. Particles within a cluster share information about promising regions, guiding one another toward the local Pareto set in their vicinity, while the overall population maintains coverage across the decision space. This division of labor is what allows the optimizer to hold on to equivalent Pareto subsets that a monolithic swarm would abandon. The design echoes earlier parameter-free ideas in the niching literature, such as Li’s ring-topology particle swarm, which replaced niching radii with a fixed social network, and Zhang and colleagues’ parameter-free Voronoi neighborhoods; AC-MOPSO extends this line of work into the multi-objective setting, where the interplay between decision-space diversity and objective-space convergence is considerably more delicate.

To test the approach, the authors ran a comparative evaluation against five advanced multi-objective optimizers on 14 benchmark functions designed for multimodal multi-objective optimization. These test suites are constructed so that the locations and number of Pareto-optimal subsets are known, allowing researchers to measure not just how well an algorithm converges but how completely it captures the full set of alternative solutions. The results, according to the study, show AC-MOPSO solving the benchmark problems effectively and outperforming the compared optimizers overall, with the advantage growing most pronounced on the higher-complexity benchmark functions—precisely the cases where the number and shape of optimal regions make hand-tuned niching parameters hardest to choose.

The authors also validated the optimizer on a real-world application example, moving beyond synthetic benchmarks to demonstrate that the parameter-free design holds up under practical conditions. This matters because the burden of parameter tuning is not merely an academic inconvenience. In industrial deployment, every tunable knob is a source of cost and risk: engineers must run repeated trials, and a parameter chosen for one problem may fail badly on the next. An optimizer that adapts its own population structure lowers the barrier to applying evolutionary search in domains where expertise in metaheuristics cannot be assumed, from agricultural system design—fitting, perhaps, for a team based at an agricultural sciences academy—to scheduling, logistics, and engineering trade-off studies.

The work was supported by the National Natural Science Foundation of China under grant 62173072, and it situates itself within a vibrant research conversation. Recent years have seen a wave of MMOP-specific methods: differential evolution variants with dynamic neighbor strategies and multi-operator adaptation, dual-population co-evolution schemes for constrained cases, fine-grained crowding distances with dual-space selection, and cluster-based particle swarms with ring topologies and leader-updating mechanisms. A 2026 survey in the European Journal of Operational Research by Ehrgott and colleagues traces fifty years of multi-objective optimization, from mathematical programming to today’s evolutionary computation, underscoring how the field’s center of gravity has shifted toward algorithms that manage diversity in both decision and objective spaces at once.

What distinguishes AC-MOPSO in this crowded landscape is its refusal to outsource the hardest decision to the user. By letting an automatic, data-driven clustering mechanism handle subpopulation formation, the algorithm removes the single most consequential—and most fragile—setting in niching-based optimizers. The study’s benchmarks suggest that this removal does not come at the price of performance; instead, the adaptive structure appears to give the swarm a better chance of covering complex, multi-peaked landscapes than fixed-parameter rivals. For a field where benchmark victories often hinge on careful per-problem calibration, a competitive parameter-free method is a meaningful step toward optimizers that work out of the box. As multimodal multi-objective problems move from test suites into real engineering pipelines, algorithms that tune themselves may prove to be the ones that actually get used.

Subject of Research: A parameter-free automatic clustering multi-objective particle swarm optimizer for multimodal multi-objective optimization

Article Title: A parameter-free automatic clustering based multi-objective particle swarm optimizer for multimodal multi-objective problems

Article References: Li, X., Guan, S., & Peng, X. (2026). A parameter-free automatic clustering based multi-objective particle swarm optimizer for multimodal multi-objective problems. Cluster Computing, 29(14), Article 788. https://doi.org/10.1007/s10586-026-06607-7

Image Credits: AI Generated

DOI: 10.1007/s10586-026-06607-7

Keywords: multimodal multi-objective optimization, particle swarm optimization, parameter-free clustering, niching, Pareto optimality, evolutionary computation, subpopulation division, benchmark functions, metaheuristics, Cluster Computing, parameter-free, automatic

The field of evolutionary multitasking grew out of the recognition that many real-world optimization tasks are interrelated. Rather than running a separate evolutionary algorithm for every problem, multitasking algorithms solve several tasks simultaneously within a single framework, allowing candidate solutions to migrate between task-specific populations. When the tasks are similar, this exchange can dramatically accelerate convergence, because a solution that performs well on one problem may already be halfway to a good solution on another. The foundational work on multifactorial evolution by Gupta, Ong, and Feng in 2016 demonstrated the promise of this approach, and a growing body of research has since refined how knowledge moves between tasks.

The catch is negative transfer. When two tasks differ substantially in the structure of their search spaces or the shape of their objective functions, blindly importing solutions from a source task can pull a target population away from its own promising regions. The result is wasted computational effort and, in the worst cases, worse final solutions than a task would achieve on its own. Researchers have proposed a variety of remedies, from adaptive transfer probabilities based on population distribution statistics to explicit mapping techniques that translate solutions between task domains. The new algorithm, called MOMFEA-MTL, combines two complementary mechanisms to attack the problem from both directions: deciding when to transfer, and deciding how to transfer.

The first mechanism is an adaptive knowledge transfer strategy that continuously monitors the historical evolution of each population. Instead of fixing the probability that a solution crosses from one task to another, the algorithm adjusts that probability dynamically based on how well past transfers have served the target task. If incoming solutions have recently improved the target population’s performance, the transfer probability rises; if they have degraded it, the probability falls. This feedback loop suppresses negative transfer without requiring any prior knowledge of how similar the tasks are, which is precisely the information that is hardest to obtain in practical settings where the geometry of the search landscape is unknown.

The second mechanism tackles the question of how solutions should be transformed when they do cross between tasks. Naive approaches simply copy decision variables from one task’s representation to another, an operation that only makes sense when the tasks share a common search space structure. MOMFEA-MTL instead constructs a mapping matrix using a manifold transfer method, an approach rooted in the observation that high-dimensional data often lie on or near a low-dimensional manifold. By learning a transformation that preserves the intrinsic geometric structure of the source population while aligning it with the target task’s distribution, the algorithm can move solutions across task boundaries in a way that respects the underlying shape of each problem’s search space.

Selecting which solutions deserve the cost of this transformation is handled by a K-means solution selection strategy. Clustering the population into groups and choosing representative solutions from those clusters ensures that the transferred knowledge captures the diversity of the source task rather than a narrow sample of its best-performing region. This matters because multi-objective optimization does not seek a single best solution but an entire Pareto front of trade-off solutions, and preserving spread across the front is as important as pushing toward it. Once selected, the solutions are mapped from the source task to the target task, where they join the target population and accelerate its evolution.

The combination is designed for multi-objective multitasking problems, where each task involves optimizing several conflicting objectives simultaneously. This setting compounds the difficulty of knowledge transfer: not only must solutions be useful, but the distribution of trade-offs must also remain balanced. The authors position their approach within the broader lineage of multiobjective multifactorial optimization, building on the original MO-MFEA framework and its successors such as MO-MFEA-II, which introduced cognizant multitasking, and on explicit transfer methods like those based on autoencoding and transfer component analysis. Manifold transfer learning itself has precedent in dynamic multiobjective optimization, where it was used to predict how Pareto sets shift as problems change over time; the new work adapts the idea to the multitasking setting, where the shift is between tasks rather than between time steps.

To evaluate the method, the team ran experiments on nine classical multi-objective multitasking test functions, comparing MOMFEA-MTL against established baselines from the literature. The results showed that the proposed algorithm achieved competitive performance across the benchmark suite, with the adaptive transfer strategy and manifold-based mapping working together to deliver gains where task relatedness could be exploited while limiting damage where it could not. The authors report that the algorithm demonstrates good competitiveness on the test problems, supporting the central claim that combining adaptive transfer control with structure-preserving mapping is an effective recipe for multitasking optimization.

The practical implications extend beyond benchmarks. Evolutionary multitasking has already been applied to problems such as vehicle routing with occasional drivers, sparse reconstruction, multi-task learning for modular learning machines, and, notably by members of the same group, the optimization of steel rolling schedules in industrial production. In each of these domains, multiple related optimization problems arise naturally, and the cost of solving them one at a time is substantial. An algorithm that can reliably harvest the similarities between tasks while shielding itself from their differences could translate into measurable savings in computation time and solution quality, particularly for expensive simulations where each function evaluation carries real cost.

The research also contributes to a conceptual shift in how the field thinks about transfer itself. Early multitasking algorithms treated knowledge transfer as a fixed structural feature, with a constant probability of inter-task mating or a static mapping between search spaces. The trend, exemplified by self-regulated multitasking, adaptive transfer based on population distributions, and transfer rank methods, is toward algorithms that learn from their own experience which transfers help. MOMFEA-MTL fits squarely in this tradition, adding the geometric perspective of manifold learning to the toolkit. As optimization problems in industry and science grow larger and more entangled, the ability to solve many tasks at once, safely and efficiently, may prove to be one of evolutionary computation’s most valuable exports, and this work offers a carefully engineered step in that direction.

Subject of Research: A multi-objective multitasking evolutionary optimization algorithm using adaptive knowledge transfer and manifold transfer learning to mitigate negative transfer.

Article Title: Multi-objective multitasking optimization based on manifold transfer learning

Article References: Zhang, K., Cheng, Y., Wang, S., Sun, H., Wei, L., & Hu, Z. (2026). Multi-objective multitasking optimization based on manifold transfer learning. International Journal of Machine Learning and Cybernetics, 17(9), Article 458. https://doi.org/10.1007/s13042-026-03300-4

Image Credits: AI Generated

DOI: 10.1007/s13042-026-03300-4

Keywords: evolutionary computation, multitasking optimization, multi-objective optimization, knowledge transfer, manifold learning, negative transfer, Pareto front, K-means clustering, evolutionary algorithms, transfer learning, optimization algorithms, machine learning

The method, called Deep-Sea Anglerfish Symbiosis Optimization, or DASO, was developed by Xinpeng Xu of The University of Newcastle in Australia and published in the journal Complex & Intelligent Systems. It belongs to the family of metaheuristics, the class of algorithms that underpin modern swarm intelligence. These are computational techniques that take their cues from nature, from bird flocks and fish schools to ant foraging trails and, increasingly, from less obvious biological phenomena. Rather than exhaustively searching every possible solution, metaheuristics deploy a population of candidate solutions that explore a problem space iteratively, guided by rules that balance finding entirely new regions against refining the best solutions already discovered.

The central challenge DASO was designed to tackle is a familiar one in optimization research: premature convergence and loss of population diversity. When an optimization algorithm confronts a high-dimensional, non-convex landscape, a mathematical terrain riddled with many local optima, deceptive basins of attraction, and sharp ridges, it can easily become trapped in a suboptimal region early in the search. Once the population clusters in the wrong place, the algorithm loses the diversity it needs to escape, and the search stalls. Classical remedies, such as increasing population size or injecting random mutations, help but often at the cost of slow convergence or unstable performance across different problem types.

Xu’s approach departs from most existing swarm intelligence methods by abandoning the assumption that every individual in the population should behave the same way. In the anglerfish metaphor, male and female agents occupy differentiated search roles, a concept the author describes as functional dimorphism. Female agents, modeled on the larger and more mobile fish, are primarily responsible for global exploration, probing broad regions of the search space for promising areas. Male agents, reflecting their smaller size and their dependence on locating and attaching to a female, are geared toward local refinement, intensifying the search around the most promising solutions found so far. This division of labor means exploration and exploitation are handled by distinct subpopulations with distinct movement rules, rather than by a single set of dynamics applied to everyone.

The framework integrates several further mechanisms inspired by anglerfish biology. Asymmetrical attachment governs how male agents bind themselves to high-quality solutions discovered by female agents, but in a way that is deliberately not uniform across the population, helping to preserve diversity in how the search intensifies. Local field-guided movement allows agents to exploit information from their immediate neighborhood, in the spirit of the luminous lure that attracts partners in the dark, steering nearby candidates toward promising regions without requiring global knowledge of the entire landscape. Nonlinear high-pressure adaptation serves as a scheduling mechanism, dynamically tuning the balance between exploration and exploitation as the search progresses, echoing the way organisms must adapt their behavior under the extreme pressure of the deep sea. Together, these components coordinate a heterogeneous, role-structured search in which global discovery and local polishing reinforce each other rather than compete.

To evaluate the algorithm, Xu ran an extensive experimental campaign using two widely respected benchmark suites: CEC2017 and CEC2022, competition benchmark sets drawn up by the IEEE Congress on Evolutionary Computation that are standard yardsticks for metaheuristic research. These suites contain functions specifically engineered to challenge different aspects of an optimizer, including unimodal problems with a single basin, multimodal problems dense with local optima, hybrid functions that combine different characteristics within one landscape, and composite functions that rotate and shift the terrain to defeat algorithms tuned to coordinate systems. DASO was tested in 10-, 30-, and 50-dimensional settings, with 30 independent runs conducted for every configuration. Repeating each experiment 30 times matters because metaheuristics are stochastic: their performance varies from run to run depending on random initial conditions, and robust conclusions require measuring that variability rather than relying on a single lucky trial.

The results showed that DASO achieved competitive performance in solution quality, convergence behavior, and robustness when compared with representative metaheuristic algorithms from the literature. In practical terms, competitive performance across both benchmark suites and all three dimensionalities indicates that the algorithm is not a specialist tuned to a narrow class of problems, but a general-purpose optimizer that adapts well as problem difficulty and dimensionality increase. Convergence behavior, meaning how quickly the best solution improves over the course of the run and whether the improvement curve plateaus at a high-quality value, was a particular strength associated with the role-structured division of labor, since male agents can intensify around female discoveries without dragging the entire population away from unexplored regions.

A crucial element of the evaluation was the statistical treatment of the results. Because stochastic algorithms produce different outcomes on every run, comparing a single set of figures can be misleading. Xu therefore applied the Wilcoxon rank-sum test, a non-parametric statistical test that determines whether the distribution of results from two algorithms differs significantly, at the 0.05 significance level. This analysis confirmed the consistency of DASO’s performance relative to its competitors, providing a rigorous basis for the claim that the observed advantages are genuine rather than artifacts of random variation.

Beyond abstract benchmarks, the study tested DASO on constrained engineering design problems, where algorithms must satisfy real-world requirements such as stress limits, material constraints, and manufacturing tolerances while minimizing cost or weight. Constrained problems are notoriously difficult because the optimal solutions often lie exactly on the boundary of feasibility, forcing the algorithm to walk a tightrope between improving the objective and violating a constraint. Strong performance in this arena is the most meaningful evidence that a new metaheuristic can translate into practical value, and DASO’s results there support the author’s broader thesis: that heterogeneous, role-structured populations are a promising design principle for complex optimization.

The significance of the work lies in its design philosophy as much as its benchmark numbers. The overwhelming majority of swarm intelligence algorithms, from particle swarm optimization to artificial bee colony methods, model a homogeneous population in which every agent follows the same behavioral rules, and diversity is maintained only through mechanisms like random perturbation. DASO demonstrates that explicitly assigning different roles to different agents, drawing on biological dimorphism as a template, can be an effective structural answer to the exploration-exploitation dilemma at the heart of all stochastic optimization. The deep-sea anglerfish turns out to be more than a curiosity of natural history: its radical cooperation between unlike partners offers a blueprint for coordinating unlike searchers in computational landscapes.

As engineering systems grow more complex, from aerodynamic shapes and structural frameworks to neural architectures and supply chains, the demand for robust, general-purpose optimizers continues to rise. DASO adds a biologically grounded and statistically validated entry to that toolbox, suggesting that the strangest corners of the natural world still hold unexploited lessons for computer science. The paper is open access, allowing researchers worldwide to examine, replicate, and build upon the approach, and future work will likely explore how role-structured populations scale to even higher dimensions and to dynamic, changing problem environments.