Method and system for failure loop correction of behavior tree based on attribution record

Abstract

The application discloses a behavior tree execution failure closed-loop correction method and system based on attribution records, and belongs to the technical field of robot learning and control. The method takes an executable behavior tree composed of a parameterized skill operator library as an object, executes the behavior tree, generates an attribution record containing a fault node, an associated operator, a violated predicate, a current symbolic state and an expected symbolic state when the execution fails, classifies the fault into three categories of precondition failure, postcondition failure and action execution failure according to the fault node type, and accordingly performs targeted local correction on the affected operator - corrects the symbolic interface when the condition is wrong, corrects the motion model when the action is not executable, and each correction only acts on the corresponding component of the affected operator without propagating changes to other operators. After correction, the behavior tree is regenerated and executed, and the cycle is repeated until the execution is successful or the maximum number of iterations is reached. The method maintains the symbolic condition as an explicit revisable entity, supports targeted fault recovery without re-teaching, and does not limit the generation source of the behavior tree.

Description

Technical Field

[0001] This invention relates to the field of robot learning and control technology, and in particular to an automatic attribution and targeted closed-loop correction method and system for behavior tree execution failure. Background Technology

[0002] In robotic manipulation tasks, behavior trees are widely used to organize and schedule robot maneuvering skills due to their modular, interpretable, and reactive control characteristics. Combining teaching learning with behavior trees allows for the extraction of motor skills and symbolic conditions from teaching data and their organization into executable behavior trees, enabling non-expert users to easily program robots. However, due to limited teaching data, noise in perception, and changes in the deployment environment over time, behavior trees inevitably fail during actual execution, thus requiring effective fault recovery mechanisms.

[0003] Existing behavior tree-based fault handling methods have several limitations. Some methods pre-write static recovery branches into the behavior tree structure, executing predefined alternative recovery actions when the main task node fails. However, the recovery behavior of these methods is fixed before deployment and cannot handle new fault types that emerge during deployment and were not foreseen by the designers. Some methods rely on manual intervention, requiring operators to manually specify corrections through an interactive interface after failure, resulting in low automation and limited efficiency. Other methods re-plan or re-teach from the top level after failure, discarding existing learning results and incurring high recovery costs. Still other methods use reinforcement learning to adjust recovery behavior online, but require a large number of samples, making it difficult to meet the need for rapid recovery.

[0004] Analysis of the aforementioned existing technologies reveals the following structural limitations:

[0005] First, there is the problem of static and fixed recovery mechanisms. The recovery behaviors of existing methods are mostly written into the behavior tree with a fixed structure before deployment, which cannot dynamically determine the correction content based on the actual faults that occur at runtime, and lacks adaptability to unforeseen fault types.

[0006] Second, there is the problem of unmodifiable symbolic conditions. Existing methods typically compile preconditions and postconditions inferred from the teaching process as fixed constraints into a tree structure. Symbolic conditions do not exist as independent, operable objects, and users cannot directly view or modify them at runtime. After a failure, the entire program must be re-taught or the program structure must be modified offline.

[0007] Third, address the problem of lacking locality and being prone to diffusion. Existing methods often cause global changes when making corrections. For example, re-teaching may reset all skills, or correcting one area may affect other learned skills, resulting in the correction of one area destroying many others and making it difficult to retain existing learning outcomes. Summary of the Invention

[0008] To address the problems of static and fixed recovery mechanisms, unmodifiable symbolic conditions, and lack of locality in correction in existing technologies, this invention provides a closed-loop correction method and system for execution failure based on a behavior tree with attribution records. The method uses an executable behavior tree composed of a parameterized skill operator library as the object. Upon execution failure, it automatically generates a structured attribution record, performs targeted local corrections on the affected operators according to the fault type, and iterates and verifies until success, achieving fault recovery without re-teaching. Validation on a collaborative robotic arm platform shows that for scenarios with conditional deviations, the recovery time of this method is reduced by approximately 64% compared to comparative methods; for scenarios where movement is infeasible, the recovery time is reduced by approximately 42% compared to comparative methods.

[0009] The technical solutions for each step are explained in detail below.

[0010] Step S1: Obtain the behavior tree to be executed and execute the behavior tree: The system takes the target predicate set and the initial symbol state as input and starts execution from the executable behavior tree composed of the parameterized skill operator library; wherein, the source of the generation of the behavior tree is not limited, and it can be obtained by teaching learning, generated by language model or written manually, as long as it is composed of parameterized skill operators containing symbolic interface and motion model;

[0011] Step S2, Attribution Record Generation: When the behavior tree execution fails, the system generates an attribution record quintuple A = ( , , , , ),in For the faulty node where failure occurred, For the operators associated with this node, To violate the predicate, The current symbol state, The expected symbolic state; this structured record encodes an execution failure into the smallest machine-processable diagnostic unit, enabling failure localization to be refined from restarting the entire process to a single component of a single operator;

[0012] Step S3, Fault Classification: The system automatically classifies faults into three categories based on the type of fault node: when the precondition check node returns failure before execution, it is determined as a precondition failure, indicating that the current state does not meet the premise assumptions of the skill; when the postcondition check node returns failure after the action is executed, it is determined as a postcondition failure, indicating that the action did not produce the expected state change; when the action node itself returns failure, it is determined as an action execution failure, indicating that the movement strategy is not feasible due to environmental changes; since the types of behavior tree nodes themselves contain semantics, fault classification can be completed automatically without manual judgment.

[0013] Step S4, targeted local correction: The system guides correction actions according to the fault category: If the fault is a condition error (precondition failure or postcondition failure), the symbol interface of the associated operator is corrected, including adjusting predicate parameters, adding predicate conditions, or deleting predicate conditions; if the fault is that the action is not executable (action execution failure), the motion model of the associated operator is corrected, including adjusting motion parameters or relearning the motion trajectory of the affected segment.

[0014] Steps S5 and S6, closed-loop verification: After the correction is completed, the system regenerates the behavior tree based on the updated operator library and executes it; if the execution is successful, the operator library is considered to have converged; if it still fails, the attribution record is generated again and the above attribution, classification and correction process is repeated; this verification-revision loop continues until the execution is successful or the maximum number of iterations is reached.

[0015] Preferably, each correction applies only to the corresponding component of the associated operator and does not propagate changes to other operators in the parameterized skill operator library, thereby preserving the existing learning results of other operators while recovering from the fault. This is the core feature that distinguishes this invention from overall replanning or re-teaching methods.

[0016] Preferably, the present invention maintains symbolic conditions as explicit, viewable, and revisable entities. Symbolic conditions include precondition predicates, postcondition predicates, and effect predicates, rather than being compiled and fixed as tree structures. Therefore, correction operations can be directly applied to the corresponding fields of the affected operators without re-parsing the entire behavior tree.

[0017] A behavior tree-based failure closed-loop correction system based on attribution records, characterized in that it includes:

[0018] The behavior tree execution module is configured to execute an executable behavior tree composed of a parameterized skill operator library;

[0019] The attribution record generation module is configured to generate attribution records containing the faulty node, associated operators, violated predicates, current symbol state, and expected symbol state when execution fails.

[0020] The fault classification module is configured to classify faults into precondition failure, postcondition failure, and action execution failure based on the type of the fault node.

[0021] The correction module is configured to perform targeted local corrections on the associated operators based on the fault category, including a symbol interface correction unit for correcting the symbol interface and a motion model correction unit for correcting the motion model, and each correction only applies to the corresponding component of the associated operator.

[0022] The operator library management module is configured to maintain symbolic conditions as explicitly revisable entities and write the correction results back to the affected operators;

[0023] The replanning and execution module is configured to regenerate the behavior tree after correction and execute it, looping until execution is successful or the maximum number of iterations is reached.

[0024] The technical advantages of this invention are as follows: through structured attribution recording, automatic fault classification based on node semantics, and targeted local correction, this invention can quickly recover after execution failure without re-teaching, while retaining the learning results of other operators. Validation on a collaborative robotic arm platform shows that for scenarios with conditional deviations caused by perceptual biases, the recovery time of this method is reduced by approximately 64% compared to comparative methods; for scenarios where movement is infeasible due to environmental changes, the recovery time is reduced by approximately 42% compared to comparative methods. Furthermore, since this invention does not limit the source of the behavior tree generation, its closed-loop correction mechanism is applicable to any executable behavior tree composed of parameterized skill operators. Attached Figure Description

[0025] Figure 1 This is a schematic diagram of the system structure of the present invention, showing the connection relationship and data flow between the behavior tree execution module, the attribution record generation module, the fault classification module, the two correction branches of symbol interface correction and motion model correction, the operator library management module, and the replanning and execution module;

[0026] Figure 2 This is a schematic diagram of the closed-loop correction process of the present invention, showing the complete closed-loop process from target predicate and initial symbol state input, behavior tree generation, execution, success or failure judgment, attribution record generation, fault classification, symbol interface correction or motion model correction, operator library update to replanning. Detailed Implementation

[0027] The specific embodiments of the present invention will be described in detail below with reference to the accompanying drawings. It should be understood that the specific embodiments described herein are only for explaining the present invention and are not intended to limit the present invention.

[0028] I. Overall Implementation Plan. (Refer to...) Figure 1 and Figure 2 This invention takes the target predicate set and initial symbol state as input and starts execution from an executable behavior tree composed of a parameterized skill operator library. If execution is successful, the operator library is considered to have converged; if execution fails, the system generates an attribution record, classifies the fault according to the type of fault node, and performs targeted local corrections on the affected operators. Then, the behavior tree is regenerated and executed, and the process is repeated until success or the maximum number of iterations is reached.

[0029] II. Experimental Platform Configuration. This invention was validated on a six-DOF collaborative robotic arm equipped with a pneumatic gripper. Visual perception was provided by an RGB-D depth camera, and object localization was achieved through visual tags. The software infrastructure was implemented on a robot operating system framework, and behavior tree construction and execution were handled by an open-source behavior tree execution framework.

[0030] III. Specific Implementation of Attribution Record Generation. When the behavior tree execution fails, the system captures the faulty node where the failure occurred. Determine the operators associated with it. Identify the predicate violations within them. And collect the current symbol state. With expected symbolic state Assembled into a quintuple of attribution records A =< , , , , >. If the action fails to execute, the predicate is violated. It can be empty, in which case the correction path is directly determined by the type of the faulty node.

[0031] IV. Specific Implementation of Fault Classification and Correction. The system determines the fault category based on the fault node type and performs corresponding corrections. For failures of preconditions and postconditions, the symbolic interface of the affected operator is corrected; for failures of action execution, the motion model of the affected operator is corrected. During the correction process, symbolic conditions are directly updated as explicitly revisable entities, and the correction only applies to the corresponding fields of the affected operator; the symbolic interfaces and motion models of other operators in the operator library are unaffected.

[0032] V. Verification of Examples

[0033] Example 1 (Condition Deviation Scenario). In a material handling task, sensor drift causes incorrect inference of preconditions, resulting in the precondition check node continuously returning failures. The system generates an attribution record, where the faulty node is the precondition check node and the associated operator is the material handling operator. Violation of predicate e (targe The current symbol state indicates that the predicate is not satisfied, while the expected symbol state requires the predicate to be true. Based on this, the system determines the fault as a failure of the precondition and corrects the symbol interface of the transport operator: removing the incorrectly inferred predicate from the transport operator. Removed from the set of precondition predicates. This modification only applies to the transport operator. The symbolic interface fields, symbolic interfaces of other operators in the operator library, and motion models were unaffected. After correction, the behavior tree was regenerated and executed, and the task was successfully recovered in approximately 10 seconds, a reduction of about 64% compared to the approximately 28 seconds of the comparison method.

[0034] Example 2 (Infeasible Motion Scenario). A fixed obstacle is introduced into the execution path, causing the action node to fail due to collision. The system generates an attribution record, where the faulty node is the action node, the associated operator is the affected motion operator, the violated predicate is empty, and the action execution failure is directly determined by the faulty node type. Based on this, the system corrects the motion model of the operator and relearns the motion trajectory of the affected segment to bypass the obstacle. This correction only applies to the motion model of this operator; other operators in the operator library are unaffected. After correction and re-execution, the task is successfully recovered, with a recovery time of approximately 18 seconds, a reduction of approximately 42% compared to the approximately 31 seconds of the comparison method.

[0035] The above embodiments are only used to illustrate the technical solutions of the present invention, and are not intended to limit them; those skilled in the art should understand that they can still modify the technical solutions described in the foregoing embodiments, or make equivalent substitutions for some of the technical features, and these modifications or substitutions do not cause the essence of the corresponding technical solutions to deviate from the scope of the technical solutions of the present invention.

Claims

1. A method for correcting execution failure loops based on behavior trees using attribution records, characterized in that, Taking an executable behavior tree composed of a parameterized skill operator library as the object, wherein each operator in the parameterized skill operator library includes a symbolic interface and a motion model, the method includes: Step S1: Obtain the behavior tree to be executed and execute the behavior tree; Step S2: When execution fails, an attribution record is generated, which includes the faulty node, the operator associated with the faulty node, the violated predicate, the current symbolic state, and the expected symbolic state. Step S3: Classify the faults according to the type of the faulty node; Step S4: Perform targeted local corrections on the associated operators according to the fault category: when the fault is a condition error, correct the symbol interface of the associated operator; when the fault is an action that cannot be executed, correct the motion model of the associated operator; wherein, each correction only applies to the corresponding component of the associated operator and does not propagate the change to other operators in the parameterized skill operator library; Step S5: Regenerate the behavior tree after correction and execute; Step S6: Repeat steps S1 to S5 until successful execution or the maximum number of iterations is reached.

2. The method according to claim 1, characterized in that, In step S2, the attribution record is represented as a quintuple A = ( , , , , ),in The faulty node, For operators associated with the faulty node, To violate the predicate, The current symbol state, This represents the expected symbol state.

3. The method according to claim 1, characterized in that, In step S3, the faults are classified into three categories according to the type of fault node: when the precondition check node returns failure, it is determined as a precondition failure, indicating that the current state does not meet the required preconditions; when the postcondition check node returns failure after the action is executed, it is determined as a postcondition failure, indicating that the action did not produce the expected state change; when the action node returns failure, it is determined as an action execution failure, indicating that the motion strategy is not feasible due to environmental changes.

4. The method according to claim 3, characterized in that, In step S4, when the fault is a failure of the precondition or a failure of the postcondition, the symbolic interface of the association operator is corrected. The correction of the symbolic interface includes adjusting the predicate parameters, adding predicate conditions, or deleting predicate conditions. When the fault is a failure of action execution, the motion model of the association operator is corrected. The correction of the motion model includes adjusting the motion parameters or relearning the motion trajectory of the affected segment.

5. The method according to claim 1, characterized in that, The symbolic interface includes a set of precondition predicates, a set of postcondition predicates, and a set of effect predicates. The symbolic conditions are maintained as explicit, viewable, and revisable entities, so that the corrections can be directly applied to the corresponding fields of the association operators without re-parsing the entire behavior tree.

6. The method according to claim 1, characterized in that, The executable behavior tree is generated by a parameterized skill operator library. The source of the generation is not limited, including behavior trees generated by instruction learning, generated by a language model, or manually written. The closed-loop correction method is applicable to any executable behavior tree composed of parameterized skill operators.

7. A behavior tree-based failure closed-loop correction system based on attribution records, characterized in that, include: The behavior tree execution module is configured to execute an executable behavior tree composed of a parameterized skill operator library; The attribution record generation module is configured to generate attribution records containing the faulty node, associated operators, violated predicates, current symbol state, and expected symbol state when execution fails. The fault classification module is configured to classify faults into precondition failure, postcondition failure, and action execution failure based on the type of the fault node. The correction module is configured to perform targeted local corrections on the associated operators based on the fault category, including a symbol interface correction unit for correcting the symbol interface and a motion model correction unit for correcting the motion model, and each correction only applies to the corresponding component of the associated operator. The operator library management module is configured to maintain symbolic conditions as explicitly revisable entities and write the correction results back to the affected operators; The replanning and execution module is configured to regenerate the behavior tree after correction and execute it, looping until execution is successful or the maximum number of iterations is reached.

Images