Distributed heterogeneous agent task allocation method based on dynamic decision behavior tree

Abstract

The invention discloses a distributed heterogeneous agent task allocation method based on a dynamic decision behavior tree, and belongs to the technical field of robot task allocation, and the method comprises the steps: S100, constructing a dynamic decision behavior tree of a distributed heterogeneous agent team; the distributed heterogeneous agent team comprises a plurality of robots participating in task execution; s200, in the behavior tree, abstracting the capability of the intelligent agent into nodes with interface constraints, and defining capability parameters; s300, defining capability implementation of the nodes, and introducing preconditions to perform execution verification on the capability implementation; and S400, in response to the fact that the execution verification is passed, in the agent task allocation operation process, when the node state changes, based on a capability-implementation binding function constructed by a centerless auction mechanism, the task is allocated to the optimal agent with the purpose of maximizing the utility. The invention provides a centerless, high-robustness and extensible task execution method, can be used for large-scale robot teams and complex task scenes, and has relatively high task allocation efficiency.

Description

Technical Field

[0001] This invention belongs to the field of robot task allocation technology, specifically relating to a distributed heterogeneous intelligent agent task allocation method based on dynamic decision behavior tree. Background Technology

[0002] In the field of multi-robot technology, walking robots and AI-assisted systems have been commercially deployed. Equipping robots with robotic arms or dedicated 3D sensors can make them more versatile, making heterogeneous robot teams a very realistic prospect. Coordinating heterogeneous robots and skills while handling dynamic team compositions requires a robust and flexible system to model, coordinate, and exchange robot skills and behaviors. Therefore, the need for Multi-Robot Task Assignment (MRTAP) using Decision Behavior Trees (BTs) is becoming increasingly apparent.

[0003] In multi-robot systems, system performance is influenced by various aspects of the decision behavior tree. For example, the task assignment failure rate is affected by the accuracy of robot capability modeling. When capability modeling ignores robot battery wear and tear, it leads to a distorted utility function, resulting in suboptimal task assignment and an 8% increase in the task failure rate, forcing the system to frequently reassign tasks. The modular design of the behavior tree also directly impacts task assignment efficiency. Different modular design methods affect the readability and maintainability of the behavior tree, limiting the dynamic allocation and adjustment of tasks. In addition, factors such as task abstraction capabilities, utility evaluation functions, network latency, auction methods, and node capabilities also affect the performance of multi-robot systems.

[0004] Before a robotic system starts, the builders of the decision behavior tree typically fix some subtree structures to the parent node, such as the "Shovables" method adopted by Heppner et al. in 2023. This allows for pre-defining the structure and action logic of the behavior tree, enabling pre-configuration and organization of the behavior tree, and ensuring that the robotic system executes tasks according to predetermined behavior patterns. However, this static binding method means that once a subtree is bound, it cannot be easily replaced or modified during the behavior tree's lifecycle. This limits the adaptability and scalability of the behavior tree. In practical applications, when a robot leaves or joins a queue, static binding forces the entire behavior tree to restart for reconfiguration. This undoubtedly increases the system's complexity and maintenance costs.

[0005] Furthermore, in practical applications, multi-robot systems currently rely heavily on a central scheduler, limiting task allocation to centralized auction mechanisms, as seen in TraderBots. This dependence on a central scheduler makes the system perform poorly in dynamic environments. In situations with multiple robots or poor communication conditions, task allocation may become inefficient or fail due to communication delays or scheduler overload. While some decentralized methods have attempted to address this issue in recent years, they haven't fully utilized the price discovery features and competitive advantages of auction mechanisms. For example, negotiation-based methods achieve decentralization through communication protocols and message exchange, but these methods fail when system resources are limited.

[0006] In existing technologies, researchers have proposed various methods for multi-robot task allocation, including centralized task allocation, genetic algorithms (GA), and reinforcement learning (RL), to reduce the complexity and improve the efficiency of task allocation. In 2023, Johnson et al. proposed a multi-robot task allocation method based on a genetic algorithm. This method optimizes task allocation through gene encoding and a fitness function, with the robot team selecting the optimal task allocation scheme based on the fitness value. This method can not only handle complex task allocation problems but also adapt to dynamic environmental changes to a certain extent. The method first encodes and initializes genes, translating the task allocation scheme into genes and initializing the population. Simultaneously, it calculates fitness based on indicators such as task completion time and energy consumption, selecting high-fitness individuals for crossover and mutation to generate a new population. In the optimization phase, the method follows the iterative optimization approach, repeatedly selecting and crossovering to gradually optimize the task allocation scheme. This method can handle complex task allocation problems and adapt to dynamic environmental changes to a certain extent.

[0007] The aforementioned genetic algorithm requires extensive iterative computation to optimize the task allocation scheme, resulting in a computational complexity far exceeding O(N), where N is the number of robots in a multi-robot system. This can lead to excessive consumption of computational resources and insufficient real-time performance in large-scale robot teams and complex task scenarios. Although genetic algorithms can adapt to environmental changes to some extent, their adaptability may be insufficient in real-time dynamic environments, requiring frequent recalculation of task allocation schemes and increasing the system's burden.

[0008] To address the real-time limitations of genetic algorithms in multi-robot task allocation, researchers have proposed numerous other methods. In 2024, Smith et al. proposed a multi-robot task allocation method based on reinforcement learning (MARL). This method trains multiple robots to collaborate in a dynamic environment, with each robot learning the optimal task allocation strategy based on environmental feedback and reward signals. Smith et al.'s method first models the task allocation problem as a multi-robot reinforcement learning problem, defining a state space, action space, and reward function. Each robot learns the optimal strategy through interaction with the environment, maximizing cumulative rewards. Robots can also collaborate using partially observable information, sharing task state and reward information. Through this strategy of centralized training and distributed execution, efficient task allocation is ultimately achieved. Furthermore, due to its ability to continuously optimize task allocation strategies through learning, this method possesses the ability to adapt to dynamic environmental changes.

[0009] The reinforcement learning methods described above require a large amount of training data to optimize the policy, which may take a long time in practical applications, especially in complex and dynamic environments. The robots need to communicate frequently to share state and reward information, which may lead to performance degradation in environments with limited communication conditions. Summary of the Invention

[0010] To address the aforementioned shortcomings in existing technologies, the distributed heterogeneous intelligent agent task allocation method based on dynamic decision behavior trees provided by this invention solves the problems of single point of failure and communication bottlenecks in existing centralized task allocation methods, making it difficult to adapt to large-scale robot teams and complex task scenarios. At the same time, existing dynamic task allocation methods cannot fully utilize the heterogeneous capabilities of robots, resulting in low task allocation efficiency.

[0011] To achieve the aforementioned objectives, the present invention employs the following technical solution: a distributed heterogeneous agent task allocation method based on dynamic decision behavior trees, comprising the following steps: S100. Construct a dynamic decision-making behavior tree for a distributed heterogeneous intelligent agent team; the distributed heterogeneous intelligent agent team includes several robots participating in task execution. S200. In the behavior tree, the agent's capabilities are abstracted into nodes with interface constraints, and capability parameters are defined. S300: Define the capabilities of the nodes and introduce preconditions to verify the execution of the capability implementation; S400, in response to successful execution verification, during the task allocation process of the agent, when the node state changes, the capability-implementation binding function built based on the decentralized auction mechanism is used as the task allocation function, with the goal of maximizing utility, to allocate the task to the optimal agent.

[0012] Furthermore, in step S200, the capabilities of each agent are included in the behavior tree. Abstracted into nodes with a single operational semantics. Its capability parameters ; The input and output parameters in the capability parameters are represented as follows: The capabilities satisfy: In the formula, Represents capability parameters Types include inputs, outputs, and options. Represents capability parameters type This represents the set of nodes in the behavior tree. Represents a set of capabilities. This represents the set of capability parameters for all nodes. Indicates options, express power set, Representational ability The set of input parameters, Representational ability The set of output parameters.

[0013] Furthermore, in S300, the node Ability to achieve Represented as: In the formula, It represents the state of the world, including each agent's perception of the current environment and its own state. Represents a behavior tree data graph. This represents the set of nodes in the behavior tree. Represents the set of edges between nodes. Represents the set of node order. A data graph representing the data interaction and transmission relationships during the process of achieving representation capabilities. This represents the set of data sources or processing points. Describes the set of data flow paths. Represents the set of capabilities. A function representing the static mapping relationship between capability realization and capability. This function represents the dynamic mapping relationship between a given capability and all executable capability implementations, dynamically searched and filtered at runtime. Represents the set of capabilities. power set, express Functions for capability implementation The return value, Indicates capability realization Execution capability Prerequisites Indicates the ability to verify implementation A Boolean function to determine whether the preconditions are met.

[0014] Furthermore, in S300, the prerequisites for capability realization include local execution or remote execution, which are expressed as follows: In the formula, Indicates capability realization The world state or location in which it exists. Representational ability The world state or location in which it exists. This represents a Boolean function used to indicate whether a capability requires execution locally. Indicates environment, This indicates a slot in the environment that provides remote execution capabilities.

[0015] Furthermore, in S300, before the capability is implemented, its prerequisites are verified according to the current runtime context, which is expressed as follows: In the formula, Indicates preconditions medium ability Execution location , Indicates capability realization The set of preconditions, Indicates local execution. Indicates remote execution. A behavior tree data graph representing neighboring world states. This represents the set of nodes in the behavior tree of neighboring world states. express The set of edges between nodes in the middle express The node order set in the middle, It indicates the state of the neighboring world.

[0016] Furthermore, in S400, through the state update function Update the node states in the behavior tree to determine whether the node states have changed; Among them, nodes new status Represented as: In the formula, This indicates that it is not initialized. This indicates that the node encountered a systemic exception or error during execution. This indicates that the node has been initialized but not yet activated for execution. This indicates that the node has completed its execution and fulfilled its task or evaluation. This indicates that the node has completed its execution, and either the task was not completed or the evaluation result was false. This indicates that the node is executing its logic or associated tasks or behaviors. This indicates that the node has terminated and will not participate in the execution process. Indicates an unassigned state. Indicates the allocated status; Among them, the state update function This indicates that during the execution of the behavior tree, based on the current node... Actions performed and the current environment Determine the node The new state; Build capabilities - Implement binding functions Represented as: In the formula, This represents the capabilities of an intelligent agent. Represents a set of capabilities. Indicates the achievement of capability. Representational ability The set of capabilities to achieve Representational ability A collection of local capability implementations.

[0017] Furthermore, in the distributed heterogeneous agent task allocation process, the nodes in the dynamic decision behavior tree also include: Remote capability slot nodes are used to execute local capability implementations based on requests from remote intelligent agents; Capability input bridge nodes and capability output bridge nodes are used to transmit capability parameters from the capability to the capability implementation and return them through parameter synchronization.

[0018] Furthermore, for the remote capability slot node, when it receives a capability-containing... and its capabilities After the execution request is received, a new local execution environment is created. It is represented as: In the formula, This represents the local environment tree currently held by the agent that possesses the remote capability slot node. This represents the current internal state of the agent that possesses a remote capability slot node. express An arbitrary data alphabet, Indicates the state of the world.

[0019] Furthermore, the capability input bridge node and the capability output bridge node are represented as follows: In the formula, This represents the set of output parameters for calculating an object. This represents the set of input parameters for calculating an object. and These represent the input bridge node and output bridge node, respectively, representing the capabilities. Representational ability The set of input bridge nodes, Representational ability The set of output bridge nodes, The power set representing the set of capability parameters. Representational ability capability parameters Represents capability parameters The corresponding section, Represents capability parameters kind of, Represents capability parameters type This indicates that the input bridge node will be used. Mapped to the target object it bridges. This indicates that the bridge node will be output. Mapped to the bridged target object. express Bridged objects The set of input parameters, express Bridged objects The set of output parameters.

[0020] Furthermore, in the S400 process, during the agent task allocation, the following is also included: By constructing a dynamically bound state machine, the state definition of nodes in the behavior tree is extended, new states are introduced, and state transition rules are defined. For behavior in the unallocated state, when calling... And ability Interface status At that time, the capability is determined by dynamically binding a state machine - and the binding function is implemented. The ability to return; For behavior in an already assigned state, when the ability Interface status Call Set the capability interface of the dynamically bound state machine as a capability-implementation binding function. The specified behavior tree; Regarding behavior in runtime, when capabilities Interface status Call At that time, the tick is forwarded to the execution environment that implements the capability through the capability interface of the dynamically bound state machine; In the formula, Indicates the update function, Indicates the process The new execution environment returned after the update Indicates the drive signal. This indicates the execution environment of the current intelligent agent. Indicates an unassigned state. Indicates that the allocation status has been achieved. This indicates that the node is executing its logic or associated tasks or behaviors.

[0021] The beneficial effects of this invention are as follows: 1. Dynamic and real-time task allocation The core advantage of this invention lies in transforming task allocation from static configuration to runtime decision-making. Specific advantages include: Runtime dynamic assignment: The system allows users to specify tasks using behavior trees, which can then be dynamically assigned to the current robot team at runtime.

[0022] Adapting to dynamic conditions: It solves the problem that static allocation is not feasible due to dynamic runtime conditions (such as robot failure and changes in team composition), and realizes dynamic task allocation with capability awareness.

[0023] The auction mechanism enables dynamism: the system provides a runtime auction system to dynamically assign tasks to the most capable robot in the team.

[0024] Actuator switching: Experiments have shown that when team members (such as Bebop drones) join or leave, the system can adjust existing assignments through re-auctioning to minimize overall cost and take advantage of potential task parallelism. For example, the Explore task was immediately assigned to a newly joined Bebop drone because it reported lower costs.

[0025] 2. Optimization and Robustness The method of this invention, through its built-in evaluation mechanism, ensures that the allocation is not only feasible but also efficient and reliable. Specific advantages include: Improve overall efficiency: Experimental results show that the system can improve the overall efficiency of the team.

[0026] Cost-based optimization: Task assignment is based on the cost reported by each robot (e.g., distance is the primary cost factor), thus prioritizing tasks with lower overall costs.

[0027] Preventing incorrect assignments: The system uses utility values ​​and prerequisites to ensure that assignments improve the overall quality of task execution while preventing faulty assignments.

[0028] Reduced reliance on prior knowledge: By modeling prerequisites and allowing for (re)assignment of tasks, this method reduces the prior assumptions and prior knowledge required for tasks.

[0029] 3. Distributed and Decentralized Systems The architecture of this invention is designed to be decentralized, avoiding single points of failure and communication bottlenecks. Specific advantages include: Decentralization: The system goal is to implement a decentralized multi-robot task allocation system, specifically designed for heterogeneous robot teams.

[0030] Eliminating centralized authority: By adopting an auction-style approach, each robot can act as an auctioneer, thus avoiding the need for centralized authority.

[0031] 4. Modeling and Modularization This invention simplifies task definition and decouples the task from the executor by introducing behavior tree capabilities. Specific advantages include: Intuitive task specification: Behavior tree capability provides an intuitive and convenient way to build and organize robot skills, enabling rapid task construction and intuitive task specification.

[0032] Skill abstraction: "Capabilities" abstracts the skills of an individual robot into node representations of semantic operations (such as MoveToPose or OpenDoor).

[0033] Balancing modularity and robot specificity: Capabilities are used as models in task definitions, while allowing the selection of appropriate robot-dependent implementations at runtime, enabling tasks to be handled in a robot-specific manner while maintaining modularity.

[0034] Focus on skills development: The core allocation principle is to allocate capabilities to the most suitable system in real time. Therefore, the development focus has shifted to developing powerful and reusable skills for individual robots.

[0035] Support for spontaneous collaboration: Behavior tree capabilities have been experimentally proven to be an intuitive and universal system that can be used to achieve spontaneous collaboration within teams. Attached Figure Description

[0036] Figure 1 The flowchart of the distributed heterogeneous intelligent agent task allocation method based on dynamic decision behavior tree provided by the present invention is shown.

[0037] Figure 2 The state transition of the dynamic decision-making behavior tree node provided by this invention.

[0038] Figure 3 Overview of the components required for deploying and implementing the task allocation method provided by this invention.

[0039] Figure 4 The behavior tree provided for this invention. Detailed Implementation

[0040] The specific embodiments of the present invention are described below to enable those skilled in the art to understand the present invention. However, it should be understood that the present invention is not limited to the scope of the specific embodiments. For those skilled in the art, various changes are obvious as long as they are within the spirit and scope of the present invention as defined and determined by the appended claims. All inventions utilizing the concept of the present invention are protected.

[0041] This invention extends the ros_bt_py framework to design a decentralized, robust, and scalable distributed heterogeneous agent task allocation method based on dynamic decision behavior trees.

[0042] refer to Figure 1 The distributed heterogeneous agent task allocation method includes the following steps: S100. Construct a dynamic decision-making behavior tree for a distributed heterogeneous intelligent agent team; whereby the distributed heterogeneous intelligent agent team includes several robots participating in task execution. S200. In the behavior tree, the agent's capabilities are abstracted into nodes with interface constraints, and capability parameters are defined. S300: Define the capabilities of the nodes and introduce preconditions to verify the execution of the capability implementation; S400, in response to successful execution verification, during the task allocation process of the agent, when the node state changes, the capability-implementation binding function built based on the decentralized auction mechanism is used as the task allocation function, with the goal of maximizing utility, to allocate the task to the optimal agent.

[0043] In S100, an extended framework based on ros_bt_py is developed to provide each agent in the task environment with the ability to statically model itself. Task logic is encapsulated through subtrees to build a dynamic decision behavior tree, providing a flexible modular foundation for subsequent decentralized auction mechanisms and dynamic task allocation, ensuring that tasks are allocated according to the actual capabilities of the agents.

[0044] For example, the robots in the distributed heterogeneous intelligent agent team include load robots, exploration robots, and drones; the 2D map of the task environment in which the agents are located includes transportation targets, exploration targets, and paths, and different agents use this 2D map for navigation.

[0045] In S200, the capabilities of each agent are represented in the behavior tree. Abstracted into nodes with a single operational semantics. It provides an abstract representation of compound actions with a single semantic meaning, which is represented as: Define the capability parameters of a node , A triple is formed by nodes ,type and type Composition, which is represented as: The input and output parameters in the capability parameters are represented as follows: In the above formula, ability input parameter set Each in the set All three conditions must be met: Belongs to set , nodes Equal to capability node , The input and output parameter sets are the same.

[0046] If a node contains option values, these values ​​are hardcoded when defining the behavior tree, making it impossible to dynamically adjust behavior based on different conditions. Therefore, to achieve system flexibility and capability... There cannot be any option values ​​in the field, which must satisfy the following: In other words, for all those belonging to the set of abilities ability There is no parameter set. parameters , so that the parameters nodes Equal to ability And parameters kind of For options.

[0047] In the formula, Represents capability parameters Types include inputs, outputs, and options. Represents capability parameters type This represents the set of nodes in the behavior tree. Represents a set of capabilities. This represents the set of capability parameters for all nodes. Indicates options, express power set, Representational ability The set of input parameters, Representational ability The set of output parameters.

[0048] In S300, nodes only provide model information about functionality; to actually perform a task, the capability implementation needs to be defined. , For capability nodes It provides the specific execution logic.

[0049] Capability Achievement It contains a complete behavior tree, behavior tree data graph. Represented as: In the formula, This represents the set of nodes in the behavior tree, where some nodes may also be capability nodes. This represents the set of edges between nodes, i.e., the connections between nodes. This represents the set of node sequences, i.e., the execution order of the behavior tree.

[0050] For heterogeneous robots, due to differences in hardware configuration, sensor type, actuators, etc., a capability implementation can typically only operate on a specific robot. From the state of the world Specify, Depend on Arbitrary data alphabet Construction can be represented as: In the formula, It is a natural number. This includes the robot's perception of its current environment and its own state, helping the robot select the most appropriate capabilities to address the current environment and task requirements during runtime. To effectively manage data interaction and transmission during capability implementation, a data graph is defined. As shown in the following formula: In the formula, It consists of data nodes and data edges. This represents the set of data sources or processing points. A set of data flow paths.

[0051] Based on the above analysis, the nodes Ability to achieve Represented as: in, Provide execution context, Define the task execution logic. Define the data interaction logic. Represents the set of capabilities.

[0052] To share environmental information, robots can use... The function exchanges parts of the world state. The connection between the concrete execution logic and the abstract task is established by the function. Defined as follows: In the formula, A function representing the static mapping relationship between capability realization and capability. The surjective but not injective property of a function guarantees that every capability has at least one corresponding implementation, and different implementations can correspond to the same capability.

[0053] Functions statically define the relationship between implementations and capabilities. To dynamically find and filter all executable implementations of a given capability at runtime, a function needs to be defined... function: In the formula, This function represents the dynamic mapping relationship between a given capability and all executable capability implementations, dynamically searched and filtered at runtime. Represents the set of capabilities. power set, express Functions for capability implementation The return value, Indicates capability realization Execution capability Prerequisites Indicates the ability to verify implementation A Boolean function to determine whether the preconditions are satisfied. The function... Map each capability c to a set of all its currently executable implementations, including not only the existence of the implementation, but also the feasibility of its implementation and the satisfaction of its preconditions; The goal is to identify all capabilities that satisfy the following conditions. : Belongs to the implementation set ; It really is a skill The realization; capability and capability realization Executable; Capable The prerequisites have been met.

[0054] Based on the above analysis, the nodes Ability to achieve Represented as: In this embodiment, through and The dual mechanism ensures the system's flexibility, dynamism, and reliability. Then it is defined The return value must meet the following requirements: capability implementation. Belongs to the set of currently available capability implementations Capability Achievement The corresponding ability is Capability Achievement It is executable; capability implemented. The precondition was verified to be true. Ensure that a certain capability can be executed correctly and safely at runtime.

[0055] In S300, to avoid resource conflicts and erroneous execution, it is necessary to determine under what conditions an implementation can be executed. This defines the preconditions for capability implementation, including local or remote execution, as follows: In the formula, Indicates capability realization The world state or location in which it exists. Representational ability The world state or location in which it exists. This represents a Boolean function used to indicate whether a capability requires execution locally. Indicates environment, This indicates a slot in the environment that provides remote execution capabilities.

[0056] in, This usually refers to the current state of the intelligent agent or robot that possesses this implementation. This typically refers to the task interface that needs to execute this capability or the state of the caller. It is a special type of node in the environment.

[0057] For local execution conditions, indicating if the capability is achieved. and ability In the same world state, then ability It can be executed locally. It is true. Or, ability. It does not require local execution, and the capability is achieved. The agent (or environment) currently provides an available remote execution interface or slot, enabling capabilities It can be invoked and executed remotely. In this case, It is also true.

[0058] The above formula for the preconditions defines two conditions for whether capability i can execute capability c: local execution and remote execution. Either condition must be met. That is true.

[0059] To ensure the successful execution of a capability, it's necessary to check whether other tasks it depends on have been completed, i.e., specifying preconditions. All possible preconditions constitute a set. As shown in the following formula: Each precondition is a pair of tuples ,express It must be executed locally or remotely. Specify The execution location. To verify that all preconditions are satisfied before execution, the precondition function needs to return a set containing all the preconditions that capability implementation i must satisfy, as follows: Before the capability is executed, its prerequisites are verified based on the current runtime context, which is represented as follows: In the formula, Indicates preconditions medium ability Execution location , Indicates capability realization The set of preconditions, Indicates local execution. Indicates remote execution. A behavior tree data graph representing neighboring world states. This represents the set of nodes in the behavior tree of neighboring world states. express The set of edges between nodes in the middle express The node order set in the middle, It indicates the state of the neighboring world.

[0060] The verification logic for the above formula is as follows: for each precondition... if Then the ability to check Is it in the current set of nodes in the behavior tree? In the middle. If Then check the state of the neighboring world. Does there exist a behavior tree with a set of nodes? Include This ensures the presence of a robot in a remote environment, capable of performing... The required resources and status. Among them, It is a function that returns the nearest world BT. This mechanism ensures that the implementation will only be executed if all preconditions are met; if the preconditions fail to be verified, the execution of the implementation will be terminated, and no nodes will be executed. This is because the failure to meet the preconditions means that the execution environment or dependencies are not ready, and continuing execution may lead to incorrect results or abnormal behavior.

[0061] In S400, after the execution verification of the capability implementation passes, during the agent task allocation and operation process, since the capability is evaluated at runtime (dynamic binding), the definition of the node state needs to be extended to handle the implementation that may change at runtime.

[0062] Based on this, this embodiment uses a state update function. Update the node states in the behavior tree to determine whether the node states have changed; Among them, nodes new status Represented as: In the formula, This indicates the uninitialized state, the initial state of the node before it is created or has started running. This indicates that the node encountered a systemic exception or error during execution. This indicates that the node has been initialized but not yet activated for execution. This indicates that the node has completed its execution and fulfilled its task or evaluation. This indicates that the node has completed its execution, and either the task was not completed or the evaluation result was false. This indicates that the node is executing its logic or associated tasks or behaviors. This indicates that the node has terminated and will not participate in the execution process. Indicates an unassigned state. Indicates the allocated status; where, and The new state introduced in this invention is to handle the process of finding and allocating specific implementations at runtime. This is a state unique to a capability node, indicating that the capability has been determined to be executed, but a specific capability implementation has not yet been found or assigned. To execute it. This is also a state unique to capability nodes, indicating that it has been assigned. It means that the system has successfully found and bound an executable capability implementation to the capability node. Once in this state, the node can attempt to execute the implementation.

[0063] Among them, the state update function This indicates that during the execution of the behavior tree, based on the current node... Actions performed and the current environment Determine the node The new state; The expanded state based on the above formula can be applied to nodes in all behavior trees. For control flow nodes, to control the execution flow of their child nodes according to certain logic, it is necessary to update the function. Define the behavior for the relevant nodes. This function is crucial for dynamically adjusting the execution flow of the behavior tree. State transitions are as follows: Figure 2 As shown in the diagram, the state set of the standard behavior tree is expanded by adding unassigned and assigned states. It illustrates how a capability node transitions from the idle state to the unassigned state; how it transitions from the unassigned state to the assigned state after an auction to determine the implementation; and how it transitions from the assigned state to the running state to begin executing the specific implementation.

[0064] During the task allocation process The function can only determine the new state of a node. When a state change occurs, the ability to implement the binding function is based on a decentralized auction mechanism. Retrieve or update the implementation of a given capability: In the formula, This represents the capabilities of an intelligent agent. Represents a set of capabilities. Indicates the achievement of capability. Representational ability The set of capabilities to achieve Representational ability A collection of local capability implementations.

[0065] The above capabilities - implement binding functions As an allocation function, when the ability In hour, What is returned is One capability is realized in the set. In these states, the function... The value remains unchanged, meaning that once a capability is assigned an implementation, the assigned implementation will not change even if its state changes (e.g., from running to paused). Only when a reset or shutdown action is received... The value will only be reset to an empty set if the current implementation is cancelled. This mechanism ensures that capability implementations in the behavior tree can be dynamically allocated and cancelled based on the capability's state, thus adapting to different operating conditions and requirements.

[0066] In this embodiment, during the task allocation process of distributed heterogeneous intelligent agents, the nodes in the dynamic decision behavior tree also include: Remote capability slot nodes are used to execute local capability implementations based on requests from remote intelligent agents; Capability input bridge nodes and capability output bridge nodes are used to transmit capability parameters from the capability to the capability implementation and return them through parameter synchronization.

[0067] In this embodiment, a remote capability slot, RemoteCapabilitySlot, is developed. A remote capability slot is a node in the behavior tree. A remote capability slot node can execute a local capability implementation based on a request from a remote robot, and only one capability implementation can be executed at a time. When a request containing capabilities is received... and its capabilities After the execution request is received, a new local execution environment is created. It is represented as: In the formula, This represents the local environment tree currently held by the agent that possesses the remote capability slot node. This indicates the current internal state of an agent that possesses a remote capability slot node (such as battery level, health status, current task, etc.). express An arbitrary data alphabet, Indicates the state of the world.

[0068] The newly constructed environment described above exists within the world state, but uses independent... and In response to the new environment Actions are transmitted through nodes. Therefore, in the new environment... The refresh rate is the same as the node's environment. This is achieved by using CapabilityIOBridges. The internal parameter values ​​are exchanged with the remote robot and transmitted. The root state. Once a capability implementation has completed its execution, it removes all traces of itself from the environment to which the RemoteCapabilitySlot belongs, resetting it to its state before accepting requests. It uses a finite state machine similar to that of regular capability interfaces, such as... Figure 3 As shown. The main difference is that the unallocated, allocated, and running states will all revert to the unallocated state after being refreshed, and the transition from the unallocated state to the allocated state requires an external signal from the ability to request remote operation. Figure 3 The diagram illustrates the system's decentralized architecture, highlighting the key components required for dynamic task allocation and their communication relationships, including: task control, the allocation system (i.e., the auction system), the capability repository, and remote capability slots. Components marked in red are new additions to this invention.

[0069] In this embodiment, cross-machine parameter synchronization is achieved by developing CapabilityIOBridge, which includes a capability input bridge node and a capability output bridge node, respectively represented as follows: In the formula, This represents the set of output parameters for calculating an object. This represents the set of input parameters for calculating an object. and These represent the input bridge node and output bridge node, respectively, representing the capabilities. Representational ability The set of input bridge nodes, Representational ability The set of output bridge nodes, The power set representing the set of capability parameters. Representational ability capability parameters Represents capability parameters The corresponding section, Represents capability parameters kind of, Represents capability parameters type This indicates that the input bridge node will be used. It maps to the target object it bridges, which is typically an actual capability or another behavior tree node. This indicates that the bridge node will be output. Mapped to the bridged target object. express Bridged objects The set of input parameters, express Bridged objects The set of output parameters.

[0070] In this case, the capability input bridge node has no input, and the capability output bridge node has no output, as shown in the following equation: When the interface state of the capability At runtime, in each call During this period, each time Afterwards, you must ensure that: For each ability There exists an input bridge. It is through a function Acquired. Regarding abilities. Each input parameter If there is an output parameter belong The output of, then This means the input parameters The value in the world state In and output parameters The value in the environment The same applies to both.

[0071] For each ability There is an output bridge. It is through a function Acquired. Regarding abilities. Each output parameter If there is an input parameter belong The input, then This means the output parameters The value in the environment input parameters The value in the environment The two are the same.

[0072] In the S400, the agent task allocation process also includes: By constructing a dynamically bound state machine, the state definition of nodes in the behavior tree is extended, new states are introduced, and state transition rules are defined. For behavior in the unallocated state, when calling... And ability Interface status At that time, the capability is determined by dynamically binding a state machine - and the binding function is implemented. The ability to return is implemented; in In, the following conditions must be met: For behavior in an already assigned state, when the ability Interface status Call Set the capability interface of the dynamically bound state machine as a capability-implementation binding function. The specified behavior tree; its slot is when an implementation is selected to be executed on the local robot. The implementation itself. If executed on a remote robot, the implementation will be set in the available RemoteCapabilitySlot. The created local or remote execution environment is called... If completed, the node will enter the running state.

[0073] Regarding behavior in runtime, when capabilities Interface status Call At that time, the tick is forwarded to the execution environment of the capability implementation through the capability interface of the dynamically bound state machine; before the checkmark is selected, the current input value of inputs(c) will be passed to the CapabilityIOBridge using CapabilityIOBridge. In the middle. Call Using CapabilityIOBridge from Extract the new value of outputs(c) and set it. and in Update the value of outputs(c) in the middle.

[0074] In the formula, Indicates the update function, Indicates the process The new execution environment returned after the update Indicates the drive signal. This indicates the execution environment of the current intelligent agent. Indicates an unassigned state. This indicates an assigned status, meaning that an executable capability implementation has been successfully found and bound to the capability node. This indicates that the node is executing its logic or associated tasks or behaviors.

[0075] In this embodiment, the above method is implemented as an extension of the ros_bt_py framework during actual deployment, such as... Figure 4 As shown. In Figure 4In this system, each action node (such as Explore, Identify Object) is an abstract capability that is dynamically assigned to the robot for execution at runtime. Each component is implemented as a Robot Operating System (ROS) node written in Python, and the interface is a ROS service. Functions, remote function slots, input and output interfaces are all implemented as abstract BT nodes, which can be instantiated for specific input and output configurations. Capability implementations are implemented through subtrees, where only input and output nodes are used to pass information across subtree boundaries. The capability library is a distributed database of all available capabilities within the current team. It also manages the capability implementations available on the local robot. Capabilities and implementations can be added and removed at runtime. Local and remote execution management of capabilities is implemented in the task control component. For local execution, it selects the best local implementation from the capability library based on a calculated utility value. For remote execution, the best local implementation and its corresponding functionality are passed to the task assignment system. Upon receiving the best available remote robot, the local task control center triggers the execution process through communication with the remote task control center. During local or remote execution, it receives heartbeat messages and reports on execution progress. This invention first simulates a single-robot scenario as a baseline for multi-robot systems, demonstrating how a single robot manages the execution sequence of multiple tasks. The results show a preference for assigning tasks with the lowest total cost, typically manifested as executing the task with the closest physical distance. Next, a heterogeneous robot team, comprising two Husky drones and one Bebop, is simulated, demonstrating the system's adaptability when the team composition dynamically changes during task execution. During the task, the Bebop drone joins the team (green arrow), and the Explore task is immediately assigned to the Bebop drone.

[0076] Therefore, this invention enables dynamic addition and optimal allocation. While Bebop focuses on Explore, the two Husky robots can simultaneously handle tasks such as Identify and Decontaminate. This demonstrates that the invention successfully leverages the heterogeneity of the team and the parallelism of tasks, minimizing overall cost through re-auctioning. During the task execution, the Husky2 robot experienced two brief failures. Despite these failures, the system consistently provided an effective task allocation scheme, avoiding system stagnation caused by the failure of a single robot, showcasing the robustness and continuous adaptability of this invention.

[0077] Specific embodiments have been used to illustrate the principles and implementation methods of this invention. The descriptions of the embodiments above are only for the purpose of helping to understand the method and core ideas of this invention. At the same time, for those skilled in the art, there will be changes in the specific implementation methods and application scope based on the ideas of this invention. Therefore, the content of this specification should not be construed as a limitation of this invention.

[0078] Those skilled in the art will recognize that the embodiments described herein are intended to help the reader understand the principles of the invention, and should be understood that the scope of protection of the invention is not limited to such specific statements and embodiments. Those skilled in the art can make various other specific modifications and combinations based on the technical teachings disclosed in this invention without departing from the spirit of the invention, and these modifications and combinations are still within the scope of protection of this invention.

Claims

1. A distributed heterogeneous agent task allocation method based on dynamic decision behavior tree, characterized in that, Includes the following steps: S100, Construct a dynamic decision-making behavior tree for a distributed heterogeneous intelligent agent team; The distributed heterogeneous intelligent agent team includes several robots that participate in task execution; S200. In the behavior tree, the agent's capabilities are abstracted into nodes with interface constraints, and capability parameters are defined. S300: Define the capabilities of the nodes and introduce preconditions to verify the execution of the capability implementation; S400, in response to successful execution verification, during the task allocation process of the agent, when the node state changes, the capability-implementation binding function built based on the decentralized auction mechanism is used as the task allocation function, with the goal of maximizing utility, to allocate the task to the optimal agent.

2. The distributed heterogeneous agent task allocation method based on dynamic decision behavior tree according to claim 1, characterized in that, In step S200, the capabilities of each agent are included in the behavior tree. Abstracted into nodes with a single operational semantics. Its capability parameters ; The input and output parameters in the capability parameters are represented as follows: The capabilities satisfy: In the formula, Represents capability parameters Types include inputs, outputs, and options. Represents capability parameters type This represents the set of nodes in the behavior tree. Represents a set of capabilities. This represents the set of capability parameters for all nodes. Indicates options, express power set, Representational ability The set of input parameters, Representational ability The set of output parameters.

3. The distributed heterogeneous agent task allocation method based on dynamic decision behavior tree according to claim 2, characterized in that, In S300, the node Ability to achieve Represented as: In the formula, It represents the state of the world, including each agent's perception of the current environment and its own state. Represents a behavior tree data graph. This represents the set of nodes in the behavior tree. Represents the set of edges between nodes. Represents the set of node order. A data graph representing the data interaction and transmission relationships during the process of achieving representation capabilities. This represents the set of data sources or processing points. Describes the set of data flow paths. Represents the set of capabilities. A function representing the static mapping relationship between capability realization and capability. This function represents the dynamic mapping relationship between a given capability and all executable capability implementations, dynamically searched and filtered at runtime. Represents the set of capabilities. power set, express Functions for capability implementation The return value, Indicates capability realization Execution capability Prerequisites Indicates the ability to verify implementation A Boolean function to determine whether the preconditions are met.

4. The distributed heterogeneous agent task allocation method based on dynamic decision behavior tree according to claim 3, characterized in that, In S300, the prerequisites for the capability to be realized include local execution or remote execution, which are expressed as follows: In the formula, Indicates capability realization The world state or location in which it exists. Representational ability The world state or location in which it exists. This represents a Boolean function used to indicate whether a capability requires execution locally. Indicates environment, This indicates a slot in the environment that provides remote execution capabilities.

5. The distributed heterogeneous agent task allocation method based on dynamic decision behavior tree according to claim 4, characterized in that, In step S300, before the capability is executed, its prerequisites are verified based on the current runtime context, which is expressed as follows: In the formula, Indicates preconditions medium ability Execution location , Indicates capability realization The set of preconditions, Indicates local execution. Indicates remote execution. A behavior tree data graph representing neighboring world states. This represents the set of nodes in the behavior tree of neighboring world states. express The set of edges between nodes in the middle express The node order set in the middle, It indicates the state of the neighboring world.

6. The distributed heterogeneous agent task allocation method based on dynamic decision behavior tree according to claim 1, characterized in that, In S400, through the state update function Update the node states in the behavior tree to determine whether the node states have changed; Among them, nodes new state Represented as: In the formula, This indicates that it is not initialized. This indicates that the node encountered a systemic exception or error during execution. This indicates that the node has been initialized but not yet activated for execution. This indicates that the node has completed its execution and fulfilled its task or evaluation. This indicates that the node has completed its execution, and either the task was not completed or the evaluation result was false. This indicates that the node is executing its logic or associated tasks or behaviors. This indicates that the node has terminated and will not participate in the execution process. Indicates an unassigned state. Indicates the allocated status; Among them, the state update function This indicates that during the execution of the behavior tree, based on the current node... Actions performed and the current environment Determine the node The new state; Build capabilities - Implement binding functions Represented as: In the formula, This represents the capabilities of an intelligent agent. Represents a set of capabilities. Indicates the achievement of capability. Representational ability The set of capabilities to achieve Representational ability A collection of local capability implementations.

7. The distributed heterogeneous agent task allocation method based on dynamic decision behavior tree according to claim 1, characterized in that, In the distributed heterogeneous agent task allocation process, the nodes in the dynamic decision behavior tree also include: Remote capability slot nodes are used to execute local capability implementations based on requests from remote intelligent agents; Capability input bridge nodes and capability output bridge nodes are used to transmit capability parameters from the capability to the capability implementation and return them through parameter synchronization.

8. The distributed heterogeneous agent task allocation method based on dynamic decision behavior tree according to claim 7, characterized in that, For the remote capability slot node, when it receives a capability... and its capabilities After the execution request is received, a new local execution environment is created. It is represented as: In the formula, This represents the local environment tree currently held by the agent that possesses the remote capability slot node. This represents the current internal state of the agent that possesses a remote capability slot node. express An arbitrary alphabet of data, Indicates the state of the world.

9. The distributed heterogeneous agent task allocation method based on dynamic decision behavior tree according to claim 7, characterized in that, The capacity input bridge node and the capacity output bridge node are represented as follows: In the formula, This represents the set of output parameters for calculating an object. This represents the set of input parameters for calculating an object. and These represent the input bridge node and output bridge node, respectively, representing the capabilities. Representational ability The set of input bridge nodes, Representational ability The set of output bridge nodes, The power set representing the set of capability parameters. Representational ability capability parameters Represents capability parameters The corresponding section, Represents capability parameters kind of, Represents capability parameters type This indicates that the input bridge node will be used. Mapped to the target object it bridges. This indicates that the bridge node will be output. Mapped to the bridged target object. express Bridged objects The set of input parameters, express Bridged objects The set of output parameters.

10. The distributed heterogeneous agent task allocation method based on dynamic decision behavior tree according to claim 3, characterized in that, In S400, the process of allocating tasks to the intelligent agent also includes: By constructing a dynamically bound state machine, the state definition of nodes in the behavior tree is extended, new states are introduced, and state transition rules are defined. For behavior in the unallocated state, when calling... And ability Interface status At that time, the capability is determined by dynamically binding a state machine - and the binding function is implemented. The ability to return; For behavior in an already assigned state, when the ability Interface status Call Set the capability interface of the dynamically bound state machine as a capability-implementation binding function. The specified behavior tree; Regarding behavior in runtime, when capabilities Interface status Call At that time, the tick is forwarded to the execution environment that implements the capability through the capability interface of the dynamically bound state machine; In the formula, Indicates the update function, Indicates the process The new execution environment returned after the update Indicates the drive signal. This indicates the execution environment of the current intelligent agent. Indicates an unassigned state. Indicates that the allocation status has been achieved. This indicates that the node is executing its logic or associated tasks or behaviors.

Images