Robot Behavior Adaptive Control System and Method

Abstract

This application discloses a robot behavior adaptive control system and method, relating to the field of robot behavior control technology. The system includes a behavior library module configured to store multiple pre-built, reusable robot behavior components; a behavior tree engine module configured to connect to the behavior library module for logical orchestration and scheduling calculations of the behavior components; and an artificial intelligence optimization module configured to connect to both the behavior tree engine module and the behavior library module for dynamically optimizing the execution parameters of the behavior components and / or the behavior tree structure of the behavior tree engine module based on real-time sensor data and historical behavior data. This robot behavior adaptive control system and method, by introducing an artificial intelligence optimization module to dynamically optimize pre-built behavior components and behavior tree structures, enhances the robot's mobility in unstructured environments and improves task execution success rate and system robustness.

Description

Technical Field

[0001] This application relates to the field of robot behavior control technology, and in particular to a robot behavior adaptive control system and method. Background Technology

[0002] Existing robotics software platforms, such as open-source frameworks, typically do not provide pre-built behavior libraries for motion planning and task execution.

[0003] To improve development efficiency, some solutions attempt to establish reusable behavior module libraries. However, once deployed, the internal parameters and execution logic of these behavior module libraries are fixed. When faced with unforeseen interference in unstructured environments (such as object sliding or sudden path blockage), the system cannot adjust itself using real-time sensor data and can only mechanically execute preset processes or fail with errors. Summary of the Invention

[0004] This application provides a robot behavior adaptive control system and method, which improves the robot's ability to move in unstructured environments by introducing an artificial intelligence optimization module to dynamically optimize pre-built behavior components and behavior tree structures, thereby solving the above-mentioned technical problems.

[0005] The technical solution to the above problems in this application is: to provide a robot behavior adaptive control system, which includes: a behavior library module configured to store multiple pre-built reusable robot behavior components; a behavior tree engine module configured to be connected to the behavior library module for logical orchestration and scheduling calculation of the behavior components; and an artificial intelligence optimization module configured to be connected to the behavior tree engine module and the behavior library module for dynamically optimizing the execution parameters of the behavior components and / or the behavior tree structure of the behavior tree engine module based on real-time sensor data and historical behavior data.

[0006] This application introduces an artificial intelligence optimization module that collaborates with the behavior library module and behavior tree engine module to transform pre-built behavior components from "fixed code blocks" into "intelligent units that can be tuned online." This breaks down the conflict between reusability and flexibility, and solves the "rigidity" problem of pre-built behavior components in practical applications. Furthermore, the artificial intelligence optimization module continuously optimizes based on real-time and historical data, enabling the entire system to dynamically adjust (in response to sudden changes) action logic (behavior tree structure) and execution parameters (parameters of behavior components) in unstructured environments, thereby improving task success rate and robustness.

[0007] In some embodiments, the artificial intelligence optimization module includes at least one pre-trained machine learning model for analyzing the real-time sensor data, the execution status feedback of the behavior tree engine module and / or the execution result feedback of the behavior component, and outputting parameter optimization instructions for the behavior component and / or issuing structural reorganization instructions to the behavior tree engine module.

[0008] This application employs a pre-trained machine learning model for data analysis and decision-making, enabling the optimization process to handle complex perceptual information and make intelligent predictions, thereby improving the accuracy and intelligence of optimization decisions. Secondly, it explicitly uses the execution status feedback of the behavior tree engine module and the execution result feedback of the behavior components as the basis for optimization, forming a complete data loop from "perception" to "decision-making" and then to "execution effect evaluation." This allows the system to learn and adjust itself based on the actual consequences of actions, making optimization more targeted and effective.

[0009] In some embodiments, the machine learning model includes a deep neural network model and / or a reinforcement learning model.

[0010] This application utilizes a deep neural network model to process high-dimensional, unstructured real-time sensor data (such as visual images) to achieve a deep understanding of the environmental state; it uses a reinforcement learning model to find the optimal strategy through trial and error in sequential decision-making, which is very suitable for dynamically optimizing the behavior tree logical structure, providing a preferred technical path for achieving efficient optimization and enhancing the feasibility and expected results of the solution.

[0011] In some embodiments, the behavior component is encapsulated as a standalone plug-in with standardized input / output interfaces and configured to receive optimization instructions from the artificial intelligence optimization module via a data interaction interface.

[0012] This application ensures that behavioral components can be uniformly scheduled and efficiently reused by the behavior tree engine module by encapsulating them as independent plug-ins with standardized input / output interfaces. Meanwhile, a specially configured data interaction interface for receiving AI optimization instructions provides a secure and controllable "adjustment channel" for the artificial intelligence optimization module, providing a reliable foundation for "dynamic optimization" at the system architecture level. This enables the optimization instructions of the artificial intelligence optimization model to be accurately and stably injected into the specific running components, achieving dynamic and secure modification of runtime parameters.

[0013] In some embodiments, a task constructor module is further included, configured to be connected to the behavior tree engine module, for receiving task instructions from the user and constructing a task tree; the behavior tree engine module is used to schedule the behavior components according to the task tree to form a sequence of behavior control instructions to drive the robot.

[0014] This application can use the task constructor module to parse and construct a structured task tree from the abstract task instructions given by the user. This adds a clear task planning layer on top of the execution logic of the behavior tree engine module, enabling the system to handle more complex multi-step composite tasks and ensuring the consistency and traceability of the transformation from high-level goals to low-level action sequences, thereby improving the system's ability to understand and process high-level task intentions.

[0015] In some embodiments, the task constructor module also updates the task tree in real time based on changes in the user's task instructions, so that the behavior tree engine module can reschedule subsequent behavior control instruction sequences that have not yet been actually executed by the robot based on the updated task tree.

[0016] In this application, when the user's task instructions change during runtime, the system does not need to suspend or restart the entire task. Instead, it can update the internal task tree representation in real time and only re-plan and schedule the subsequent behavior sequences that have not yet been executed. This enhances the system's flexibility and interactivity during execution, reduces efficiency losses caused by changes in task objectives, and gives the system the ability to respond quickly to sudden changes in instructions at the task execution level.

[0017] In some embodiments, the system further includes an instruction conversion module configured to convert the behavior control instructions into a standardized sequence of robot control instructions via a hardware abstraction interface.

[0018] This application uses a hardware abstraction interface to convert upper-level behavior control instructions into a standardized sequence of control instructions. This enables the core behavior control system of this application, which includes artificial intelligence optimization capabilities, to be deployed on robot hardware of different configurations and brands without extensive modifications. This greatly improves the versatility, portability, and application scope of the entire technical solution and decouples the algorithm logic from the specific robot hardware platform.

[0019] This application also provides a robot behavior adaptive control method, applied to the control system described in any of the preceding paragraphs, comprising the following steps: loading pre-built behavior components from the behavior library module; calling and organizing the behavior components to form task execution logic through a behavior tree engine module; running the task execution logic through the behavior tree engine module; and during operation, analyzing the real-time sensor data, the execution status feedback of the behavior tree engine module, and / or the execution result feedback of the behavior components in real time through an artificial intelligence optimization module, so as to dynamically adjust the parameters of the behavior components corresponding to the executed task and / or dynamically adjust the execution logic of the behavior tree engine module.

[0020] This application defines a complete, closed-loop adaptive robot behavior control process, which not only makes full use of pre-built component libraries to ensure development efficiency and reliability, but more importantly, it clarifies the core link of real-time dynamic adjustment based on multi-source feedback "during operation" to ensure that the adaptive optimization of the system is continuous and accompanying, thereby guaranteeing the robot's ability to cope with environmental uncertainties at the methodological level.

[0021] In some embodiments, the dynamic adjustment of parameters of the behavioral component corresponding to the task being performed includes: analyzing and predicting real-time sensor data based on a pre-trained machine learning model; and generating and sending parameter adjustment instructions to the currently invoked behavioral component based on the analysis and prediction results.

[0022] This application uses machine learning models to analyze real-time sensor data and fine-tunes the parameters of specific behavioral components (such as grasping force and tracking speed) of the currently performing task online. This enables the robot to adapt compliantly to subtle environmental disturbances such as object surface characteristics and changes in lighting, thereby significantly improving the accuracy and success rate of operations while ensuring task continuity, and achieving subtle, continuous, and real-time optimization of the robot's actions.

[0023] In some embodiments, the dynamic adjustment of the execution logic of the behavior tree engine module includes: based on the analysis results of the execution status feedback and / or the execution result feedback, when it is determined that the task currently being executed by the robot has a risk of failure, or the execution efficiency is lower than a preset efficiency threshold, the artificial intelligence optimization module generates a structural modification suggestion; the behavior tree engine module responds to the structural modification suggestion by reorganizing the branch structure of the behavior tree to enable alternative behavior logic or insert new rollback and recovery nodes.

[0024] In this application, when the current task is determined to be high-risk or inefficient based on feedback analysis, the artificial intelligence optimization module will trigger the structural reorganization of the behavior tree, such as switching to a backup plan or inserting an error recovery process. This "monitor-evaluate-reconstruct" mechanism enables the system to cope with more fundamental environmental changes or initial planning defects, demonstrating a higher level of intelligent decision-making and strong fault-tolerant self-recovery capabilities. It also gives the system the ability to reconstruct macro-level behavioral logic online when faced with strategy-level failures or inefficiencies.

[0025] Additional aspects and advantages of this application will be described or shown in part in the following description, or illustrated by practice of the embodiments of this application. Attached Figure Description

[0026] To more clearly illustrate the technical solutions of the embodiments of this application, the drawings used in the description of the embodiments of this application will be briefly introduced below. Obviously, the drawings described below are only some embodiments of this application. For those skilled in the art, other drawings can be obtained based on these drawings without creative effort.

[0027] Figure 1 A schematic diagram of a robot behavior adaptive control system provided in this application embodiment;

[0028] Figure 2 A flowchart illustrating a robot behavior adaptive control method provided in an embodiment of this application; Figure 3 A schematic flowchart illustrating a method for dynamically adjusting the parameters of a behavior component as provided in an embodiment of this application; Figure 4 This is a flowchart illustrating the method for dynamically adjusting the execution logic of the behavior tree engine module provided in an embodiment of this application. Detailed Implementation

[0029] To make the objectives, technical solutions, and advantages of this application clearer, the following detailed description is provided in conjunction with the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are for illustrative purposes only and are not intended to limit the scope of this application. All other embodiments obtained by those skilled in the art based on the embodiments in this application without inventive effort are within the scope of protection of this application.

[0030] It should be noted that, unless there is a conflict, the various features in the embodiments of this application can be combined with each other, all of which are within the protection scope of this application. Furthermore, although functional modules are divided in the device schematic diagram and a logical order is shown in the flowchart, in some cases, the steps shown or described can be executed in a different order than the module division in the device or the order in the flowchart. Moreover, the terms "first," "second," and "third" used in this application do not limit the data or execution order, but only distinguish identical or similar items with essentially the same function and effect.

[0031] Please see Figure 1 An embodiment of this application discloses a robot behavior adaptive control system, comprising: a behavior library module configured to store multiple pre-built reusable robot behavior components; a behavior tree engine module configured to be connected to the behavior library module for logical orchestration and scheduling calculation of the behavior components; and an artificial intelligence optimization module configured to be connected to the behavior tree engine module and the behavior library module for dynamically optimizing the execution parameters of the behavior components and / or the behavior tree structure of the behavior tree engine module based on real-time sensor data and historical behavior data.

[0032] Specifically, please refer to Figure 1 This application provides a robot behavior adaptive control system. Implemented at the software level, it is deployed in the robot's main control computing unit; its core includes a behavior library module, a behavior tree engine module, and an artificial intelligence optimization module, all of which are collaborative software algorithm modules.

[0033] The behavior tree engine module accesses the behavior library module through a well-defined application programming interface (API) to query and call the stored behavior components. The behavior tree engine module and the artificial intelligence optimization module share a common data area called the "context manager." The behavior tree engine module writes its real-time running status (such as currently active nodes and task progress) to this context manager, while the artificial intelligence optimization module reads this status information from the context manager, as well as the aggregated real-time sensor data (such as camera images and LiDAR point clouds). At the same time, the artificial intelligence optimization module sends specific optimization instructions to the specific behavior component instance that is currently executing the task through the standardized configuration interface reserved for each behavior component by the behavior library module.

[0034] It should be noted that real-time sensor data is collected into the context manager through a separate sensor data driving and fusion module. This sensor data driving and fusion module polls or subscribes to the robot's various hardware buses (such as ROS topics) at a fixed frequency, reads the raw sensor data (such as camera image topics, LiDAR point cloud topics, IMU data topics), performs timestamp synchronization and preliminary filtering, and then writes it in real time to a specific data area in the shared context manager in a structured format (e.g., a data frame containing "timestamp", "sensor ID", and "data volume"). The artificial intelligence optimization module and the behavior components that require sensor data read the latest data from this area.

[0035] The behavior components stored in the behavior library module are the smallest schedulable algorithm units that encapsulate specific and complete robot functions. They are not physical structures themselves, but software packages. For example, they may include object recognition behavior components, joint space trajectory generation behavior components, force control grasping behavior components, etc. Each behavior component receives predefined input parameters, executes its internal algorithm, and returns a standard status such as "success", "failure" or "running".

[0036] Behavior trees are typically built automatically based on user task instructions. For example, when a user's task instruction is "pick up the red part", the task instruction will be broken down into a sequence of sub-tasks such as "locate the part", "plan the grab path", and "execute the grab". Each sub-task is mapped to one or more behavior components in the behavior library, and then organized into an initial behavior tree according to logical relationships such as sequence and selection.

[0037] The logical orchestration and scheduling calculation process of the behavior tree engine module is driven by a periodic signal called "Tick". Starting from the root node, this signal traverses the tree structure from top to bottom. When it encounters a "sequence" control node, it triggers the execution of its child nodes sequentially, returning success only when all child nodes succeed. If it encounters a "selection" control node, it attempts child nodes sequentially until one succeeds. Finally, when the "Tick" signal reaches a behavior node, the behavior tree engine module calls the corresponding behavior component (such as a path planning algorithm) and determines the subsequent process based on the status returned by the called behavior component, thus implementing complex decision-making and rollback logic.

[0038] The dynamic optimization of the AI ​​optimization module is specifically manifested in its internal pre-trained model, which continuously analyzes real-time sensor data (from the robot's physical sensors) and a historical behavior database (a local or cloud-based structured database (e.g., SQLite or MySQL database) that continuously records metadata for each task execution during system operation, forming "historical behavior data." This data typically includes: task ID, the behavior tree structure used, the input parameters and output state of each behavior component, the final task result (success / failure), key performance indicators (such as time consumption and energy consumption), and an environmental snapshot (such as a summary of the sensor data at that time) triggered the optimization; this database is automatically written and updated by the system after each task execution). For example, the pre-trained model receives real-time feature vectors from the context manager (e.g., current obstacle distance, robot end-effector velocity, gripping force readings) and related historical features retrieved from the historical database (e.g., the past 10 successful / failed records of grasping similar objects under similar gripping forces), and performs forward propagation calculations on these features to obtain the raw numerical results of the output layer.

[0039] The raw numerical result needs to be parsed by a post-processing decision layer: For parameter optimization, the decision layer maps the raw numerical result (such as a scalar representing the adjustment range) to a specific parameter adjustment instruction with units (e.g., 'increase the clamping force setting by 3.5 Newtons'); for structural optimization, the decision layer may apply argmax or threshold judgment to the raw numerical result (such as the scores of each candidate subtree) to generate a clear 'structural modification suggestion' (e.g., 'suggest switching to the candidate grabbing subtree with ID 1024'). Finally, the generated standardized instruction or suggestion is sent to the corresponding behavior component or behavior tree engine module through a standardized interface.

[0040] In this way, the system can self-adjust and adapt during operation.

[0041] In some embodiments, the artificial intelligence optimization module includes at least one pre-trained machine learning model for analyzing real-time sensor data, as well as the execution status feedback of the behavior tree engine module and / or the execution result feedback of the behavior components, and outputting parameter optimization instructions for the behavior components and / or issuing structural reorganization instructions to the behavior tree engine module.

[0042] Specifically, the AI ​​optimization module is implemented as a software decision service integrating at least one pre-trained machine learning model. The AI ​​optimization module continuously receives multi-source inputs via the system's data bus: firstly, real-time sensor data streams from the sensor-driven layer (e.g., RGB-D images captured by a stereo camera, point clouds generated by LiDAR, and readings from a six-dimensional force / torque sensor); secondly, execution status feedback from the behavior tree engine module (typically provided in the form of structured logs, such as the currently active behavior node ID, runtime since the task started, and the traversal path of each control node in the most recent "Tick" loop); and thirdly, execution result feedback from each behavior component (e.g., the confidence score returned by the "visual positioning component," and the cumulative error between the actual trajectory and the planned trajectory reported by the "robotic arm motion component"). Before being input into the model, this data is preprocessed by a feature extraction and fusion submodule, converting heterogeneous data into standardized feature vectors that the model can accept.

[0043] The pre-trained machine learning model within this module (e.g., a hybrid model of a deep convolutional neural network and a long short-term memory recurrent neural network) is responsible for analyzing the transformed feature vectors. The machine learning model performs forward propagation computation, outputting raw numerical results without business logic interpretation. These raw numerical results are then fed into a lightweight post-processing decision layer, which maps the raw numerical values ​​into specific, executable control instructions based on preset rules and thresholds.

[0044] Specifically, for parameter optimization of behavioral components, the decision layer generates instructions based on the model's analysis of real-time sensor data. For example, when the model identifies that the target object of the current "visual servo grasping component" has smooth surface features (derived from real-time image analysis), and combines this with the pattern of high grasping slippage rates for similar features marked in the historical database, the decision layer will generate a clear parameter optimization instruction, such as "increase the preset value of the gripping force by 20% and decrease the servo gain coefficient Kp by 0.1." This parameter optimization instruction is sent directly to the specific behavioral component instance currently executing the task through the standardized configuration interface defined for each component by the behavior library module, enabling dynamic fine-tuning at runtime.

[0045] For the structural reorganization of behavior tree logic, the decision layer mainly relies on the time-series analysis of execution status and result feedback by the machine learning model to generate suggestions. For example, when the machine learning model detects that the "laser-based corridor navigation component" returns to the "failure" state three times in a short period of time (execution result feedback), and the status feedback of the behavior tree engine module shows that the system has fallen into a loop of the same "selection" node (execution status feedback), the decision layer will trigger the reorganization logic and generate a structural reorganization instruction. Its content may be "replace the 'laser navigation' node with ID N-107 in the current behavior tree with the 'visual inertial odometry navigation' subtree with ID N-203". This instruction does not directly modify the behavior tree, but is published in the form of a message to the dedicated instruction topic subscribed to by the behavior tree engine module.

[0046] Upon hearing this message, the behavior tree engine module will call its internal structure management interface during its next safe scheduling interval (e.g., at the beginning of a "Tick" cycle after the current behavior node has finished executing) to perform the node replacement, insertion, or deletion operation specified by the structure reorganization instruction, thereby achieving online and safe reconstruction of the overall task logic.

[0047] In some embodiments, the machine learning model includes a deep neural network model and / or a reinforcement learning model.

[0048] Specifically, the machine learning models included in the AI ​​optimization module are implemented as deep neural network models and / or reinforcement learning models, which complement each other to serve the system's dynamic optimization objectives. When using a deep neural network model, it is typically a multimodal fusion network whose input layer is designed to receive and process heterogeneous data from different sensors; for example, a parallel network structure can simultaneously process RGB image streams from a camera (extracting visual features through convolutional neural network branches) and point cloud sequences from a LiDAR (extracting geometric features through point cloud neural network branches), and fuse these features with scalar data (such as grasping force error) fed back from behavioral components in a fully connected layer. The model learns the mapping relationship between complex environmental states and optimal parameter adjustments through offline training; at runtime, it compares the real-time perceived scene (such as the reflective properties of object materials and surface tilt) with historical successful grasping data patterns, and through forward propagation calculations, directly outputs a set of precise, low-latency parameter adjustment instructions, such as "adjust the end-effector approach speed to 0.15 m / s" or "relax the attitude alignment threshold to 5 degrees." This deep neural network-based implementation is particularly suitable for scenarios that require rapid interpretation of high-dimensional sensing signals and the generation of instantaneous optimal decisions.

[0049] In other embodiments, the machine learning model included in the AI ​​optimization module can also be a reinforcement learning model, which is trained as an intelligent agent interacting with the robot's environment and task objectives. Its state space is defined as all observable information in the system context manager (including sensor data, behavior tree states, and component feedback), and its action space corresponds to the set of all adjustable behavioral component parameters and executable behavior tree structure reorganization operations (such as calling a candidate subtree). This model learns a value function or policy function through extensive interactions with a simulated environment or a real robot, either online or offline. During deployment and runtime, reinforcement learning models do not only react to the current instantaneous state, but also make decisions based on their predictions of the long-term rewards of the task (such as the final success rate and total time). For example, in a long-term exploration task of a mobile robot, when the model observes that the battery power is continuously decreasing (historical behavior data) and there is a communication blind spot ahead of the current path (real-time sensor data), it may decide to trigger a structural reorganization instruction, switching the original "detailed exploration" behavior tree branch to a backup branch of "quickly returning to the charging area". This reinforcement learning-based implementation is good at handling sequential decision problems and can perform long-term strategy planning and optimization during task execution.

[0050] Furthermore, in some more complex embodiments, deep neural networks and reinforcement learning models can be combined in a hybrid architecture to work together. The deep neural network, acting as the "sensory organ" or "world model" of the reinforcement learning agent, is responsible for extracting high-level, decision-useful state features from raw sensor data, while the reinforcement learning model performs high-level policy learning and decision-making based on these refined features. This division of labor enables the system to process rich perceptual information and perform complex sequence optimization, jointly achieving comprehensive and adaptive adjustment of robot behavior from micro-parameters to macro-logic.

[0051] In some embodiments, the behavior component is encapsulated as a standalone plug-in with standardized input / output interfaces and configured to receive optimization instructions from the AI ​​optimization module via a data interaction interface.

[0052] Specifically, behavior components exist as highly modular software, encapsulated as independent plugins with standardized input / output interfaces. Each plugin is physically an independent dynamic link library file (e.g., a .so file on Linux systems), containing the complete implementation code for a specific robot function (such as "visual servo grasping" or "dynamic obstacle avoidance"). These plugins adhere to a unified interface specification, which mandates that each plugin expose a set of predefined function handles, including but not limited to: an initialization function for receiving global configuration; an execution function as the main entry point for component logic; a termination function for releasing resources; and a crucial callback function specifically for receiving optimization instructions. All plugins are dynamically loaded, registered, and managed by a central plugin manager at system startup. The behavior tree engine module queries this plugin manager to locate and invoke the corresponding plugin instance based on the plugin identifier defined in the behavior tree node (e.g., "grasping_planner_v2.so").

[0053] The standardized input / output interface is reflected in two aspects: First, the input parameters are not directly passed to the execution function. Instead, the behavior tree engine module writes the task-related context information (such as the coordinates of the target object and the maximum allowed speed) into a shared data area called the "blackboard" before execution. The execution function obtains the input required for this execution by accessing the specified fields of the "blackboard". Second, the output is strictly limited to a few enumerated states, namely "success", "failure" or "running". After the called behavior component has completed the execution of its core algorithm, it must map the result to one of these three states and return it to the behavior tree engine module, thereby driving the subsequent logic flow of the tree.

[0054] When the AI ​​optimization module determines that parameters need to be adjusted for a currently executing or about-to-execute behavioral component (e.g., deciding to adjust the proportional gain coefficient Kp of the "Path Tracking Controller" component from 1.5 to 2.0), it does not directly manipulate the internal variables of that behavioral component. Instead, it constructs a structured optimization instruction message. This message contains a unique identifier for the behavioral component instance and a list of key-value pairs (e.g., {"Kp": 2.0, "max_velocity": 0.8}). Subsequently, the AI ​​optimization module sends this instruction either by calling a service provided by the plugin manager or directly to a thread-safe message queue held by the currently executing or about-to-execute behavioral component instance.

[0055] The callback function of the behavior component is designed to be interrupted or periodically checked while remaining thread-safe; once a new instruction is received, the function immediately parses the key-value pairs and performs a safe parameter update operation within the behavior component (e.g., assigning the new Kp value to the internal control variable).

[0056] This process ensures that optimization instructions can be injected into running behavioral logic in a low-latency and highly reliable manner, enabling dynamic fine-tuning of runtime behavior without restarting components or interrupting task flow. This pluggable and standardized interface design gives the system's behavior library excellent scalability and maintainability, and provides a solid technical foundation for its collaboration with upper-layer AI optimization modules.

[0057] In some embodiments, a task constructor module is also included, configured to connect to the behavior tree engine module, for receiving user task instructions and constructing a task tree; the behavior tree engine module is used to schedule behavior components according to the task tree to form a sequence of behavior control instructions to drive the robot.

[0058] Specifically, the task constructor module is implemented as an independent software planning service, which establishes a bidirectional communication connection with the behavior tree engine module through a remote procedure call interface or a service call mechanism based on message middleware.

[0059] The core function of the task constructor module is to act as a translator between high-level intent and low-level execution. Its input consists of unstructured or semi-structured task instructions received from the user, which can be provided through a graphical user interface, natural language text, or voice-translated commands (e.g., "Assemble the red gear on the workbench onto the blue bushing on the left"). Internally, the task constructor module includes a task parsing and reasoning layer. It first performs semantic analysis on the original instructions (the user's unstructured or semi-structured task instructions), identifying key operational objects ("red gear," "blue bushing"), the target action ("assemble onto"), and spatial constraints ("on the workbench," "left side"). Subsequently, referring to a predefined task ontology library, the task constructor module decomposes the abstract goal into a hierarchical flowchart composed of atomic or composite subtasks—the task tree. For example, the above instructions may be broken down into four main sub-task sequences: "locating the red gear", "picking up the gear", "locating the blue bushing", and "performing precision assembly". The "picking up the gear" sub-task may be further broken down into finer-grasping steps such as "moving to the pre-grabbing pose", "performing the grab", and "lifting up". Each tree node not only contains a task description, but also metadata such as success conditions and failure handling strategies. The completed task tree is serialized into a standard data exchange format and sent to the behavior tree engine module through the connection interface as its execution blueprint.

[0060] Upon receiving the task tree, the behavior tree engine module initiates a dynamic instantiation and scheduling process. The scheduler of the behavior tree engine module traverses each node of the task tree and maps it to the corresponding specific behavior component plugin in the behavior library module (for example, the "Locate the red gear" node in the task tree will trigger the behavior tree engine module to find and load the "Color and Shape Recognition Behavior Component" and the "3D Pose Estimation Behavior Component"). This mapping relationship is maintained through a registry, ensuring the accurate conversion of task logic to executable code. Next, the behavior tree engine module begins scheduling the execution of these behavior components according to the control logic defined in the task tree, such as the order, selection, or parallel execution.

[0061] The scheduling does not generate all instructions at once, but rather proceeds on demand and progressively: the behavior tree engine module first schedules the execution of the first behavior component (such as the "color and shape recognition component"). When this behavior component is executed, it reads real-time sensor data from the aforementioned context management area, performs calculations, writes its output (such as the estimated pose of a gear) back to the context management area, and returns a "success" status. After receiving the success feedback, the behavior tree engine module schedules the next component (such as the "3D pose estimation component") according to the task tree logic to refine the results.

[0062] Each behavioral component, after executing its core algorithm, generates low-level, specific control commands, such as a set of target joint angles, a Cartesian space path, or a gripper opening / closing instruction. The behavior tree engine module continuously collects, integrates, and arranges these low-level control command fragments generated by the various scheduled behavioral components in chronological order, ultimately combining them into a coherent, time-synchronized sequence of behavioral control instructions. This sequence constitutes the detailed action script that drives the joint motors and end effectors of the real robot to complete the entire "assembly" task from "perception" to "operation," thereby achieving an automated and structured transformation from abstract user instructions to specific robot actions.

[0063] In some embodiments, the task constructor module also updates the task tree in real time based on changes in the user's task instructions, enabling the behavior tree engine module to reschedule subsequent behavior control instruction sequences that have not yet been actually executed by the robot based on the updated task tree.

[0064] Specifically, the task constructor module is further configured as a real-time planning service with dynamic response capabilities. Its purpose is to handle changes in user task instructions during runtime and update the issued task tree safely and efficiently accordingly. This module continuously monitors the user instruction input channel through a resident instruction listening and difference detection service. When a new task instruction is received (for example, if the user updates the instruction to "send the part to inspection station B" during the execution of the original instruction "send the part to inspection station A"), the service immediately initiates a rapid analysis process: First, the new instruction is parsed and a new potential task tree is generated; then, it is compared with the task tree currently being executed by the behavior tree engine module. The comparison algorithm identifies the first semantic branching node in the two trees starting from the root node and marks all subtrees after this branching node as "areas to be updated".

[0065] The key is that the task constructor module combines the execution status feedback obtained in real time from the behavior tree engine module to accurately determine which atomic actions the robot has actually completed (e.g., the "pick up part" action has been completed, and the "start moving" action is in progress), thereby further defining the "area to be updated" as subsequent task branches that have not yet been actually executed by the robot's physical system.

[0066] Subsequently, the task constructor module initiates an atomic tree structure update operation. Instead of drastically replacing the entire tree, it generates a structured "update patch" instruction. This instruction explicitly specifies the node IDs to be modified or replaced, the new subtree structure to be inserted, and necessary state transition instructions. This "update patch" is immediately sent to the behavior tree engine module via a low-latency communication link (such as shared memory or a high-priority message queue). Internally, the behavior tree engine module employs a state-consistent scheduling coordinator. At a safe boundary point (e.g., when the currently executing behavior component reaches an interruptible checkpoint and returns a "success" state), it suspends scheduling of subsequent branches of the original task tree. Then, the coordinator applies the received "update patch," modifying its internally maintained task tree representation online and in a transactional manner, replacing or adjusting only those branches marked as future, while ensuring that the context of all currently executing nodes is properly preserved or migrated.

[0067] After the update, the behavior tree engine module immediately recalculates the scheduling based on the updated task tree. Starting from the safety boundary point that was just completed, it re-plans the calling order and parameters of subsequent behavior components according to the new task logic. For example, in the parts delivery scenario, the behavior tree engine module will stop calculating the subsequent path to "inspection station A" and instead begin scheduling a series of new components: first, calculating the new path to "inspection station B", and then executing the new movement command. All these reschedulings generate a new sequence of behavior control instructions (starting from the new path point sequence), which will seamlessly connect to the completed action sequence to form a coherent and ultimately complete action flow that conforms to the latest user intent.

[0068] The entire process, from instruction modification to the start of execution of the new sequence, is completed within hundreds of milliseconds, achieving efficient adaptation to dynamic changes at the task level while ensuring system state consistency and execution process safety. In some embodiments, the system further includes an instruction conversion module configured to convert behavior control instructions into a standardized sequence of robot control instructions via a hardware abstraction interface.

[0069] Specifically, the instruction conversion module is implemented as a key system middleware, responsible for translating the hardware-independent "behavior control instruction sequence" generated by upper-level decisions into a "standardized robot control instruction sequence" that can directly drive the physical robot. It is decoupled from the underlying robot hardware through a well-designed hardware abstraction interface layer. This module continuously monitors the behavior control instruction stream output by the behavior tree engine module. These instructions are high-level, functional descriptions, such as "move the end effector of the robotic arm linearly at a speed of 0.2 m / s to its pose (X, Y, Z, Rx, Ry, Rz) in the world coordinate system" or "hold with a force of 15 N until the perceived positional deviation is less than 2 mm." Internally, the instruction conversion module maintains a robot hardware description file and a kinematic / dynamic model library. When a behavior control instruction is received, the module first determines the specific configuration of the target robot (e.g., a six-axis serial robotic arm, a four-wheel differential mobile chassis), joint parameters, and bus protocol (e.g., EtherCAT, CANopen) based on the hardware description file. Subsequently, the conversion engine calls the corresponding algorithm to translate the functional instruction into specific hardware commands.

[0070] For example, for the aforementioned linear movement command, the command conversion module uses an inverse kinematics model to calculate the sequence of angles each joint needs to reach, and then interpolates a smooth joint trajectory based on the robot's dynamic characteristics. This encapsulates the aforementioned movement command into a data packet format required by the target hardware controller (such as a periodic synchronization position command for a specific brand of driver). This encapsulation process strictly follows the standardized command format defined internally by the command conversion module. This format may be a cross-platform intermediate representation (such as a JointTrajectory message based on ROS Control), characterized by describing only the final, controller protocol-independent motion intent (such as "Joint 1 moves at a constant speed to 30 degrees within 2 seconds"). The hardware abstraction interface layer provides a series of device driver adapters, each responsible for converting the standardized command format into native protocol commands that can be recognized by a specific type of motor driver, sensor, or end effector. Ultimately, the standardized instruction sequence generated by the instruction conversion module and adapted through the hardware abstraction interface is stably and periodically sent to the robot's joint motor controllers and I / O modules via a real-time network or bus, precisely driving the robot to complete physical actions, thus realizing a closed loop from the intelligent decision-making layer to the physical execution layer.

[0071] In some embodiments, this application also provides a robot behavior adaptive control method, using the system of any of the foregoing embodiments, the method comprising: S1. Load pre-built behavior components from the behavior library module; S2. Through the behavior tree engine module, call and organize behavior components to form task execution logic; S3. Run the task execution logic through the behavior tree engine module; S4. During operation, the AI ​​optimization module analyzes real-time sensor data, execution status feedback from the behavior tree engine module, and / or execution result feedback from the behavior components in real time to dynamically adjust the parameters of the behavior components corresponding to the task being performed and / or dynamically adjust the execution logic of the behavior tree engine module.

[0072] Specifically, in this embodiment, when the robot behavior adaptive control system in any of the aforementioned embodiments is started, the behavior tree engine module queries the behavior library module and dynamically loads one or more pre-built behavior component plugins from the behavior library module into the corresponding storage space according to the requirements of the task to be executed. These behavior component plugins (such as path planning and visual recognition plugins) complete their own initialization during loading, registering their standardized input / output interfaces and internal parameter configuration interfaces to the system's global service directory to prepare for subsequent scheduling.

[0073] Subsequently, the behavior tree engine module begins to orchestrate logic based on the initial task blueprint issued by the task constructor module or predefined; it calls the loaded behavior component instances in sequence according to the structured rules of the behavior tree (such as sequence, selection, and parallelism).

[0074] Specifically, the behavior tree engine module generates an initial component call graph by parsing the task tree, and sets the input parameters required for each component's current execution in the "blackboard" shared data area according to this graph (for example, setting the target point coordinates for the "move" component). This organizes the discrete component capabilities into a coherent task execution logic that can accomplish complex goals. This logic is represented internally by the behavior tree engine module as a traversable and evaluable runtime behavior tree data structure.

[0075] Next, the behavior tree engine module runs the task execution logic in a loop through its internal scheduler. The scheduler generates a "Tick" signal at a fixed frequency (e.g., 100 times per second), and performs a depth-first traversal starting from the root node of the behavior tree. Whenever the "Tick" reaches a behavior node, the behavior tree engine module calls the execution function of the behavior component instance bound to it, so that the corresponding behavior component instance can access the "blackboard" to obtain input, execute its internal algorithm (e.g., calculate a trajectory), and return the status result of "success", "failure" or "running" to the behavior tree engine module. Based on the returned status and the rules of the control nodes in the tree, the behavior tree engine module determines the next node to be "Ticked", thereby driving the entire task logic to move forward step by step, and gradually generating the underlying behavior control instruction sequence (e.g., trajectory point sequence) in the process.

[0076] Throughout the entire task execution process, the AI ​​optimization module works continuously as a background process. It receives and caches real-time sensor data streams (such as LiDAR frames and image frames) from sensor-driven systems via the system data bus. At the same time, it subscribes to and reads execution status feedback (such as the current active node ID and task stage) published by the behavior tree engine module, as well as execution result feedback (such as location confidence and trajectory tracking error) reported by various behavioral components. These multimodal data are fused into a time-aligned feature vector, which is then input into a pre-trained machine learning model (such as a deep neural network) within the AI ​​optimization module for forward propagation computation and inference analysis.

[0077] Based on the inference analysis results, the AI ​​optimization module implements two types of dynamic adjustments: First, parameter adjustment. When the AI ​​optimization module recognizes an environmental change (such as detecting a slippery surface on the target object), it immediately sends a parameter adjustment instruction (e.g., "increase the preset gripping force by 25%) to the currently executing behavior component (e.g., the "grasping" component) through the configuration interface registered by the currently executing behavior component. Second, logical structure adjustment. When the AI ​​optimization module determines, based on historical behavior data, that the current execution path has a high failure risk, it issues a structure reorganization instruction to the behavior tree engine module (e.g., "replace node A with backup solution B"). The behavior tree engine module responds to this instruction in the next safety scheduling interval, modifying its internal behavior tree structure without interrupting system stability, thereby changing the subsequent execution logic flow to form a real-time closed loop from perception, execution to evaluation and optimization. This enables the robot to dynamically adapt to unstructured environments, significantly improving task robustness and autonomy.

[0078] In some embodiments, dynamically adjusting the parameters of the behavioral component corresponding to the task being performed includes: S411. Analyze and predict real-time sensor data based on pre-trained machine learning models; S412. Based on the analysis and prediction results, generate and send parameter adjustment instructions to the currently invoked behavior component.

[0079] Specifically, the process of dynamically adjusting the parameters of the behavioral components corresponding to the executed task is a real-time fine-tuning mechanism tightly embedded in the system's operating loop. When the behavior tree engine module schedules a behavioral component (e.g., a "force-controlled assembly component") for execution, the dedicated data pipeline in the artificial intelligence optimization module synchronously captures real-time sensor data streams strongly correlated with the task of that behavioral component (e.g., contact force and torque vectors fed back in real time by a six-dimensional force / torque sensor, and workpiece mating surface images captured by a high-frame-rate vision camera). These captured real-time sensor data are immediately fed into a pre-trained, lightweight deep neural network model (e.g., a convolutional-fully connected hybrid network specifically designed for predicting assembly states and optimal adjustment amounts) for online inference.

[0080] This neural network model analyzes the input data stream through forward propagation calculations. Its output is not a direct control command, but a set of raw results containing predicted states and suggested adjustments. For example, based on the waveform characteristics of the force sensor and the edge alignment pixel deviation of the workpiece in the visual image, the neural network model predicts that "there is currently a lateral misalignment of about 0.5 mm, and the contact force is climbing toward the friction limit," and thus generates an implicit suggestion: "A small position compensation needs to be applied in the positive X-axis direction, and the downforce should be slightly reduced."

[0081] Next, the raw results are passed to an instruction generation and arbitration submodule within the AI ​​optimization module. This submodule, based on a pre-defined strategy mapping table bound to specific component types, transforms the abstract predictions and suggestions into precise parameter adjustment instructions that the behavioral component can understand and execute. For example, it maps the aforementioned analysis results into a well-formatted instruction message: {component_id: “force_controlled_insertion”,command:“SET_PARAM”,params: {“offset_x”: +0.0005,“force_z_setpoint”:-2.0}}, meaning “Increase the X-axis offset parameter of the component with ID 'force_controlled_insertion' by 0.0005 meters and decrease the Z-axis downforce setting by 2.0 Newtons.”

[0082] Subsequently, the instruction is sent directly to the standardized configuration interface of the specific behavior component instance currently being called by the behavior tree engine module 'Tick' via an extremely low-latency inter-process communication mechanism (such as atomic operations pointing to shared memory or real-time message queues). The behavior component instance safely receives and parses the instruction in its execution thread and immediately applies the new parameter values ​​in its next control cycle, thereby enabling dynamic, online fine-tuning of the execution behavior to offset predicted problems and ensure that tasks (such as precision assembly) are performed smoothly and successfully.

[0083] In some embodiments, dynamically adjusting the execution logic of the behavior tree engine module includes: S421. Based on the analysis results of the execution status feedback and / or execution result feedback, when it is determined that the task currently being executed by the robot has a risk of failure, or the execution efficiency is lower than a preset efficiency threshold, the artificial intelligence optimization module generates structural modification suggestions. S422. The behavior tree engine module responds to structural modification suggestions by reorganizing the branch structure of the behavior tree to enable alternative behavior logic or insert new fallback and recovery nodes.

[0084] Specifically, the AI ​​optimization module continuously monitors execution status feedback from the behavior tree engine module (provided in the form of structured data streams, such as the path of the currently active behavior node, the cumulative execution time of each node, and frequent trigger records of the condition checker) and execution result feedback from various behavior components (such as the low confidence scores continuously returned by the "object recognition component" and the repeated planning timeout status reported by the "navigation component"). This feedback data is fed into a dedicated sequence analysis model (e.g., a combination of a long short-term memory network and a logic rule engine) for real-time evaluation. This sequence analysis model calculates the real-time failure probability estimate and efficiency evaluation index (such as the progress / time ratio) of the current task branch by analyzing patterns in the feedback data (e.g., the "visual positioning" component failing three times consecutively under specific lighting conditions) and combining this with querying related cases in the historical behavior database.

[0085] When the sequence analysis model determines that the failure probability exceeds the safety threshold, or the efficiency index is consistently lower than a preset efficiency threshold, the decision logic is triggered. Subsequently, the artificial intelligence optimization module generates a precise structural modification suggestion based on its internal pre-built "strategy-solution" mapping library. This suggestion is an operable data structure that clearly indicates the target modification point (such as the "visual positioning" selection node identified as ID_101 in the behavior tree), the suggested operation type (such as "node replacement" or "sub-node insertion"), and the specific content reference for replacement or insertion (such as the identifier Backup_Subtree_05 pointing to the backup logic "laser and odometry fusion positioning" subtree).

[0086] Following this, the behavior tree engine module responds to the structural modification suggestion and reorganizes the branching structure of the behavior tree. Internally, the behavior tree engine module has a reorganization request processor. Upon receiving a structural modification suggestion from the AI ​​optimization module, it does not immediately interrupt the currently executing atomic action. Instead, it seeks a safe reorganization boundary point, typically the instant after the behavior component instance currently being "ticked" completes its current execution cycle and returns a definite status (success or failure). At this moment, the behavior tree engine module pauses the scheduling of subsequent nodes and initiates an atomic reorganization transaction. Based on the suggestion, the reorganization request processor performs precise operations on the data structure of the running behavior tree; for example, unlinking the node identified as ID_101 from its parent node and linking the subtree described by Backup_Subtree_05 back to its original position; or, before determining potentially risky sequence nodes, inserting a new fallback and recovery node with additional condition checks and retry logic.

[0087] After the reorganization is completed, the behavior tree engine module immediately continues its scheduling loop from the point of modification, calling behavior components based on the new branch structure; for example, the system will no longer try the repeatedly failed "visual positioning", but will instead execute the alternative behavior logic of "laser and odometry fusion positioning".

[0088] It should be noted that in the above embodiments, there is no necessarily a certain order between the steps. Those skilled in the art can understand from the description of the embodiments of this application that the above steps may have different execution orders in different embodiments, that is, they may be executed in parallel or in turn, etc.

[0089] Furthermore, the robot behavior adaptive control system provided in this application embodiment can be a software module. The software module includes several instructions stored in a memory. The processor can access the memory, call the instructions for execution, and complete the robot behavior adaptive control method described in the above embodiments.

[0090] In other embodiments, the robot behavior adaptive control system can also be built from hardware devices; for example, the robot behavior adaptive control system can be built from one or more chips, which can work together to complete the robot behavior adaptive control method described in the various embodiments above. Furthermore, the robot behavior adaptive control system can also be built from various logic devices, such as general-purpose processors, digital signal processors (DSPs), application-specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), microcontrollers, ARM (Acorn RISC Machine) or other programmable logic devices, discrete gate or transistor logic, discrete hardware components, or any combination of these components.

[0091] It should be noted that the above-described robot behavior adaptive control system can execute the robot behavior adaptive control method provided in the embodiments of this application, and has the corresponding functional modules and beneficial effects of the method. Technical details not described in detail in the embodiments of the robot behavior adaptive control device can be found in the robot behavior adaptive control method provided in the embodiments of this application.

[0092] In some embodiments, this application also provides a computer device including one or more processors and a memory, wherein the memory is connected to one or more processors, for example, via a bus.

[0093] The processor is configured to support the computer device in performing the corresponding functions in the methods described in the above method embodiments; the processor may be a central processing unit (CPU), a network processor (NP), a hardware chip, or any combination thereof. The aforementioned hardware chip may be an application-specific integrated circuit (ASIC), a programmable logic device (PLD), or a combination thereof. The aforementioned PLD may be a complex programmable logic device (CPLD), a field-programmable gate array (FPGA), a generic array logic (GAL), or any combination thereof.

[0094] Memory is used to store program code, etc. Memory can include volatile memory (VM), such as random access memory (RAM); memory can also include non-volatile memory (NVM), such as read-only memory (ROM), flash memory, hard disk drive (HDD), or solid-state drive (SSD); memory can also include combinations of the above types of memory.

[0095] The memory can be used to store non-volatile software programs, non-volatile computer-executable programs, and modules, such as the robot behavior adaptive control system in the embodiments of this application. The processor executes various functional applications and data processing of the robot behavior adaptive control system and robot behavior adaptive control method by running the non-volatile software programs, instructions, and modules stored in the memory, that is, it realizes the functions of each module or unit of the robot behavior adaptive control system and robot behavior adaptive control method provided in the above method embodiments.

[0096] The memory may include a program storage area and a data storage area. The program storage area may store the operating system and application programs required for at least one function. The data storage area may store data created based on the use of the robot's adaptive control system.

[0097] In some embodiments, the memory may optionally include memory remotely located relative to the processor, which can be connected to the robot behavior adaptive control system via a network. Examples of such networks include, but are not limited to, the Internet, corporate intranets, local area networks, mobile communication networks, and combinations thereof.

[0098] The one or more modules are stored in the memory. When executed by the one or more processors, they perform the robot behavior adaptive control method in any of the above method embodiments. For example, they perform the method steps described in the above method embodiments to realize the functions of the modules described in the above device embodiments.

[0099] This application also provides a computer-readable storage medium storing a computer program, the computer program including program instructions, which, when executed by a computer device, cause the computer device to perform the method described in any of the foregoing embodiments.

[0100] Those skilled in the art will understand that all or part of the processes in the above embodiments can be implemented by a computer program instructing related hardware. The program can be stored in a computer-readable storage medium, and when executed, it can include the processes of the embodiments of the above methods. The storage medium can be a magnetic disk, optical disk, read-only memory (ROM), or random access memory (RAM), etc.

[0101] The above-disclosed embodiments are merely preferred embodiments of this application and should not be construed as limiting the scope of this application. Therefore, any equivalent variations made in accordance with the claims of this application shall still fall within the scope of this application.

Claims

1. A robot behavior adaptive control system, characterized in that, include: The behavior library module is configured to store multiple pre-built, reusable robot behavior components; The behavior tree engine module is configured to connect to the behavior library module for logical orchestration and scheduling calculation of the behavior components; An artificial intelligence optimization module is configured to connect to the behavior tree engine module and the behavior library module, and is used to dynamically optimize the execution parameters of the behavior components and / or the behavior tree structure of the behavior tree engine module based on real-time sensor data and historical behavior data.

2. The system according to claim 1, characterized in that, The artificial intelligence optimization module includes at least one pre-trained machine learning model for analyzing the real-time sensor data, the execution status feedback of the behavior tree engine module, and / or the execution result feedback of the behavior component, and outputting parameter optimization instructions for the behavior component and / or issuing structural reorganization instructions to the behavior tree engine module.

3. The system according to claim 2, characterized in that, The machine learning model includes a deep neural network model and / or a reinforcement learning model.

4. The system according to claim 1, characterized in that, The behavioral component is encapsulated as a standalone plug-in with standardized input / output interfaces and is configured to receive optimization instructions from the artificial intelligence optimization module via a data interaction interface.

5. The system according to claim 1, characterized in that, It also includes a task constructor module, configured to connect to the behavior tree engine module, for receiving user task instructions and building a task tree; The behavior tree engine module is used to schedule the behavior components according to the task tree to form a sequence of behavior control instructions to drive the robot.

6. The system according to claim 5, characterized in that, The task constructor module also updates the task tree in real time based on changes in the user's task instructions, so that the behavior tree engine module can reschedule subsequent behavior control instruction sequences that have not yet been actually executed by the robot based on the updated task tree.

7. The system according to claim 5, characterized in that, It also includes an instruction conversion module, configured to convert the behavior control instructions into a standardized robot control instruction sequence through a hardware abstraction interface.

8. A method for adaptive control of robot behavior, characterized in that, Using the system of any one of claims 1-7, the method comprises: Load pre-built behavior components from the behavior library module; The behavior tree engine module calls and organizes the behavior components to form task execution logic; The task execution logic is executed through the behavior tree engine module; During operation, the AI ​​optimization module analyzes the real-time sensor data, the execution status feedback of the behavior tree engine module, and / or the execution result feedback of the behavior components in real time to dynamically adjust the parameters of the behavior components corresponding to the task being performed and / or dynamically adjust the execution logic of the behavior tree engine module.

9. The method according to claim 8, characterized in that, The dynamic adjustment of parameters of the behavioral components corresponding to the executed task includes: Analyze and predict real-time sensor data based on pre-trained machine learning models; Based on the analysis and prediction results, parameter adjustment instructions are generated and sent to the currently invoked behavior component.

10. The method according to claim 8, characterized in that, The dynamic adjustment of the execution logic of the behavior tree engine module includes: Based on the analysis results of the execution status feedback and / or the execution result feedback, when it is determined that the task currently being executed by the robot has a risk of failure, or the execution efficiency is lower than a preset efficiency threshold, the artificial intelligence optimization module generates a structural modification suggestion. In response to the structural modification suggestion, the behavior tree engine module reorganizes the branch structure of the behavior tree to enable alternative behavior logic or insert new fallback and recovery nodes.

Images