Task planning method and device based on parallel transfer mechanism, and electronic equipment

Abstract

The invention discloses a multi-objective optimization method, and particularly relates to a task planning method and device based on a parallel transfer mechanism and electronic equipment. The method comprises the steps that a task platform sends a received planning task to a plurality of parallel unmanned aerial vehicles for optimization calculation; each unmanned aerial vehicle performs optimization calculation through a transformation learning mechanism to obtain a first-generation memory population and sends the first-generation memory population to the task platform; multiple population iterations are executed, a target memory population is obtained, and the target memory population is used for representing a solution of the planning task. According to the method provided by the embodiment of the invention, the time consumed for solving and calculating the planning task can be shortened, and the real-time performance of unmanned cluster task planning is improved.

Description

Technical Field

[0001] The present invention relates to a multi-objective optimization method, and specifically to a task planning method, device and electronic equipment based on a parallel reincarnation mechanism. Background Art

[0002] Unmanned swarm mission planning often involves more than one optimization objective, often conflicting with each other. Such problems are generally defined as multi-objective optimization problems (MOPs). To address these problems, many classic multi-objective evolutionary algorithms (MOEAs) have been proposed, such as the Non-dominated Sorting Genetic Algorithms-II (NSGA-II), the Non-dominated Sorting Genetic Algorithms-III (NSGA-III), and the Reference Vector Guided Evolutionary Algorithm (RVEA).

[0003] In many practical applications, such as autonomous mission planning for unmanned swarms, the objective function of a multi-objective optimization problem (MOP) is often very time-consuming. These MOPs are called computationally expensive multi-objective optimization problems (CEMOPs). Due to the long computation time of the objective function, it is impractical to perform large-scale iterations of the MOEA. For example, a computational fluid dynamics optimization problem requires 2 to 3.5 hours to calculate a single fitness evaluation. Therefore, after 300 generations of evolutionary optimization, it takes about 6 weeks to obtain a converged result.

[0004] Because optimization algorithms' computational tasks have a well-developed parallel framework, multi-population evolutionary algorithms can be combined with parallel computing, significantly accelerating iterative convergence. Furthermore, multi-population algorithms introduce multiple populations to optimize the search, connecting them using a strategy and ultimately selecting candidate solutions. During autonomous task planning for unmanned swarms, after receiving a task, the task platform itself takes too long to perform its own calculations due to its limited computing power.

[0005] First, for scenarios like disaster relief and material delivery, shorter computation times translate to higher efficiency and greater mission effectiveness. Using drones for parallel computing can significantly shorten planning time. Second, when unmanned swarms execute missions, drones are limited to identifying locations and controlling their flight, which is a waste of computing power for drones with ample computing power. Finally, using drones for computing allows them to promptly identify real-time tasks, make adjustments, and send them to the task platform and other drones for further computation. Using the task platform alone for computation is incapable of adjusting to sudden, real-time tasks.

[0006] Based on the above reasons, in current specific applications, after receiving a task, the task platform will assign the received computing task to the drone for parallel computing, and the task platform will determine the final optimized solution from the candidate solutions calculated by multiple drones through a certain strategy.

[0007] These algorithms iterate and update the population to identify a set of feasible Pareto solutions. During each iteration, the fitness function is recalculated, and the population is updated through selection and modification operations. Over multiple rounds of iteration, the population gradually converges to a candidate solution.

[0008] Autonomous mission planning for unmanned swarms typically requires extensive pre-calculation and allocation to adapt to dynamic and complex environments. However, current planning tasks are computationally expensive, resulting in poor real-time performance and difficulty adapting to the dynamic and complex environments in which unmanned swarms operate. Summary of the Invention

[0009] The technical problem to be solved by the present invention is that the current calculation and solution of planning tasks takes a long time, resulting in poor real-time performance of unmanned cluster task planning. In order to solve the above problem, the present invention provides a task planning method, device and electronic equipment based on a parallel reincarnation mechanism.

[0010] The content of the present invention includes:

[0011] In a first aspect, an embodiment of the present invention provides a task planning method based on a parallel reincarnation mechanism, comprising:

[0012] The task platform sends the received planning tasks to multiple parallel UAVs for optimization calculation;

[0013] Each of the drones performs optimization calculations through a reincarnation learning mechanism to obtain a first-generation memory population and sends it to the mission platform;

[0014] Performing multiple population iterations to obtain a target memory population, wherein the target memory population is used to represent a solution to the planning task;

[0015] The execution of the i-th population iteration includes:

[0016] The task platform performs population merging on the i-th generation memory populations of the multiple parallel drones received to obtain a merged i-th generation memory population, where i is a positive integer;

[0017] The task platform performs population selection on the merged i-th generation memory population to obtain a screened i-th generation memory population;

[0018] The task platform determines whether the filtered i-th generation memory population meets the convergence condition;

[0019] If the filtered i-generation memory population meets the convergence condition, the i-generation memory population is determined as the target memory population; if the filtered i-generation memory population does not meet the convergence condition, the task platform performs population segmentation on the filtered i-generation memory population, and sends the multiple i-generation sub-memory populations obtained by segmentation to the multiple parallel drones;

[0020] Each of the drones optimizes the received i-th generation sub-memory population through a reincarnation learning mechanism to obtain an i+1-th generation memory population and sends it to the mission platform.

[0021] Optionally, the memory population includes multiple memory genes, and the memory genes include decision variable bits, fitness and flag bits, and the flag bits are used to determine whether the fitness needs to be recalculated. The fitness and flag bits of the i-th generation memory population are used to be integrated into the memory genes of the i+1-th generation memory population.

[0022] Optionally, the fitness function used to calculate the fitness satisfies:

[0023]

[0024] Among them, F MG Used to characterize the fitness of the memory gene, flag MG The marker used to characterize the memory gene, X MG The decision variable used to characterize the memory gene, the initial value of the flag bit is 0, and when there is crossover or mutation between memory genes, the flag bit of the memory gene is changed to 1.

[0025] Optionally, each of the drones optimizes the received i-th generation sub-memory population through a reincarnation learning mechanism to obtain an i+1-th generation memory population and sends it to the task platform, including:

[0026] Each of the drones performs race iterative calculation on the i-th generation sub-memory population through a reincarnation learning mechanism;

[0027] Changing the flag of the memory gene that has undergone crossover and mutation to 1 to obtain the i+1 generation memory population;

[0028] The i+1 generation memory population is sent to the task platform.

[0029] Optionally, the number of the drones is n, where n is an integer greater than 1. The task platform performs population segmentation on the screened i-th generation memory population and sends the multiple i-th generation sub-memory populations obtained by segmentation to the multiple parallel drones, including:

[0030] After the task platform sends the memory genes that have undergone crossover or mutation in the i-th population iteration to each drone in turn, it randomly sends the memory genes that have not undergone crossover or mutation to each drone.

[0031] Optionally, the task platform determines whether the filtered i-th generation memory population meets the convergence condition, including:

[0032] The task platform determines whether the filtered i-th generation memory population meets the convergence condition based on the modified formula of the Cauchy criterion formula, and the modified formula of the Cauchy criterion formula satisfies:

[0033] max HVSet n -min HVSet n <ε,n∈N,n>I,

[0034] HVSet n ={HV(S n-I ),HV(S n-I+1 ),...,HV(S n )},

[0035] Among them, HVSet n Represents a sequence containing a series of hypervolume values, maxHVSet n Represents HVSet n The maximum value of HVSet, I is a constant, indicating n A fixed interval of , ε is a small constant;

[0036] The HV value is calculated as follows:

[0037]

[0038] Wherein, Leb(S) represents the Lebesgue measure of the solution set S, which is used to characterize the i-th generation memory population after the screening, Ref=(r1,r2,...,r m )∈Π is the reference point, [f1(X),r1]×[f2(X),r2]×...×[fm (X),r m ] represents a hypercube surrounded by all points dominated by X, but not by the reference point Ref, where X is a sequence, X n Represents the i-th element in the sequence X, satisfying N is the number of iterations after convergence.

[0039] In a second aspect, an embodiment of the present invention provides a task planning device based on a parallel reincarnation mechanism, comprising:

[0040] The processing module is used by the task platform to send the received planning tasks to multiple parallel UAVs for optimization calculation;

[0041] A computing module, configured to perform optimization calculations on each of the UAVs through a reincarnation learning mechanism, obtain a first-generation memory population, and send the population to the mission platform;

[0042] An execution module, configured to execute multiple population iterations to obtain a target memory population, wherein the target memory population is used to represent a solution to the planning task;

[0043] The execution module includes:

[0044] a population merging unit, configured for the task platform to merge the i-th generation memory populations received from the plurality of parallel UAVs to obtain a merged i-th generation memory population, where i is a positive integer;

[0045] A population selection unit, configured for the task platform to perform population selection on the merged i-th generation memory population to obtain a screened i-th generation memory population;

[0046] A judgment unit, configured for the task platform to judge whether the filtered i-th generation memory population meets the convergence condition;

[0047] a processing unit configured to, if the filtered i-th generation memory population satisfies a convergence condition, determine the i-th generation memory population as the target memory population; if the filtered i-th generation memory population does not satisfy the convergence condition, cause the task platform to perform population segmentation on the filtered i-th generation memory population and send the multiple i-th generation sub-memory populations obtained by segmentation to the multiple parallel UAVs;

[0048] The optimization unit is used for each of the drones to optimize the received i-th generation sub-memory population through a reincarnation learning mechanism to obtain the i+1-th generation memory population and send it to the task platform.

[0049] In a third aspect, an embodiment of the present invention provides an electronic device comprising: a memory, a processor, and a program stored in the memory and executable on the processor; the processor is configured to read the program in the memory to implement the steps of the task planning method based on the parallel reincarnation mechanism as described in the first aspect.

[0050] In a fourth aspect, an embodiment of the present invention provides a readable storage medium for storing a program, which, when executed by a processor, implements the steps of the task planning method based on the parallel reincarnation mechanism as described in the first aspect.

[0051] In a fifth aspect, an embodiment of the present invention provides a computer program product, comprising computer instructions, which, when executed by a processor, implement the steps of the task planning method based on the parallel reincarnation mechanism as described in the first aspect.

[0052] In an embodiment of the present application, the task platform sends the received planning tasks to multiple parallel drones for optimization calculations. Each of the drones performs optimization calculations through a reincarnation learning mechanism to obtain a first-generation memory population and sends it to the task platform. Perform multiple population iterations to obtain a target memory population, which is used to characterize the solution to the planning task. The technical effect of the present invention is that, in this embodiment, a center-multi-population evolutionary algorithm is used for task planning. During each population iteration, the drone performs optimization calculations based on the reincarnation learning mechanism, which is equivalent to integrating the reincarnation learning mechanism into the sub-population search strategy of the multi-population evolutionary algorithm, thereby accelerating the sub-population search speed, improving the computing efficiency of the drone, and thereby shortening the task solution time, improving the real-time performance of the unmanned cluster task planning, and enabling the unmanned cluster to efficiently and quickly execute tasks according to the solution of the planned task to adapt to complex environments with rapid and dynamic changes. BRIEF DESCRIPTION OF THE DRAWINGS

[0053] Attachment Figure 1 A flowchart of a task planning method based on a parallel reincarnation mechanism provided by an embodiment of the present invention;

[0054] Attachment Figure 2 A schematic diagram of a process for executing the i-th population iteration provided in an embodiment of the present invention;

[0055] Attachment Figure 3a Schematic diagram of the reincarnation learning mechanism in Caenorhabditis elegans;

[0056] Attachment Figure 3b Schematic diagram of the reincarnation learning mechanism in the genetic-based metaheuristic algorithm;

[0057] Attachment Figure 4 A parallel evolutionary computing framework based on a reincarnation learning mechanism provided by an embodiment of the present invention;

[0058] Attachment Figure 5a A schematic diagram of memory gene initialization provided by an embodiment of the present invention;

[0059] Attachment Figure 5b A schematic diagram of a memory gene adaptation map provided by an embodiment of the present invention;

[0060] Attachment Figure 5c A schematic diagram of memory gene crossover provided by an embodiment of the present invention;

[0061] Attachment Figure 5d A schematic diagram of memory gene mutation provided by an embodiment of the present invention;

[0062] Attachment Figure 6 A schematic diagram of the adaptive framework of PRETTY provided in an embodiment of the present invention;

[0063] Attachment Figure 7 A schematic diagram of the interaction process between the PRETTY task platform and the parallel computing environment provided in an embodiment of the present invention;

[0064] Attachment Figure 8 Schematic diagram of a parallel reincarnation learning-assisted evolution framework for autonomous mission planning of drone swarms provided by an embodiment of the present invention;

[0065] Attachment Figure 9 A schematic diagram of the time for single fitness evaluation for different real-world problems provided by an embodiment of the present invention;

[0066] Attachment Figure 10 A schematic diagram of sensitivity analysis of drones and population size provided by an embodiment of the present invention;

[0067] Attachment Figure 11 A comparison chart of the execution time ET of the five algorithms provided by the embodiment of the present invention for ZDT1-3 problems with different waiting times;

[0068] Attachment Figure 12 Convergence analysis of five algorithms for the ZDT1 problem provided by the embodiment of the present invention on the HV-Cauchy algorithm;

[0069] Attachment Figure 13a The formation organization of cluster formation flying provided by the embodiment of the present invention;

[0070] Attachment Figure 13b The embodiment of the present invention provides a formation reorganization for cluster formation flying in an obstacle environment;

[0071] Attachment Figure 13c The neural network structure under y=sin(5 / 4πx)+8 provided in an embodiment of the present invention;

[0072] Attachment Figure 13dThe neural network structure under y=(1+sin3x) / (3+sinx) provided in an embodiment of the present invention;

[0073] Attachment Figure 14 A schematic diagram of a task planning device based on a parallel reincarnation mechanism provided by an embodiment of the present invention;

[0074] Attachment Figure 15 A schematic structural diagram of an electronic device provided by an embodiment of the present invention. DETAILED DESCRIPTION

[0075] In the embodiments of this application, the term "and / or" describes the relationship between associated objects, indicating that three relationships can exist. For example, A and / or B can represent three situations: A exists alone, A and B exist simultaneously, and B exists alone. The character " / " generally indicates that the related objects are in an "or" relationship. In the embodiments of this application, the term "plurality" refers to two or more, and other quantifiers are similar.

[0076] The following will be combined with the drawings in the embodiments of this application to clearly and completely describe the technical solutions in the embodiments of this application. Obviously, the embodiments described are only part of the embodiments of this application, not all of the embodiments. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0077] See Figure 1 and Figure 2 , Figure 1 This is a flow chart of a task planning method based on a parallel reincarnation mechanism provided by an embodiment of the present invention. The method specifically includes the following steps:

[0078] Step 101: The task platform sends the received planning task to multiple parallel drones for optimization calculation.

[0079] In step 102, each of the UAVs performs optimization calculations through a reincarnation learning mechanism to obtain a first generation memory population and sends it to the mission platform.

[0080] Step 103 , performing multiple population iterations to obtain a target memory population, wherein the target memory population is used to represent a solution to the planning task.

[0081] Among them, such as Figure 2 As shown, executing the i-th population iteration includes:

[0082] S1: The task platform performs population merging on the i-th generation memory populations of the multiple parallel UAVs received to obtain a merged i-th generation memory population, where i is a positive integer.

[0083] S2: The task platform performs population selection on the merged i-th generation memory population to obtain a screened i-th generation memory population.

[0084] S3: The task platform determines whether the filtered i-th generation memory population meets the convergence condition.

[0085] S4: When the filtered i-generation memory population meets the convergence condition, the i-generation memory population is determined as the target memory population; when the filtered i-generation memory population does not meet the convergence condition, the task platform performs population segmentation on the filtered i-generation memory population, and sends the multiple i-generation sub-memory populations obtained by segmentation to the multiple parallel drones.

[0086] S5: Each of the drones optimizes the received i-th generation sub-memory population through a reincarnation learning mechanism to obtain an i+1-th generation memory population and sends it to the task platform.

[0087] In an embodiment of the present application, the task platform sends the received planning tasks to multiple parallel drones for optimization calculations. Each of the drones performs optimization calculations through the reincarnation learning mechanism to obtain the first generation of memory population and sends it to the task platform. Multiple population iterations are performed to obtain the target memory population, which is used to characterize the solution of the planning task. During each population iteration, the drone performs optimization calculations based on the reincarnation learning mechanism, which is equivalent to integrating the reincarnation learning mechanism into the subpopulation search strategy of the multi-population evolutionary algorithm, thereby speeding up the subpopulation search speed and improving the computing efficiency of the drone, thereby shortening the time consumption for solving the overall task planning and improving the real-time performance of the unmanned swarm task planning, so that the unmanned swarm can efficiently and quickly execute tasks according to the solution of the planned task to adapt to the complex environment with rapid dynamic changes.

[0088] In this embodiment, the task platform acts as a central node, and each drone acts as a computational node. Population iteration is the process of optimizing the solution to the planned task. The resulting memory population is the optimized solution obtained in that iteration. The memory population records the task plan and the corresponding task execution performance. When the task platform issues the task plan to the unmanned cluster, each drone in the cluster calculates the task execution performance, records it in the memory population, and returns it to the task platform. Each drone calculates the optimal solution to the planned task through a reincarnation learning mechanism. The resulting target memory population is the optimized solution obtained after multiple iterations, and this optimized solution is used to represent the solution to the planned task.

[0089] In scenarios where unmanned swarms perform tasks such as disaster relief and material delivery, the faster the task execution time, the greater the task execution efficiency. However, task planning for unmanned swarms often requires a lot of time to optimize and solve planning schemes. Through the task planning method based on the parallel reincarnation mechanism provided by the embodiment of the present application, an accurate and efficient planning scheme is obtained while meeting the timeliness requirements of the task. In the process of unmanned swarms performing tasks, the drone’s tasks are only to identify the location and control the drone’s flight. This is a waste for drones with sufficient computing power. Therefore, applying this part of computing power to task planning and allowing the unmanned swarm to perform some decision-making tasks can effectively shorten the calculation time of task planning. In addition, the use of unmanned swarms to make decisions separately can adapt to rapidly changing task environments. For example, when a new disaster or a new material delivery location occurs, the drone can record the scene and notify surrounding drones to quickly replan, which can be more flexibly applied to real-time tasks.

[0090] For ease of understanding, several algorithms mentioned in this embodiment are first introduced below.

[0091] 1. Multi-population evolutionary algorithm

[0092] The significant increase in computer processing power and the development of large-scale parallel architectures have provided important hardware support for the rapid development of metaheuristic algorithms. However, a major drawback of metaheuristics is that the fitness value of each new solution must be evaluated. Because problems such as task planning require the fitness value of the solution to be evaluated through simulation systems or neural networks, metaheuristic algorithms often have a high time complexity. Fast evaluation techniques are alternative methods to the evaluation process. Common alternatives include parallel computing and agent modeling techniques.

[0093] Metaheuristic algorithms, combined with various population evolution techniques, have been widely used in parallel and distributed computing. Multi-population-based approaches maintain population diversity and significantly improve metaheuristic computational efficiency. These algorithms partition the original population into multiple subpopulations. Then, operations such as selection, crossover, and mutation are performed on each subpopulation to achieve individual evolution. Finally, by employing a process of merging and repartitioning, premature convergence is avoided and population diversity is maintained.

[0094] Determining the search strategy for subpopulations is a key issue in the coevolution of multiple populations. Several commonly used algorithms in the prior art are introduced below: The iNSGA-II algorithm assumes that high-quality parents tend to produce high-quality offspring. This algorithm generates n subpopulations during each iteration and selects the optimal solution within each subpopulation for selection, crossover, and mutation. This approach allows for rapid convergence while maintaining diversity. Inspired by the altruistic behavior of honeybees, the Alt-NSGA-II-aJG algorithm incorporates altruism into the evolution of multiple populations. This algorithm generates multiple parallel queens. Using a two-point three-pair crossover operation, it increases the probability of further evolution within an individual queen and improves the convergence rate of the optimization problem. Prior art proposes a decision variable framework that facilitates objective evolutionary algorithms. Within this framework, decision variables are clustered and grouped to maintain convergence, and each group is optimized within the subgroup. To maintain diversity, a separate global archive is established outside the subpopulations to record global decision variable information. This archive is used to optimize decision variables to enhance diversity. Prior art also proposes a multi-population genetic algorithm. This algorithm assumes that the number of subpopulations is consistent with the number of optimization objectives, and each subpopulation optimizes only one objective function. This algorithm significantly outperforms other optimization algorithms for scheduling problems. Prior art also proposes a dual-population algorithm, in which a second population provides the primary population with a choice between evolution and degradation. Prior art also proposes a new dual-population and multi-stage MOEA for exploring the search space and feasible region.

[0095] However, most search strategies of these algorithms improve population diversity at the expense of computational cost. For expensive optimization problems, each subpopulation often takes a considerable amount of time to compute. Therefore, it is necessary to design a special optimization strategy for each subpopulation to speed up the computation process.

[0096] 2. Reincarnation learning mechanism

[0097] In recent years, a mechanism of transgenerational learning has been proposed in biology to explain the phenomenon of memory being passed down to the next generation in some organisms. This mechanism was first proposed in analytical psychology as the group memory hypothesis. Through a "group unconscious," offspring of a population can inherit memories, feelings, and ideas from their parents. This mechanism has been demonstrated experimentally in mice and the nematode Caenorhabditis elegans. Neuroscience research in mice has shown that specific experiences can influence the next generation. Studies have shown that some mice trained to fear specific odors can pass on this characteristic aversion to the next generation. Even in the next generation of these mice, even if they have not received similar training and have never encountered the specific odor, they remain susceptible to it and exhibit the same fearful behaviors. Furthermore, by observing changes in the mouse brain structure, researchers have concluded that even before conception, parental experiences can significantly influence the structure and function of the offspring's nervous system.

[0098] The mechanism of reincarnation learning also appears in Caenorhabditis elegans. Figure 3a As shown, they are currently one of the most common "model organisms" in biological research and they are found in almost all environmental habitats. They reproduce very quickly and the number of genes in their genome is almost the same as the number of genes in the human genome. A recent study found that memory can be inherited and maintained for 3 to 4 generations in organisms such as Caenorhabditis elegans. After these C. elegans learned how to avoid infection by the pathogenic bacteria Pseudomonas aeruginosa (PA14), the learned information was successfully passed on to their offspring. This transmission continued until the fourth generation. The nematode's nervous system communicates with germ cells through neurons, which contain information (genetic and epigenetic) that is passed on to future generations. This study identified the neuronal pattern that transmits this information to these offspring.

[0099] In a reincarnation learning mechanism, each offspring adapts to the environment by inheriting information from its parent. This characteristic allows this mechanism to be applied to a genetic-based metaheuristic algorithm, effectively solving CEMOPs. Inspired by natural evolution, genetic-based metaheuristic algorithms use continuous iterations of mutation, function evaluation, and selection to solve optimization problems. Figure 3a and Figure 3b A diagram comparing the mechanisms of reincarnation learning in Caenorhabditis elegans and a genetic-based metaheuristic algorithm. In C. elegans, neuronal RDE-4 is dependent on small RNAs. Production of these small RNAs, through HRDE-1, controls chemotactic behavior for at least three generations. Among the target genes of these small RNAs, seag-2 is observed to be persistent and transgenerationally downregulated in the germline.

[0100] Based on this mechanism, a reincarnation learning assisted evolutionary algorithm is proposed in the embodiment of this application. Figure 3b As shown, fitness estimates are stored in memory genes (MGs). When MGs perform crossover and mutation, a flag changes. In the next generation, MGs with flag changes are selected for fitness evaluation. MGs with unchanged flags inherit the fitness of the previous generation. Both C. elegans and metaheuristic algorithms have behavior containers (RDE-4 and fitness) and controllers (HRDE-1 and flags). Therefore, they can selectively achieve favorable outcomes for the next generation, leading to better population iteration.

[0101] For the convenience of description, the memory population containing memory genes (Memory Gene, MG) is recorded as MG Sets. Figure 4 This method employs a central-multi-population evolutionary algorithm structure. The mission platform accepts the optimized solutions (i.e., MGSets) computed by each UAV, combines these solutions, and filters them to obtain filtered MGSets. It then determines whether the Pareto solution set has converged. If the algorithm converges, the target memory population is obtained and a solution is generated. If not, the population is partitioned into MGSets (MGSets) using a specific strategy and provided to each UAV. Each UAV optimizes the MGSet through a reincarnation learning mechanism and passes it to the mission platform for a new round of iteration.

[0102] like Figure 4 As shown in the figure, in the initial stage of the population, after receiving the planning task, the task platform directly performs the population segmentation step, divides the planning task and sends it to n parallel drones for optimization calculation. The n drones perform optimization calculations through the reincarnation learning mechanism, obtain the initial MG set (MGSets) (i.e., the calculated optimized solution) and send it to the task platform. The task platform merges the MGSets and then screens them, using a self-convergence algorithm to determine whether the Pareto solution set has achieved convergence. If the algorithm converges, a solution is generated (i.e., the MGSets obtained after the current screening). If not, the population is divided into multiple new MGSets through a certain strategy and provided to each drone. Each drone once again optimizes the new MGSet received through the reincarnation learning mechanism and passes the results to the task platform for a new round of iteration.

[0103] The reincarnation learning mechanism and self-convergence algorithm mentioned in this embodiment are described below.

[0104] In traditional metaheuristic algorithms, decision variables are iteratively updated through selection, crossover, and mutation. In this process, the fitness function of each decision variable must be calculated after each round of overall iteration. However, some decision variables still do not have crossover and mutation, which does not require fitness calculation. This leads to a huge waste of resources. Figure 5a-5d Based on the reincarnation learning mechanism shown, this application provides a new memory gene (MG).

[0105] Optionally, the memory population includes multiple memory genes, and the memory genes include decision variable bits, fitness and flag bits, and the flag bits are used to determine whether the fitness needs to be recalculated. The fitness and flag bits of the i-th generation memory population are used to be integrated into the memory genes of the i+1-th generation memory population.

[0106] In this embodiment, the MG includes decision variables, fitness and flags. The fitness function and flags can be integrated into the MG of the next generation. The initialization of the MG is as follows: Figure 5a As shown in the figure, MG initializes the decision variables according to the initialization rules and records the flag as 0. In addition, MG also records the fitness evaluation of the decision variables.

[0107] Optionally, the MG determines whether it is necessary to recalculate the fitness function according to the value of the flag bit, and the fitness function used to calculate the fitness satisfies:

[0108]

[0109] Among them, F MG Used to characterize the fitness of the memory gene, flag MG The marker used to characterize the memory gene, X MG The decision variable used to characterize the memory gene, the initial value of the flag bit is 0, and when there is crossover or mutation between memory genes, the flag bit of the memory gene is changed to 1.

[0110] In this embodiment, fitness function calculations are reduced by evaluating the unchanged population. In this mechanism, each decision variable records a calculated fitness evaluation. In the next iteration, if the decision variable changes, the fitness evaluation for that decision variable is calculated. Otherwise, the fitness evaluation for that decision variable is transferred from the parent decision variable without calculation.

[0111] Optionally, each of the drones optimizes the received i-th generation sub-memory population through a reincarnation learning mechanism to obtain an i+1-th generation memory population and sends it to the task platform, including:

[0112] Each of the drones performs race iterative calculation on the i-th generation sub-memory population through a reincarnation learning mechanism;

[0113] Changing the flag of the memory gene that has undergone crossover and mutation to 1 to obtain the i+1 generation memory population;

[0114] The i+1 generation memory population is sent to the task platform.

[0115] The fitness calculation process is as follows Figure 5b When there is a crossover or mutation between MGs, the MG flag bit changes to 1. These changes can be seen in Figure 5c and Figure 5d shown.

[0116] By integrating MG into the NSGA-II algorithm, the resulting algorithm can be called a single transgenerational learning-assisted evolutionary algorithm (SITTY). During the population initialization phase, the fitness evaluation of the MG is calculated and the MG flag is recorded as 0. During the population iteration process, fast non-dominated sorting and crowding distance calculation are performed. After selection, the MG that has undergone crossover and mutation has its flag changed to 1. Then, the MG is placed in R. Subsequently, SITTY will P i Combined with R to get MGSet, and by applying the resizing function to get P i+1 .P i+1 The fitness evaluation of is calculated by applying the above fitness function. When the number of iterations reaches the set threshold or meets the convergence condition, the solution is output.

[0117] The specific algorithm implementation example of the reincarnation learning mechanism in the embodiment of this application is as follows:

[0118]

[0119] As an optional implementation, the task platform determines whether the filtered i-th generation memory population meets the convergence condition by determining whether the number of convergence iterations reaches a set value. As another optional implementation, the present application provides an algorithm called the Hyper Volume-Cauchy algorithm (HV-Cauchy) that can adaptively determine whether the convergence condition is met.

[0120] Optionally, in some embodiments, the task platform determines whether the filtered i-th generation memory population meets the convergence condition, including:

[0121] The task platform determines whether the filtered i-th generation memory population meets the convergence condition based on the Cauchy criterion formula.

[0122] Specifically, the hypervolume value is defined as the solution set The volume of the hypercube enclosed by all points in the target space and the reference point in the target space. The HV value is calculated as follows:

[0123]

[0124] Where Leb(S) represents the Lebesgue measure of the solution set S, which is used to characterize the i-th generation memory population after the screening, Ref=(r1,r2,...,r m )∈Π is the reference point, [f1(X),r1]×[f2(X),r2]×...×[f m (X),r m ] represents a hypercube surrounded by all points dominated by X but not by the reference point Ref.

[0125] Because each iteration of the MOEA changes the solution set, it is difficult to directly determine whether the MOEA has converged based on the solution set. Therefore, this embodiment considers the HV value of the solution set as the basis for convergence judgment. After each iteration, the HV values of the solution set form a sequence, and convergence can be determined by applying the Cauchy criterion.

[0126] The following formula is the Cauchy criterion that determines the convergence of the sequence:

[0127]

[0128] Where N is the number of iterations after convergence. X is a sequence, X n Represents the i-th element in the sequence X.

[0129] In order to be more suitable for calculation, a modified formula of the Cauchy criterion formula is proposed to determine the convergence of the solution set, specifically:

[0130] maxHVSet n -minHVSet n <ε,n∈N,n>I,

[0131] HVSet n ={HV(S n-I ),HV(S n-I+1 ),...,HV(S n )},

[0132] Among them, HVSet n Represents a sequence containing a series of hypervolume values, maxHVSet n Represents HVSet n The maximum value of HVSet, I is a constant, indicating n is a fixed interval of , and ε is a small constant.

[0133] In the embodiment of the present application, the above-mentioned Cauchy criterion formula can be used to effectively determine whether the obtained solution has converged. The method forms a hypervolume for each obtained solution in a sequence form. Then, the Cauchy convergence criterion is used to determine when the solution has converged.

[0134] See Figure 6 This embodiment provides an adaptive framework in which, when a task in a task list is assigned to a task platform, the task platform sends the task to multiple parallel UAVs. These nodes use a computing module to obtain an MGSet and then send it to the task platform. After receiving all MGSets, the task platform uses the computing module to obtain an optimized MGSet. These nodes determine whether it is necessary to distribute them to each node based on a modified formula of the Cauchy criterion formula. If necessary, the algorithm will perform a new round of iterative calculations. Otherwise, the algorithm will output an MGSet. Then, a new task is deleted from the calculated task list.

[0135] Furthermore, due to the parallelism of the subpopulation evolutionary algorithm, the embodiment of the present application provides a parallel computing algorithm with a transgenerational learning mechanism and an HV-Cauchy algorithm, called a Parallel Transgenerational Learning-Assisted Evolutionary Algorithm (PRETTY), which can significantly accelerate the convergence speed of SITTY. In PRETTY, the interaction process between the mission platform and the UAV is as follows: Figure 7 shown.

[0136] First, in PRETTY, the initialization process is performed separately on the task platform and the parallel computing environment. In the parallel computing environment, after initialization, the UAV selects, crosses, and mutates the MGSet. After that, the fitness evaluation of each MG in the MGSet is calculated. Finally, the MGSet is passed to the task platform. On the task platform, when all MGSets are received, PRETTY first merges the MGSets into a population. Next, a resize operation is performed on the population. Finally, based on a certain strategy, the merged population is divided into MGSets for each UAV in the parallel computing environment. After the UAV calculates, the new MGSet is passed to the task platform, and this process repeats until the solution meets the convergence conditions.

[0137] A specific example of the PRETTY algorithm of the task platform is as follows:

[0138]

[0139] Optionally, the number of the drones is n, where n is an integer greater than 1. The task platform performs population segmentation on the screened i-th generation memory population and sends the multiple i-th generation sub-memory populations obtained by segmentation to the multiple parallel drones, including:

[0140] After the task platform sends the memory genes that have undergone crossover or mutation in the i-th population iteration to each drone in turn, it randomly sends the memory genes that have not undergone crossover or mutation to each drone.

[0141] In specific implementation, the task platform aims to minimize the target difference, and performs population segmentation on the screened i-generation memory population to obtain n i-generation sub-memory populations. The target difference is the difference between the sum of the markers of the memory genes in the n i-generation sub-memory populations.

[0142] In this embodiment, when performing population segmentation, the task platform aims to adjust the sum of the marker numbers of genes in each MGSet to be as equal as possible, so that the computing load of different drones is more balanced, thereby accelerating the computing speed of parallel tasks.

[0143] During mission platform initialization, a socket listening port and multiple child threads are established to listen for messages in the parallel computing environment. When the i-th receiving thread receives an MGSet, PRETTY blocks the receiving thread and opens the i-th sending thread. After all MGSets are received, PRETTY begins merging and resizing operations. The population then determines convergence by applying the HV-Cauchy algorithm. If converged, a solution is output. Otherwise, the population is split into MGSets for each drone. After sending an MGSet, the mission platform blocks each sending thread and opens a receiving thread for the next iteration.

[0144] In order to quantitatively measure the improvement in the execution speed of parallel programs, considering the characteristics of PRETTY, the speedup ratio is calculated as follows:

[0145]

[0146] Where p is the number of nodes in the parallel system. T is the number of parallel tasks. W is the computational complexity of a given problem. s Refers to the serial port of the program. t i represents the computational effort of the t-th task, the i-th UAV, and S is the speedup ratio.

[0147] For a fixed problem size, W is a constant. Therefore, to maximize S, we need to minimize However, in PRETTY, the number of parallel planning tasks run in each iteration is positively correlated with the number of genes with flag=1 in MGSets.

[0148] The optimization formula in PRETTY is as follows:

[0149]

[0150] The planning tasks of each iteration are independent of each other. Based on the above formula, in order to speed up the calculation of parallel tasks, the sum of the number of markers of genes in each MGSet is adjusted to be as equal as possible when separating the MGSets to minimize

[0151] A specific example of the PRETTY algorithm for drones is as follows:

[0152]

[0153] First, during the initialization phase, the UAV establishes a socket connection with the mission platform. Next, after performing non-dominated sorting and calculating crowding distance on the population, SITTY's selection, crossover, and mutation methods are executed on the UAV's PRETTY. PRETTY then generates an MGSet and sends it to the mission platform. Finally, the UAV waits to receive another MGSet.

[0154] Distributed collaborative tasks of unmanned platforms usually require sufficient calculation and allocation in advance. Unmanned platforms execute according to established algorithms or plans, which makes it difficult to adapt to dynamic changes and complex environments. The application of the unmanned cluster task planning framework based on parallel cross-population learning provided in this embodiment can greatly speed up the calculation time of the entire collaborative task. The specific calculation framework is as follows: Figure 8 As shown in the figure, when a planning task arrives, the task platform (i.e., the central node) will send the task to multiple drones (i.e., multiple parallel computing nodes) for calculation. The drone cluster communicates the situation through the communication module, and interacts with the dynamic environment based on the control unit and perception unit, and performs task calculations through the computing unit. In specific implementation, the planning task can be other types of multi-objective optimization tasks, and the central node and computing node can also be set to different objects according to the specific application scenario, which is not limited here.

[0155] For example, in different application scenarios, the planning task can be a collaborative path planning task, a resource scheduling planning task, an area search planning task, etc. After obtaining the optimized solution of the planning task through this method, the task platform (i.e., the central node) can realize the task allocation according to the optimized solution so that the drone can perform the corresponding task.

[0156] Expensive and time-consuming optimization problems are common in real life. This method can be applied to various such problems to improve the efficiency of task computation. In different application scenarios, the specific objects corresponding to central nodes and computational nodes can vary, and the tasks targeted by optimization computations can also be other types of computational tasks besides planning tasks. These are not specifically limited here.

[0157] For example, in problems like autonomous swarm mission planning and workpiece design, MOEA's adaptive function calculations require a simulation system to mimic real-world systems, resulting in very high computational costs. In AI problems like image recognition and neural network compression, MOEA must train the entire neural network for each adaptive function calculation, consuming considerable computing resources. Figure 9 The average execution time of a single fitness evaluation for common real-world problems was selected. They are inventory control, parallel machine scheduling, minimum spanning tree, facility layout design, hub location allocation, drone path planning, investment portfolio, swarm formation flying, key node detection, feature selection, neural network training, and optimization experiments in computational fluid dynamics. The computation time of each fitness function ranges from 10 -5 to 10 4 This study starts from 10 -2 to 10 1 The computation time of CEMOP is selected, including feature selection, key node detection, swarm formation flying, and neural network training. The detailed information of each problem is listed in Table 1.

[0158] Table 1 Description of expensive optimization problems in real life

[0159]

[0160] (1) Feature selection: Feature selection combines deep learning with MOEA for training. It has been widely used to solve classification problems such as RNA identification and cancer diagnosis. To solve these problems, many input features are required. However, some irrelevant features can lead to poor performance in the training case. Therefore, it is crucial to select the most relevant features. In order to mitigate the negative impact of irrelevant and redundant features, many feature selection methods have been proposed. The main goal of feature selection is to select relevant features from a large number of features. The number of selected features needs to be minimized.

[0161] (2) Critical node detection: It is crucial to understand the connectivity properties and dynamic characteristics of a network, where the performance of a network is often affected by a small number of its nodes. The failure of these critical nodes may cause the network performance to degrade rapidly. Therefore, it is very important to find critical nodes in large-scale networks. The main purpose of critical node detection is to minimize the pairwise connections of the network after removing the selected nodes. The number of selected nodes needs to be minimized.

[0162] (3) Swarm formation flying: Swarm formation flying is a technology that uses simple rules to simulate group behavior. It has many applications in unmanned swarm control, such as swarm formation. In large-scale unmanned swarms, automatic control tasks in complex environments have problems with stability and poor environmental adaptability due to the setting of hyperparameters and target points. To solve this problem, swarm formation flying models are usually combined with metaheuristic algorithms. For this problem, swarm formation flying models are usually modeled as MOPs. Its goal is to maximize formation similarity and minimize formation density and formation time.

[0163] (4) Neural network training: The neural network training process is often affected by network topology and hyperparameters, which can reduce training efficiency. In neural network architecture search, metaheuristic algorithms use iteration to automatically design high-performance neural networks, effectively reducing the scale and implementation cost of neural networks. Therefore, the neural network training problem is usually modeled as a MOP. The decision variables include each activation function of the hidden layer nodes and the structure of the neural network, which is constructed as a directed acyclic graph. The main goal of neural network training is to minimize the model loss. The complexity of the neural network needs to be minimized.

[0164] The performance of MOEA often needs to consider the quality of candidate solutions and the computational efficiency of the algorithm. In order to evaluate the quality of candidate solutions, hypervolume (HV) and inverted generational distance (IGD) can simultaneously consider the convergence, uniformity, and breadth of candidate solutions. The computational efficiency of the algorithm is usually calculated by the execution time (ET) of the algorithm. Therefore, this embodiment measures the algorithm performance of MOEA through three indicators, namely HV, IGD, and ET.

[0165] (1) HV: According to the fitness function, we can obtain the HV value through the solution set and the reference point.

[0166] (2) IGD: IGD is a comprehensive performance evaluation indicator. It mainly evaluates the convergence performance and distribution performance of the algorithm by calculating the sum of the minimum distances between each point on the entire Pareto front surface and the Pareto solution calculated by MOEA. The smaller the value, the better the overall performance of the algorithm. The calculation formula of IGD is as follows:

[0167]

[0168] Where P is the set of points uniformly distributed on the Pareto surface. |P| is the number of individuals in the set of points distributed on the Pareto surface. Q is the set of Pareto solutions obtained by solving the MOEA. d(v,Q) is the minimum Euclidean distance from individual v to population Q in P.

[0169] (3) ET: Based on the modified formula of the Cauchy criterion formula, the iteration time of the entire iterative process satisfies:

[0170] IT=min{nI|maxHVSet n -minHVSet n <ε,n∈N,n>I}

[0171] Among them, HVSet n ={HV(S n-I ),HV(S n-I+1 ),...,HV(S n )}. Finally, the execution time is calculated using the following formula:

[0172] ET=t IT -t start

[0173] Among them, t IT is the iterative convergence time.

[0174] In order to ensure a fair comparison of the algorithms, the parameter settings of the experiments are introduced below.

[0175] (1) Comparison of algorithms: In order to fairly test the performance of PRETTY on MOPs, NSGA-II, RVEA, MOEA / PSL, and SITTY algorithms were selected for comparison. As a classic MOEA, NSGA-II is often used as a benchmark algorithm. RVEA has certain advantages in solving high-dimensional MOPs and large-scale MOPs. MOEA / PSL is a surrogate model-assisted evolutionary algorithm that has certain advantages in solving CEMOPs problems. SITTY is a single reincarnation learning-assisted evolutionary algorithm used to verify the performance of the reincarnation learning mechanism.

[0176] (2) Experimental Environment: NSGA-II and RVEA algorithms were implemented in Geap. MOEA / PSL were implemented in PlatEMO. SITTY and PRETTY were implemented in Python 3.6. Except for PRETTY, the other algorithms were run on a PC with an InterCore 2.6GHz processor and 16.0G RAM. PRETTY was run on an Intel NUC with product code BXNUC10i7FNH.

[0177] (3) Genetic operators: All algorithms use simulated binary crossover and polynomial mutation as their genetic operators. In general, the crossover probability p c Set to a value close to 1. In this section, the crossover probability is set to 0.8. The mutation probability is generally set to 1 / d, where d is the dimension of the decision variable. The maximum number of iterations IT max =1000.

[0178] (4) Population size: Taking into account both computational time and algorithm efficiency, this example uses the same population size N = 100 for the NSGA-II, RVEA, MOEA / PSL, SITTY, and PRETTY algorithms in the benchmark problem. In practice, we use the same population size N = 20 for the NSGA-II, RVEA, MOEA / PSL, SITTY, and PRETTY algorithms. Table 2 shows the population size settings for each UAV and mission platform for different numbers of UAVs.

[0179] Table 2 Mission platform and drone population size settings in PRETTY

[0180]

[0181] (5) Expensive optimization problems: In order to verify the performance of PRETTY in solving various multi-objective optimization problems, this application compares multiple types of benchmark problems. For example, the DTLZ 1-3 problems are used to verify high-dimensional multi-objective optimization problems, and the LSMOP 1-3 problems are used to verify large-scale multi-objective optimization problems. However, CEMOP does not have any benchmark problems for expensive and time-consuming multi-objective optimization problems. In order to design experiments for CEMOP, we improved the ZDT problem. In these problems, the sleep function of Python is used to simulate the single computation time of different expensive fitness evaluations. For ZDT 1-3, it takes 0.001, 0.01, and 0.1 seconds to execute the fitness evaluation. For real-world MOPs, this chapter selects feature selection, key node detection, cluster formation flying, and neural network training problems to test the performance of different algorithms in practical applications. The detailed information of the CEMOP dataset in practical applications is shown in Table 3.

[0182] Table 3. Datasets of Realistic Expensive Optimization Problems

[0183]

[0184] PRETTY's performance optimization on the benchmark problem is verified by comparing it with NSGA-II, RVEA, MOEA / PSL, and SITTY algorithms. For these five algorithms, the mean and standard deviation (in parentheses) of the IGD and ET values are shown in Tables 4 and 5, respectively. The best value (highest HV, lowest IGD, and lowest ET) for each test case is shown in gray.

[0185] Table 4 Comparison of IGD indicators of five algorithms in ZDT1-3, DTLZ1-3, and LSMOP1-3 problems

[0186]

[0187] As shown in Table 4, PRETTY achieves lower IGD mean and variance for the ZDT1, ZDT2, and ZDT3 problems, indicating that the non-dominated solution sets obtained by PRETTY offer better and more stable results in terms of IGD. For high-dimensional multi-objective optimization problems, RVEA performs better for the DTLZ problem. For large-scale multi-objective optimization problems, PRETTY also performs better for the LSMOP problem. This demonstrates that the PRETTY algorithm effectively leverages the advantages of multi-population algorithms, providing diversity for iterative population computation.

[0188] Table 5 demonstrates the advantages of PRETTY through the calculation of CEMOP. Taking the ZDT1 problem as an example, when directly computing ZDT1, PRETTY requires 48 seconds to converge, while SITTY takes 61 seconds, NSGA-II takes 51 seconds, MOEA / PSL takes 1.28 seconds, and RVEA takes 40 seconds. As can be seen, the speedup effect is not significant. Furthermore, we observe that MOEA / PSL achieves the highest computational efficiency when the fitness evaluation takes less than 0.01 seconds. However, when ZDT1 requires 0.1 seconds per calculation, PRETTY takes 104 seconds. In comparison, SITTY takes 287 seconds, NSGA-II takes 1160 seconds, MOEA / PSL takes 1000 seconds, and RVEA takes 1009 seconds. PRETTY's computational efficiency is 2.7 times that of SITTY, 9.1 times that of NSGA-II, 10 times that of MOEA / PSL, and 9.7 times that of RVEA. Furthermore, when optimized solely through the reincarnation learning mechanism, SITTY's computational efficiency is 4 times that of NSGA-II, 3.9 times that of MOEA / PSL, and 3.9 times that of RVEA.

[0189] Table 5 Comparison of execution time ET of five algorithms in ZDT1-3 problems with waiting time of 0.001 seconds, 0.01 seconds, and 0.1 seconds

[0190]

[0191] Tables 4 and 5 analyze the performance of IGD and ET for the ZDT1-3, DTLZ1-3, and LSMOP1-3 problems for NSGA-II, RVEA, MOEA / PSL, SITTY, and PRETTY, respectively. Comparing the dispersion of candidate solutions, their proximity to the entire Pareto front, and the computational efficiency of the algorithms reveals that for non-expensive problems, when IGD values are similar to those of NSGA-II, SITTY's ET is longer than those of NSGA-II and RVEA. However, when solving CEMOPs, NSGA-II's convergence time is at least twice that of SITTY when the fitness evaluation execution time exceeds 0.01 seconds. This is because the fitness of genes is recorded in the MG for reincarnation learning. The fitness function for genes without crossover and mutation does not need to be recalculated. After the first generation is calculated, the execution time of each population iteration is significantly faster. Therefore, SITTY accelerates NSGA-II without changing its algorithmic strategy.

[0192] While PRETTY's HV calculations are similar to those of NSGA-II, the IGD and ET metrics are significantly improved. In particular, when solving expensive problems, PRETTY's execution efficiency is 2.7 times that of SITTY when the execution time is greater than 0.1 seconds. This is due to the diversity of the population provided by the parallel computing framework. Therefore, performing distributed genetic iterations and then aggregating the optimal selection strategies can make the Pareto solution set similar to the true solution.

[0193] Sensitivity analysis of the number of nodes: To further test the performance of PRETTY, we used the number of drones n in PRETTY. Node The number and size of MGSet in the UAV n Pop Scalability analysis was performed. ZDT1-3 was tested with a 0.1 second wait time and n based on Table 2. Pop Down, Figure 10 (a), (b), and (c) in Figure 3 show that PRETTY achieves maximum computational efficiency when the number of drones is 5 or 6. At the same time, as the number of drones increases, the range of variation in the algorithm execution time continues to decrease.

[0194] Population size sensitivity analysis: The effects of various MGSet sizes on ET are as follows: Figure 10 These three box plots show that the algorithm achieves maximum efficiency when the population size is 20. Furthermore, as the population size increases, the algorithm convergence time decreases. However, once the population size reaches a certain level, the improvement in algorithm efficiency is not significant. Therefore, setting a reasonable population size significantly impacts PRETTY efficiency.

[0195] Time sensitivity analysis: Figure 11 The graph shows the convergence times of five different algorithms for various computationally expensive problems. To simulate CEMOP, the x-axis represents the number of seconds the function sleeps when computing the ZDT problem. The three graphs show that for non-expensive problems, the five algorithms operate at nearly identical efficiency. When the fitness evaluation time is between 0.001 and 0.01 seconds, SITTY and PRETTY significantly outperform NSGA-II. When the fitness evaluation time is greater than 0.01 seconds, PRETTY's efficiency is higher than that of the other four algorithms. However, the fitness evaluation execution time slightly impacts PRETTY's computational overhead. This is because PRETTY distributes the fitness function calculation to each drone. Furthermore, a key factor affecting PRETTY's computational efficiency is that the resizing of all MGSets on the mission platform must be performed serially. Based on the aforementioned speedup formula, it can be seen that PRETTY's speedup S has an upper limit.

[0196] 2) Convergence analysis: Figure 12 The figure shows the evolution of the HV values for NSGA-II, RVEA, MOEA / PSL, SITTY, and PRETTY on the ZDT1 problem. During the iteration process, it can be observed that all five algorithms stop iteration after convergence, demonstrating the effectiveness of the HV-Cauchy algorithm. Furthermore, PRETTY converges faster due to the diversity of its subpopulation evolutionary algorithm. However, RVEA, MOEA / PSL, SITTY, and NSGA-II require more iterations to converge. It is observed that PRETTY converges faster due to its parallel computation, which reduces direct interactions between different drone populations.

[0197] Table 6 shows the HV values of eight CEMOPs obtained by the five MOEAs in real-world applications. It can be seen that PRETTY performs well in solving real-world CEMOPs. Furthermore, Table 7 shows the execution time of these problems for the five algorithms. Compared to other algorithms, PRETTY demonstrates superior efficiency. Compared to NSGA-II, RVEA, and MOEA / PSL, PRETTY's computational efficiency is over six times higher.

[0198] Table 6 Comparison of HV values of five algorithms for CEMOP problems in real life

[0199]

[0200] Table 7 Comparison of ET values of five algorithms for CEMOP problems in real life

[0201]

[0202] Figure 13a-13d The candidate results of PRETTY for solving unmanned swarm formation flying and neural network training problems are presented. Figure 13a It shows the unmanned swarm evolving from a disorganized mess to forming a peach shape. Figure 13b The unmanned swarm is shown forming a peach and then changing into an apple shape while navigating an obstacle. Figure 13c A neural network topology is shown, in which three neuron nodes are used to fit y = sin (5 / 4πx) + 8, and the activation functions of the nodes include sigmoid and tanh functions. Figure 13d It is a neural network topology with two neuron nodes, used to fit y = (1 + sin3x) / (3 + sinx). Its nodes are all composed of tanh.

[0203] The algorithm provided in this embodiment can be called PRETTY's parallel reincarnation learning-assisted evolutionary algorithm, which is used to solve expensive and time-consuming task planning problems. In PRETTY, a reincarnation learning mechanism is designed for the search strategy of the multi-population evolutionary algorithm. To improve convergence efficiency, a HV-Cauchy algorithm is proposed to accelerate optimization by adaptively determining the convergence of the MOEA. Finally, a parallel computing framework is designed using the reincarnation mechanism and the HV-Cauchy algorithm.

[0204] To validate the performance of PRETTY, we compared it with NSGA-II, RVEA, MOEA / PSL, and SITTY on the expensive MOP. Experimental results show that PRETTY significantly outperforms other algorithms in generating ET values on the CEMOP. When the fitness function execution time exceeds 0.01 seconds, PRETTY's computational efficiency is several times higher than that of other algorithms. Furthermore, due to the diversity of multi-population algorithms, PRETTY's candidate solutions offer superior performance.

[0205] See Figure 14 The embodiment of the present invention further provides a task planning device 1400 based on a parallel reincarnation mechanism, comprising:

[0206] Processing module 1401 is used for the task platform to send the received planning task to multiple parallel UAVs for optimization calculation;

[0207] The calculation module 1402 is used for each UAV to perform optimization calculations through the reincarnation learning mechanism to obtain the first generation memory population and send it to the mission platform;

[0208] An execution module 1403 is configured to execute multiple population iterations to obtain a target memory population, wherein the target memory population is used to represent a solution to the planning task;

[0209] The execution module 1403 includes:

[0210] The population merging unit 14031 is configured for the task platform to merge the received i-th generation memory populations of the multiple parallel UAVs to obtain a merged i-th generation memory population, where i is a positive integer;

[0211] The population selection unit 14032 is used for the task platform to perform population selection on the merged i-th generation memory population to obtain a screened i-th generation memory population;

[0212] A judgment unit 14033 is used for the task platform to judge whether the filtered i-th generation memory population meets the convergence condition;

[0213] Processing unit 14034 is configured to, if the filtered i-th generation memory population meets the convergence condition, determine the i-th generation memory population as the target memory population; if the filtered i-th generation memory population does not meet the convergence condition, the task platform performs population segmentation on the filtered i-th generation memory population, and send the multiple i-th generation sub-memory populations obtained by segmentation to the multiple parallel UAVs;

[0214] The optimization unit 14035 is used for each of the drones to optimize the received i-th generation sub-memory population through a reincarnation learning mechanism, obtain the i+1-th generation memory population and send it to the task platform.

[0215] Optionally, the memory population includes multiple memory genes, and the memory genes include decision variable bits, fitness and flag bits, and the flag bits are used to determine whether the fitness needs to be recalculated. The fitness and flag bits of the i-th generation memory population are used to be integrated into the memory genes of the i+1-th generation memory population.

[0216] Optionally, the fitness function used to calculate the fitness satisfies:

[0217]

[0218] Among them, F MG Used to characterize the fitness of the memory gene, flag MG The marker used to characterize the memory gene, X MG The decision variable used to characterize the memory gene, the initial value of the flag bit is 0, and when there is crossover or mutation between memory genes, the flag bit of the memory gene is changed to 1.

[0219] Optionally, the optimization unit 14035 is specifically configured to:

[0220] Each of the drones performs race iterative calculation on the i-th generation sub-memory population through a reincarnation learning mechanism;

[0221] Changing the flag of the memory gene that has undergone crossover and mutation to 1 to obtain the i+1 generation memory population;

[0222] The i+1 generation memory population is sent to the task platform.

[0223] Optionally, the number of the drones is n, where n is an integer greater than 1, and the processing unit 14034 is specifically configured to:

[0224] After the task platform sends the memory genes that have undergone crossover or mutation in the i-th population iteration to each drone in turn, it randomly sends the memory genes that have not undergone crossover or mutation to each drone.

[0225] Optionally, the judging unit 14033 is specifically configured to:

[0226] The task platform determines whether the filtered i-th generation memory population meets the convergence condition based on the modified formula of the Cauchy criterion formula, and the modified formula of the Cauchy criterion formula satisfies:

[0227] maxHVSet n -minHVSet n <ε,n∈N,n>I,

[0228] HVSet n ={HV(S n-I ),HV(S n-I+1 ),...,HV(S n )},

[0229] Among them, HVSet n Represents a sequence containing a series of hypervolume values, maxHVSet n Represents HVSet n The maximum value of HVSet, I is a constant, indicating n A fixed interval of , ε is a small constant;

[0230] The HV value is calculated as follows:

[0231]

[0232] Where Leb(S) represents the Lebesgue measure of the solution set S, which is used to characterize the i-th generation memory population after the screening, Ref=(r1,r2,...,r m )∈Π is the reference point, [f1(X),r1]×[f2(X),r2]×...×[f m (X),rm ] represents a hypercube surrounded by all points dominated by X, but not by the reference point Ref, where X is a sequence, X n Represents the i-th element in the sequence X, satisfying N is the number of iterations after convergence.

[0233] The task planning device 1400 based on the parallel reincarnation mechanism provided in the embodiment of the present application can execute the above method embodiment, and its implementation principle and technical effects are similar, which will not be repeated in this embodiment.

[0234] It should be noted that the division of units in the embodiments of the present application is schematic and is merely a logical functional division. In actual implementation, other division methods may be used. Furthermore, the functional units in the various embodiments of the present application may be integrated into a single processing unit, or each unit may exist physically separately, or two or more units may be integrated into a single unit. The aforementioned integrated units may be implemented in the form of hardware or software functional units.

[0235] If the integrated unit is implemented in the form of a software functional unit and sold or used as an independent product, it can be stored in a processor-readable storage medium. Based on this understanding, the technical solution of the present application is essentially or the part that contributes to the prior art or all or part of the technical solution can be embodied in the form of a software product, and the computer software product is stored in a storage medium, including a number of instructions for enabling a computer device (which can be a personal computer, server, or network device, etc.) or a processor to execute all or part of the steps of the method described in each embodiment of the present application. The aforementioned storage medium includes: various media that can store program codes, such as a USB flash drive, a mobile hard disk, a read-only memory (ROM), a random access memory (RAM), a magnetic disk or an optical disk.

[0236] like Figure 15 As shown, an embodiment of the present application provides an electronic device 1500, including: a memory 1502, a processor 1501, and a program stored on the memory 1502 and executable on the processor 1501; the processor 1501 is used to read the program in the memory 1502 to implement the steps in the task planning method based on the parallel reincarnation mechanism as described above.

[0237] An embodiment of the present application also provides a readable storage medium, on which a program is stored. When the program is executed by a processor, the various processes of the above-mentioned task planning method embodiment based on the parallel reincarnation mechanism are implemented, and the same technical effect can be achieved. To avoid repetition, it will not be repeated here. Among them, the readable storage medium can be any available medium or data storage device that can be accessed by the processor, including but not limited to magnetic storage (such as floppy disk, hard disk, magnetic tape, magneto-optical disk (MO), etc.), optical storage (such as compact disk (CD), digital video disc (DVD), Blu-ray disc (BD), high-definition versatile disc (HVD), etc.), and semiconductor memory (such as read-only memory (ROM), erasable programmable read-only memory (EPROM), electrically erasable programmable read only memory (EEPROM), non-volatile memory (NAND FLASH), solid state drive (SSD)), etc.

[0238] An embodiment of the present application also provides a computer program product, including computer instructions, which, when executed by a processor, implement the various processes of the above-mentioned task planning method embodiment based on the parallel reincarnation mechanism and can achieve the same technical effect. To avoid repetition, they will not be repeated here.

[0239] It should be noted that, in this document, the terms "comprises," "includes," or any other variations thereof are intended to encompass non-exclusive inclusion, such that a process, method, article, or apparatus comprising a series of elements includes not only those elements but also other elements not explicitly listed, or elements inherent to such process, method, article, or apparatus. In the absence of further limitations, an element defined by the phrase "comprising a ..." does not exclude the presence of other identical elements in the process, method, article, or apparatus comprising the element.

[0240] Through the description of the above embodiments, those skilled in the art can clearly understand that the above embodiment methods can be implemented by means of software plus the necessary general hardware platform, and of course can also be implemented by hardware, but in many cases the former is a better embodiment. Based on this understanding, the technical solution of the present application, or the part that contributes to the prior art, can be embodied in the form of a software product, which is stored in a storage medium (such as ROM / RAM, disk, CD-ROM), and includes a number of instructions for enabling a terminal (which can be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in each embodiment of the present application.

[0241] The embodiments of the present application are described above in conjunction with the accompanying drawings, but the present application is not limited to the above-mentioned specific implementation methods. The above-mentioned specific implementation methods are merely illustrative and not restrictive. Under the guidance of this application, ordinary technicians in this field can also make many forms without departing from the purpose of this application and the scope of protection of the claims, all of which are within the protection of this application.

Claims

1. A task planning method based on a parallel reincarnation mechanism, characterized in that: include: The task platform sends the received planning tasks to multiple parallel UAVs for optimization calculation; Each of the drones performs optimization calculations through a reincarnation learning mechanism to obtain a first-generation memory population and sends it to the mission platform; Performing multiple population iterations to obtain a target memory population, wherein the target memory population is used to represent a solution to the planning task; Among them, executing the i-th population iteration includes: The task platform performs population merging on the i-th generation memory populations of the multiple parallel drones received to obtain a merged i-th generation memory population, where i is a positive integer; The task platform performs population selection on the merged i-th generation memory population to obtain a screened i-th generation memory population; The task platform determines whether the filtered i-th generation memory population meets the convergence condition; If the filtered i-generation memory population meets the convergence condition, the i-generation memory population is determined as the target memory population; if the filtered i-generation memory population does not meet the convergence condition, the task platform performs population segmentation on the filtered i-generation memory population, and sends the multiple i-generation sub-memory populations obtained by segmentation to the multiple parallel drones; Each of the drones optimizes the received i-th generation sub-memory population through a reincarnation learning mechanism to obtain an i+1-th generation memory population and sends it to the mission platform.

2. The method according to claim 1, wherein: The memory population includes multiple memory genes, each of which includes a decision variable bit, fitness and a flag bit. The flag bit is used to determine whether the fitness needs to be recalculated. The fitness and flag bit of the i-th generation memory population are used to be integrated into the memory gene of the i+1-th generation memory population.

3. The method according to claim 2, wherein The fitness function for calculating the fitness satisfies: Among them, F MG Used to characterize the fitness of the memory gene, flag MG The marker used to characterize the memory gene, X MG The decision variable used to characterize the memory gene, the initial value of the flag bit is 0, and when there is crossover or mutation between memory genes, the flag bit of the memory gene is changed to 1.

4. The method according to claim 3, wherein: Each of the drones optimizes the received i-th generation sub-memory population through a reincarnation learning mechanism to obtain an i+1-th generation memory population and sends it to the task platform, including: Each of the drones performs race iterative calculation on the i-th generation sub-memory population through a reincarnation learning mechanism; Changing the flag of the memory gene that has undergone crossover and mutation to 1 to obtain the i+1 generation memory population; The i+1 generation memory population is sent to the task platform.

5. The method according to claim 3, wherein: The number of the drones is n, where n is an integer greater than 1. The task platform performs population segmentation on the screened i-generation memory population and sends the multiple i-generation sub-memory populations obtained by segmentation to the multiple parallel drones, including: After the task platform sends the memory genes that have undergone crossover or mutation in the i-th population iteration to each drone in turn, it randomly sends the memory genes that have not undergone crossover or mutation to each drone.

6. The method according to claim 1, wherein: The task platform determines whether the filtered i-th generation memory population meets the convergence condition, including: The task platform determines whether the filtered i-th generation memory population meets the convergence condition based on the modified formula of the Cauchy criterion formula, and the modified formula of the Cauchy criterion formula satisfies: max HVSet n -min HVSet n <ε,n∈N,n>I, HVSet n ={HV(S n-I ),HV(S n-I+1 ),...,HV(S n )}, Among them, HVSet n Represents a sequence containing a series of hypervolume values, maxHVSet n Represents HVSet n The maximum value of HVSet. I is a constant, indicating n A fixed interval of , ε is a small constant; The HV value is calculated as follows: Wherein, Leb(S) represents the Lebesgue measure of the solution set S, which is used to characterize the i-th generation memory population after the screening, Ref=(r1,r2,...,r m )∈Π is the reference point, [f1(X),r1]×[f2(X),r2]×...×[f m (X),r m ] represents a hypercube surrounded by all points dominated by X, but not by the reference point Ref, where X is a sequence, X n Represents the i-th element in the sequence X, satisfying N is the number of iterations after convergence.

7. A task planning device based on a parallel reincarnation mechanism, characterized in that: include: The processing module is used by the task platform to send the received planning tasks to multiple parallel UAVs for optimization calculation; A computing module, configured to perform optimization calculations on each of the UAVs through a reincarnation learning mechanism, obtain a first-generation memory population, and send the population to the mission platform; An execution module, configured to execute multiple population iterations to obtain a target memory population, wherein the target memory population is used to represent a solution to the planning task; The execution module includes: a population merging unit, configured for the task platform to merge the i-th generation memory populations received from the plurality of parallel UAVs to obtain a merged i-th generation memory population, where i is a positive integer; A population selection unit, configured for the task platform to perform population selection on the merged i-th generation memory population to obtain a screened i-th generation memory population; A judgment unit, configured for the task platform to judge whether the filtered i-th generation memory population meets the convergence condition; a processing unit configured to, if the filtered i-th generation memory population satisfies a convergence condition, determine the i-th generation memory population as the target memory population; if the filtered i-th generation memory population does not satisfy the convergence condition, cause the task platform to perform population segmentation on the filtered i-th generation memory population and send the multiple i-th generation sub-memory populations obtained by segmentation to the multiple parallel UAVs; The optimization unit is used for each of the drones to optimize the received i-th generation sub-memory population through a reincarnation learning mechanism to obtain the i+1-th generation memory population and send it to the task platform.

8. An electronic device comprising: A memory, a processor, and a program stored in the memory and executable on the processor; wherein the processor is configured to read the program in the memory to implement the steps of the task planning method based on a parallel reincarnation mechanism as described in any one of claims 1 to 6.

9. A readable storage medium for storing a program, characterized in that: When the program is executed by a processor, the steps of the task planning method based on the parallel reincarnation mechanism according to any one of claims 1 to 6 are implemented.

10. A computer program product, characterized in that The method comprises computer instructions, which, when executed by a processor, implement the steps of the task planning method based on the parallel reincarnation mechanism as claimed in any one of claims 1 to 6.

Images