Skill tree-based embodied intelligent robot control method, device and equipment

Abstract

Embodiments of the present application provide a somatic intelligent robot control method, device and equipment based on skill tree, belonging to the technical field of intelligent robots. The method comprises: in response to receiving a task instruction, acquiring a current skill node and a target state indicated by the task instruction; matching the target state with a pre-constructed skill tree to determine a target skill node corresponding to the target state; searching for a feasible path from the current skill node to the target skill node in the skill tree, and generating a task plan composed of at least one skill node according to the feasible path; and calling skill operations encapsulated by each skill node in sequence according to the task plan to drive the somatic intelligent robot to complete the task instruction. In the above manner, the target state is mapped to the skill tree node at one time, and then the feasible path is searched, so that the task plan is automatically generated, and the reuse rate of the skill of the somatic intelligent robot is improved.

Description

Technical Field

[0001] This application belongs to the field of embodied intelligent robot technology, specifically relating to a control method, device, and equipment for embodied intelligent robots based on a skill tree. Background Technology

[0002] With the advancement of Industry 4.0 and flexible manufacturing, a production line often needs to switch between different models and processes within hours; the SKUs and shelf layouts of logistics and warehousing are dynamically adjusted daily; and unstructured scenarios such as homes and hospitals involve diverse tasks and changing parameters. This requires embodied intelligent robots to move beyond "one task, one program" and instead continuously complete multi-step, cross-scenario collaborative operations such as "grasping-assembly-inspection," "handling-sorting-replenishment," and "cleaning-care-delivery" on the same body.

[0003] Currently, embodied intelligent robots generally adopt a "physical body + intelligent agent" architecture: the physical body integrates multiple sensors such as vision, force, and laser, and realizes environmental state perception through fusion algorithms; the intelligent agent relies on a preset rule base or deep reinforcement learning model to map the perception results into action commands. However, regardless of the rule base or end-to-end network, its underlying skill modules (such as "tightening screws", "plugging plugs", "suction cup picking up boxes") are still hard-coded in a task-specific way: developers need to reset the coordinates, force control thresholds and motion trajectories for specific parameters such as screw distribution, plug orientation, and box size; otherwise, the robot cannot directly reuse old skills to complete new tasks.

[0004] However, the skill modules are hard-coded for specific tasks, so when the scene parameters change, the skill modules need to be redeveloped, which reduces the reuse rate of the embodied intelligent robot's skills. Summary of the Invention

[0005] This application provides a skill tree-based control method, apparatus, and device for embodied intelligent robots, which solves the problem that skill modules are hard-coded in a task-specific manner, requiring redevelopment of skill modules when scene parameters change, thus reducing the reusability of embodied intelligent robot skills.

[0006] In a first aspect, this application provides a method for controlling an embodied intelligent robot based on a skill tree, the method comprising:

[0007] In response to receiving a task instruction, obtain the current skill node and the target state indicated by the task instruction;

[0008] The target state is matched with the attainable states associated with each skill node in the pre-built skill tree, and the skill node that matches the target state is determined as the target skill node. The skill tree contains multiple skill nodes, and each skill node encapsulates the skill operation that the embodied intelligent robot can perform and the state that can be achieved after execution.

[0009] Based on the state transition relationship between skill nodes, a feasible path is searched in the skill tree to transition from the current state encapsulated by the current skill node to the target state encapsulated by the target skill node, and a task plan consisting of at least one skill node is generated according to the feasible path.

[0010] The skill operations encapsulated in each skill node are invoked sequentially according to the task plan to drive the embodied intelligent robot to complete the task instructions.

[0011] In one possible implementation, before acquiring the current skill node and target state, the method further includes:

[0012] The system acquires multiple basic skill operations that the embodied intelligent robot can perform, and encapsulates each basic skill operation into a corresponding meta-skill node, wherein the meta-skill node is an indivisible atomic action unit;

[0013] Extract the action feature parameters of each meta-skill node, and calculate the composite compatibility between each meta-skill node based on the action feature parameters. The composite compatibility is used to indicate the compatibility level of multiple meta-skill nodes performing the same composite skill operation in different orders.

[0014] Based on the composite compatibility, multiple meta-skill nodes are divided into multiple clusters using a clustering analysis algorithm, and each cluster is encapsulated as a composite skill node. The composite skill node is used to indicate a reusable skill template composed of at least two meta-skill nodes.

[0015] A skill tree is constructed based on the meta-skill nodes and the composite skill nodes.

[0016] In one possible implementation, the step of sequentially invoking the skill operations encapsulated in each skill node according to the task plan includes:

[0017] Obtain the skill nodes to be executed and their corresponding prerequisites from the task plan;

[0018] Determine whether the current environment information obtained by parsing the task instruction meets the prerequisite execution conditions;

[0019] If the conditions are met, the skill operation encapsulated in the skill node to be executed is invoked, and the execution result is monitored.

[0020] Based on the execution result, continue executing the next skill node according to the task plan, or update the task plan;

[0021] If the conditions are not met, then a candidate skill node corresponding to the skill node to be executed is determined, wherein the sub-target states corresponding to the skill node to be executed and the candidate skill node are the same;

[0022] Starting from the candidate skill node and ending at the next skill node in the task plan, a local path is determined within the skill tree, and the corresponding segment in the task plan is replaced according to the local path to form an updated task plan.

[0023] Repeat the precondition verification, and continue to execute the next skill node according to the task plan based on the execution result of the called skill node, or update the steps of the task plan, until the target state is reached, or until there are no candidate skill nodes in the skill tree that meet the preconditions. If so, the task plan is determined to be uncompleted and an exception is reported.

[0024] In one possible implementation, after monitoring the execution result, the method further includes:

[0025] Generate the execution log of the skill node to be executed, and write the execution log to the log library. The execution log includes: the environment context vector when the skill node to be executed is invoked, the actual skill parameters used, and the corresponding execution result.

[0026] Periodically extract historical logs of the same skill node from the log library to construct a sample set, and divide the sample set into multiple clusters using a preset algorithm. Clusters with an execution success rate higher than the success rate threshold are selected as clusters to be verified.

[0027] For each cluster to be verified, calculate the Gaussian joint distribution of the cluster's environment context vector and skill parameters to obtain the conditional probability, and write the conditional probability as the parameter recommendation model for the skill node to be executed into the node configuration table;

[0028] When the skill node to be executed is invoked again, the real-time environment context vector is used as input, and the parameter recommendation model is used to generate suitable recommended skill parameters, and the default parameters inside the skill node to be executed are replaced according to the recommended skill parameters.

[0029] In one possible implementation, the method further includes:

[0030] Analyze historical command and task execution logs to identify skill node sequences with an execution success rate greater than or equal to a preset success rate;

[0031] Based on the skill node sequence, a recommended composite skill node is constructed, and a confirmation prompt is output based on the recommended composite skill node;

[0032] Upon receiving feedback in response to the confirmation prompt, the recommended composite skill node is added to the skill tree.

[0033] In one possible implementation, adding the recommended composite skill node to the skill tree includes:

[0034] Retrieve the original skill node sequence to which the skill node sequence belongs;

[0035] Obtain the first skill node immediately preceding the skill node sequence and the second skill node immediately following the skill node sequence from the original skill node sequence;

[0036] The recommended composite skill node is inserted into the skill tree, and a parent-child relationship is established between the recommended composite skill node and the first skill node, as well as a parent-child relationship between the recommended composite skill node and the second skill node.

[0037] In one possible implementation, the method further includes:

[0038] The graphical interface displays multiple meta-skill nodes contained in the composite skill node and logical control nodes located between each meta-skill node, wherein the logical control node includes at least one of sequence nodes, parallel nodes, or delay nodes.

[0039] In response to the user's drag operation on the logical control node, update the connection relationship within the composite skill node;

[0040] Based on the updated connection relationships, a corresponding updated task plan is generated and executed.

[0041] Secondly, this application provides a skill tree-based embodied intelligent robot control device, comprising: a parsing module, a plan generation module, and a control module, wherein:

[0042] The parsing module is used to obtain the current skill node and the target state indicated by the task instruction in response to receiving the task instruction;

[0043] The plan generation module is used to match the target state with the achievable states associated with each skill node in the pre-built skill tree, and to determine the skill node that matches the target state as the target skill node. The skill tree contains multiple skill nodes, and each skill node encapsulates the skill operation that the embodied intelligent robot can perform and the state that can be achieved after execution.

[0044] The plan generation module is also used to search in the skill tree for a feasible path from the current state encapsulated by the current skill node to the target state encapsulated by the target skill node based on the state transition relationship between skill nodes, and generate a task plan consisting of at least one skill node based on the feasible path.

[0045] The control module is used to sequentially call the skill operations encapsulated in each skill node according to the task plan, so as to drive the embodied intelligent robot to complete the task instructions.

[0046] In one possible implementation, the control module is further configured to:

[0047] The system acquires multiple basic skill operations that the embodied intelligent robot can perform, and encapsulates each basic skill operation into a corresponding meta-skill node, wherein the meta-skill node is an indivisible atomic action unit;

[0048] Extract the action feature parameters of each meta-skill node, and calculate the composite compatibility between each meta-skill node based on the action feature parameters. The composite compatibility is used to indicate the compatibility level of multiple meta-skill nodes performing the same composite skill operation in different orders.

[0049] Based on the composite compatibility, multiple meta-skill nodes are divided into multiple clusters using a clustering analysis algorithm, and each cluster is encapsulated as a composite skill node. The composite skill node is used to indicate a reusable skill template composed of at least two meta-skill nodes.

[0050] A skill tree is constructed based on the meta-skill nodes and the composite skill nodes.

[0051] In one possible implementation, the control module is further configured to:

[0052] Obtain the skill nodes to be executed and their corresponding prerequisites from the task plan;

[0053] Determine whether the current environment information obtained by parsing the task instruction meets the prerequisite execution conditions;

[0054] If the conditions are met, the skill operation encapsulated in the skill node to be executed is invoked, and the execution result is monitored.

[0055] Based on the execution result, continue executing the next skill node according to the task plan, or update the task plan;

[0056] If the conditions are not met, then a candidate skill node corresponding to the skill node to be executed is determined, wherein the sub-target states corresponding to the skill node to be executed and the candidate skill node are the same;

[0057] Starting from the candidate skill node and ending at the next skill node in the task plan, a local path is determined within the skill tree, and the corresponding segment in the task plan is replaced according to the local path to form an updated task plan.

[0058] Repeat the precondition verification, and continue to execute the next skill node according to the task plan based on the execution result of the called skill node, or update the steps of the task plan, until the target state is reached, or until there are no candidate skill nodes in the skill tree that meet the preconditions. If so, the task plan is determined to be uncompleted and an exception is reported.

[0059] In one possible implementation, after monitoring the execution result, the control module is further configured to:

[0060] Generate the execution log of the skill node to be executed, and write the execution log to the log library. The execution log includes: the environment context vector when the skill node to be executed is invoked, the actual skill parameters used, and the corresponding execution result.

[0061] Periodically extract historical logs of the same skill node from the log library to construct a sample set, and divide the sample set into multiple clusters using a preset algorithm. Clusters with an execution success rate higher than the success rate threshold are selected as clusters to be verified.

[0062] For each cluster to be verified, calculate the Gaussian joint distribution of the cluster's environment context vector and skill parameters to obtain the conditional probability, and write the conditional probability as the parameter recommendation model for the skill node to be executed into the node configuration table;

[0063] When the skill node to be executed is invoked again, the real-time environment context vector is used as input, and the parameter recommendation model is used to generate suitable recommended skill parameters, and the default parameters inside the skill node to be executed are replaced according to the recommended skill parameters.

[0064] In one possible implementation, the control module is further configured to:

[0065] Analyze historical command and task execution logs to identify skill node sequences with an execution success rate greater than or equal to a preset success rate;

[0066] Based on the skill node sequence, a recommended composite skill node is constructed, and a confirmation prompt is output based on the recommended composite skill node;

[0067] Upon receiving feedback in response to the confirmation prompt, the recommended composite skill node is added to the skill tree.

[0068] In one possible implementation, the control module is further configured to:

[0069] Retrieve the original skill node sequence to which the skill node sequence belongs;

[0070] Obtain the first skill node immediately preceding the skill node sequence and the second skill node immediately following the skill node sequence from the original skill node sequence;

[0071] The recommended composite skill node is inserted into the skill tree, and a parent-child relationship is established between the recommended composite skill node and the first skill node, as well as a parent-child relationship between the recommended composite skill node and the second skill node.

[0072] In one possible implementation, the control module is further configured to:

[0073] The graphical interface displays multiple meta-skill nodes contained in the composite skill node and logical control nodes located between each meta-skill node, wherein the logical control node includes at least one of sequence nodes, parallel nodes, or delay nodes.

[0074] In response to the user's drag operation on the logical control node, update the connection relationship within the composite skill node;

[0075] Based on the updated connection relationships, a corresponding updated task plan is generated and executed.

[0076] Thirdly, this application provides an electronic device, including: a processor, and a memory communicatively connected to the processor;

[0077] The memory stores computer-executed instructions;

[0078] The processor executes computer execution instructions stored in the memory to implement the skill tree-based embodied intelligent robot control method as described in the first aspect.

[0079] Fourthly, this application provides a computer-readable storage medium storing computer-executable instructions, which, when executed by a computer, are used to implement the skill tree-based embodied intelligent robot control method as described in the first aspect.

[0080] Fifthly, this application also provides a computer program product, including a computer program that, when executed by a processor, can implement the steps of the scheme recommendation method as described in any of the first aspects.

[0081] The embodied intelligent robot control method, apparatus, and device provided in this application first map the target state in the task instruction to the corresponding target skill node in the skill tree. Then, a feasible path from the current skill node to the target skill node is searched in the skill tree to obtain the task plan. The skill operations encapsulated in each skill node are then sequentially invoked according to the task plan to drive the embodied intelligent robot to complete the task instruction. By mapping the target state to skill tree nodes all at once and then searching for feasible paths, a task plan can be automatically generated, improving the skill reuse rate of the embodied intelligent robot. Attached Figure Description

[0082] The accompanying drawings, which are incorporated in and form part of this specification, illustrate embodiments consistent with this application and, together with the description, serve to explain the principles of this application.

[0083] Figure 1 A flowchart illustrating a skill tree-based embodied intelligent robot control method provided in this application embodiment. Figure 1 ;

[0084] Figure 2 A flowchart illustrating a skill tree-based embodied intelligent robot control method provided in this application embodiment. Figure 2 ;

[0085] Figure 3 A flowchart illustrating a skill tree-based embodied intelligent robot control method provided in this application embodiment. Figure 3 ;

[0086] Figure 4 A schematic diagram of the structure of an embodied intelligent robot control device based on a skill tree, provided in an embodiment of this application;

[0087] Figure 5 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application.

[0088] The accompanying drawings illustrate specific embodiments of this application, which will be described in more detail below. These drawings and descriptions are not intended to limit the scope of the concept in any way, but rather to illustrate the concept of this application to those skilled in the art through reference to particular embodiments. Detailed Implementation

[0089] To make the objectives, technical solutions, and advantages of this application clearer, the technical solutions of this application will be clearly and completely described below with reference to the accompanying drawings. Obviously, the described embodiments are only some embodiments of this application, not all embodiments. Based on the embodiments of this application, all other embodiments obtained by those skilled in the art without creative effort are within the scope of protection of this application.

[0090] Currently, embodied intelligent robots generally adopt a "physical body + intelligent agent" architecture: the physical body integrates multiple sensors such as vision, force, and laser, and realizes environmental state perception through fusion algorithms; the intelligent agent relies on a pre-set rule base or deep reinforcement learning model to map the perception results into action commands. However, regardless of the rule base or end-to-end network, its underlying skill modules (such as "tightening screws," "plugging plugs," and "suction cup picking up boxes") are still hard-coded in a task-specific manner: developers need to reset the coordinates, force control thresholds, and motion trajectories for specific parameters such as screw distribution, plug orientation, and box size; otherwise, the robot cannot directly reuse old skills to complete new tasks. However, since the skill modules are hard-coded in a task-specific manner, the skill modules need to be redeveloped when the scene parameters change, reducing the reuse rate of skills in embodied intelligent robots.

[0091] This application provides a skill tree-based control method for embodied intelligent robots. First, the target state in the task instruction is mapped to the corresponding target skill node in the skill tree. Then, a feasible path from the current skill node to the target skill node is searched in the skill tree to obtain the task plan. The skill operations encapsulated in each skill node are sequentially invoked according to the task plan to drive the embodied intelligent robot to complete the task instruction. By mapping the target state to skill tree nodes in one step and then searching for feasible paths, a task plan can be automatically generated, improving the skill reuse rate of the embodied intelligent robot.

[0092] The technical solutions of this application and how they solve the aforementioned technical problems are described in detail below with specific embodiments. These specific embodiments may exist independently or in combination with each other. Identical or similar concepts or processes may not be repeated in some embodiments. The embodiments of this application will now be described with reference to the accompanying drawings.

[0093] It should be noted that the executing entity in subsequent embodiments may be the embodied intelligent robot body, or a cloud or edge system that communicates and connects with the embodied intelligent robot, or a combination of both.

[0094] Figure 1 A flowchart illustrating a skill tree-based embodied intelligent robot control method provided in this application embodiment. Figure 1 .like Figure 1 As shown, the method includes:

[0095] S101. In response to receiving a task instruction, obtain the current skill node and the target status indicated by the task instruction.

[0096] In this step, with the advancement of Industry 4.0 and flexible manufacturing, a production line often needs to switch between different models and processes within hours; the SKUs and shelf layouts of logistics and warehousing are dynamically adjusted daily; and unstructured scenarios such as homes and hospitals involve diverse tasks and changing parameters. This requires embodied intelligent robots to move beyond "one task, one program" and instead continuously complete multi-step, cross-scenario collaborative operations such as "grasping-assembly-inspection," "handling-sorting-replenishment," and "cleaning-care-delivery" on the same body. Currently, embodied intelligent robots generally adopt a "physical body + intelligent agent" architecture: the body integrates multiple sensors such as vision, force, and laser, and realizes environmental state perception through fusion algorithms; the intelligent agent relies on a preset rule base or deep reinforcement learning model to map the perception results into action commands. However, regardless of the rule base or the end-to-end network, the underlying skill modules (such as "tightening screws," "plugging plugs," and "suction cup picking up boxes") are still hard-coded in a task-specific manner. Developers need to reset the coordinates, force control thresholds, and motion trajectories for specific parameters such as screw distribution, plug orientation, and box size; otherwise, the robot cannot directly reuse old skills to complete new tasks. However, this task-specific hard-coding of skill modules requires redevelopment when scene parameters change, reducing the reusability of embodied intelligent robot skills.

[0097] Because hard-coded skill modules are tightly coupled with specific scenario parameters, any change in workpiece tolerances, process sequence, or environmental layout necessitates the redevelopment, compilation, and deployment of the entire module, resulting in long development cycles, extensive on-site debugging, and extremely low skill reuse rates. This embodiment addresses these issues through a three-step approach: mapping, searching, and invoking. First, the target state in the task instruction is mapped to the corresponding skill node in the skill tree, decoupling the abstract state from the discrete skill. Then, a feasible path from the current node to the target node is searched in the skill tree, automatically generating a task plan. Finally, the encapsulated skill operations of each node are invoked sequentially according to the plan, driving the embodied intelligent robot to complete the task. Therefore, when scenario parameters change, only nodes need to be updated or added, without rewriting the entire process, achieving high skill reuse and rapid line switching.

[0098] To obtain the current skill node and the target state indicated by the task instruction, the following steps must be executed sequentially: task instruction access, current skill node location, target state parsing, and data consistency verification. The specific implementation process is as follows:

[0099] Task instruction access: Continuously listen for task instructions issued by the host scheduling system, MES, or human-machine interface terminal via Ethernet, industrial fieldbus, or wireless communication module. Task instructions use a structured description format, including task identifier, target object type, expected finished product status, priority, and optional process constraint fields. After completing CRC verification at the data link layer, the receiving thread pushes the task instruction into the memory message queue and triggers the wake-up signal of the main planning thread.

[0100] Current skill node localization: After the main planning thread is awakened, it first reads the latest state snapshot through the blackboard system built into the embodied intelligent robot or the shared memory area. The snapshot is periodically written by the perception fusion module and includes: the pose of the end effector in the 3D workspace. This pose is matched with the nearest neighbor of the preset discrete pose templates in the skill tree. The template node that matches successfully is the current skill node. If the end effector is in the process of executing a compound skill, the blackboard also records the identifier of the running skill node. The planning thread directly uses this identifier as the current skill node to avoid duplicate matching. When the confidence of the matching result is lower than the set threshold, the localization recovery sub-process is triggered: the robot is controlled to perform a small exploratory movement, visual and force data are re-acquired, the state snapshot is updated, and the matching is repeated until the confidence reaches the threshold.

[0101] Target State Resolution: The target state field in the task instruction is given in the form of semantic labels plus a parameter list. The parser first checks the validity of the labels against the state dictionary at the top level of the embodied intelligent robot's skill tree. Labels that pass the check are mapped to unique state entries in the dictionary, each entry recording the set of geometric, force control, and I / O conditions that the state must satisfy. For target states containing variable parameters, the parser fills the placeholders in the condition set with the numerical fields from the instruction, forming an instantiated target state. If a target state field is missing or out of bounds, an error code is returned to the host computer and a retransmission is requested to prevent invalid states from entering subsequent planning stages.

[0102] Data consistency verification: After completing the above steps, the planning thread packages the current skill node and target state into a context structure within the critical section, along with a timestamp and sequence number. This structure is written to an exclusive cache, and the "context valid" flag is set for atomic reading by the subsequent path search module. This ensures that the current node and target state are not tampered with by concurrent tasks during the planning cycle, thereby guaranteeing the consistency of the planning input.

[0103] Furthermore, the process of constructing the skill tree is as follows:

[0104] Obtain multiple basic skill operations that the embodied intelligent robot can perform, and encapsulate each basic skill operation into a corresponding meta-skill node, where the meta-skill node is an atomic action unit that cannot be further decomposed;

[0105] Extract the action feature parameters of each meta-skill node, and calculate the composite compatibility between each meta-skill node based on the action feature parameters. The composite compatibility is used to indicate the compatibility level of multiple meta-skill nodes performing the same composite skill operation in different orders.

[0106] Based on the composite compatibility, multiple meta-skill nodes are divided into multiple clusters using a clustering analysis algorithm, and each cluster is encapsulated as a composite skill node. The composite skill node is used to indicate a reusable skill template composed of at least two meta-skill nodes.

[0107] Construct a skill tree based on meta-skill nodes and composite skill nodes.

[0108] Specifically, firstly, all atomic actions that the embodied intelligent robot can independently complete within its workspace are collected through teach pendants, force-controlled dragging, or offline simulation. These actions include linear movement, rotation, gripping, releasing, force-controlled insertion, vacuum suction, visual positioning and alignment, and switch output triggering. Each of these actions is recorded as a basic skill operation, including trajectory, force threshold, duration, input / output channel number, and resource usage list. During the data collection process, the observable changes to the environmental state before and after each action are simultaneously verified to ensure that it cannot be further broken down into finer-grained sub-actions while maintaining a functional closed loop. This confirms that it possesses the non-decomposable characteristics required for a meta-skill node. Subsequently, a unique identifier is assigned to each basic skill operation and written to non-volatile storage, completing the encapsulation of the meta-skill node.

[0109] Next, motion feature parameters are extracted for each meta-skill node: geometric features include the relative pose vector between the start and end points of the motion, trajectory length, maximum velocity, and acceleration; force control features include peak torque, average contact force, and length of the stable force direction segment; resource features include the type of end effector used, vacuum loop number, visual window number, and digital output channel number; and temporal features include the duration of the motion and the minimum allowed interval between the motion and the preceding and following motions. All features are normalized to form a motion feature parameter vector of a unified dimension and stored in shared memory for subsequent calculations.

[0110] After obtaining the action feature parameters, the pairwise comparison stage begins: for each meta-skill node, the magnitude of the difference in feature vectors is used as the distance metric to calculate the composite compatibility between them. If the distance is less than a set threshold, the two nodes are considered to be functionally consecutively combined, thus generating a full symmetric similarity matrix with element values ​​ranging from zero to...

[0111] After obtaining the similarity matrix, a clustering analysis algorithm is used to divide multiple meta-skill nodes: first, each node is treated as an independent cluster, and the clusters with the highest composite compatibility are gradually merged until the similarity between clusters is below a preset lower limit, thus obtaining several compact and functionally cohesive clusters. The meta-skill nodes within each cluster maintain high similarity in geometric, force control, resource, and temporal features, and can be abstracted into the same type of composite action template. Subsequently, a composite skill node description is generated for each cluster. The description records the execution order, parameter passing rules, shared resources, and unified input / output interfaces exposed by all meta-skill nodes within the cluster, completing the encapsulation of the composite skill node and making it a reusable skill template.

[0112] Finally, the system constructs a hierarchical skill tree with meta-skill nodes as leaf nodes and composite skill nodes as intermediate nodes. Leaf nodes are directly attached to their corresponding composite skill nodes, forming parent-child relationships. Parent nodes internally store an ordered list of handles pointing to child nodes and declare serial, parallel, or conditionally triggered combination relationships between child nodes. The entire tree continuously aggregates upwards using a depth-first approach until the root node represents the most abstract overall machine task capability. In persistent storage, the combination relationships between parent nodes and their child nodes are written to an adjacency list, supporting rapid expansion and backtracking at runtime, thereby completing the construction of the hierarchical skill tree and providing a top-down call skeleton and bottom-up state reduction capability for subsequent path search.

[0113] It should be noted that meta-skill nodes correspond to atomic actions of embodied intelligent robots that cannot be further subdivided. For example, an end effector moving linearly to a target pose, a vacuum suction cup activating and maintaining negative pressure, pushing an electrical plug into a socket with a set torque, and a visual trigger taking a picture and returning the positioning result are all meta-skill nodes. These nodes contain only a trajectory or a force control curve, producing observable state transitions before and after execution, and cannot be further broken down into smaller functional loops.

[0114] Composite skill nodes are composed of several meta-skill nodes assembled through sequential, parallel, or delayed logic, used to describe high-order and reusable process segments. For example, a grasping, handling, and placing process can be encapsulated as a composite skill node: internally, it sequentially calls five meta-skill nodes: move to the grasping position, activate the vacuum, deactivate the vacuum, move to the target position, and release the workpiece, with sequential execution ensured by sequence nodes. If two-handed coordination is required, parallel nodes can be introduced within the composite node, allowing the left-hand grasping and right-hand detection to run synchronously. Through a parent-child hierarchical structure, the robot can decompose complex tasks into familiar atomic actions and validated action phrases, quickly assembling new execution plans in the skill tree without having to write the underlying trajectory from scratch.

[0115] S102. Match the target state with the pre-built skill tree to determine the target skill node corresponding to the target state.

[0116] In this step, the target state is pre-arranged in dictionary order, including geometric conditions, force control conditions, IO conditions, and expandable semantic tag fields. First, a completeness check is performed on the target state: if any required field is missing or its value exceeds the physically feasible range declared in the skill tree dictionary, a matching failure is immediately reported to the host computer, and the process is terminated to avoid wasting computing power on invalid searches.

[0117] The pre-built skill tree is stored in persistent storage in a hierarchical index: the top layer is the state dictionary area, the middle layer is the node mapping area, and the bottom layer is the node attribute area. The state dictionary area stores all registered state signatures, and each signature uniquely corresponds to a state template. The planning thread calculates a hash value based on the semantic label of the target state, and uses this hash value to directly locate the candidate bucket in the state dictionary area, achieving constant-level entry point location and narrowing the range of subsequent linear comparisons.

[0118] After entering the candidate bucket, all state signatures within the bucket are retrieved and sorted in ascending order by priority field. The comparator sequentially performs conditional alignment between the target state and each signature: geometric conditions use tolerance range matching; if the target value falls within the upper or lower limits of the signature declaration, the item is considered compliant. Force control conditions, in addition to the numerical range, also compare the force direction flag bit to ensure directional consistency. IO conditions check the channel number and level range of digital and analog quantities; a successful match is only achieved after all channels pass the check.

[0119] If any field is found to be mismatched, the matcher immediately skips that signature and moves on to the next. When all fields match, the unique identifier of the signature is recorded, and the comparison loop terminates, ensuring that a perfect match is returned on the first attempt, reducing unnecessary computation.

[0120] After obtaining a unique identifier for a successfully matched signature, the process enters the node mapping area. Using this identifier, it queries the one-to-one mapping table to directly obtain the handle of the target skill node bound to it. The handle contains the node's offset address in the memory pool, its lifecycle version number, and the concurrent access lock status. If the mapping table returns an empty handle, it indicates a synchronization error between the dictionary and the tree structure, triggering a mapping reconstruction process: rescanning the skill tree, updating the mapping table, and then querying again to ensure reliable results. Once the target skill node is located, the planning thread performs a validity check: it checks if the node's lifecycle version number matches the current tree version to confirm the node hasn't been hot-updated; simultaneously, it attempts to acquire the node's shared read lock. If the lock is already occupied by a write operation, it waits for the lock to be released before continuing, preventing the node from being deleted or modified during the planning process, which could invalidate subsequent path search references.

[0121] After successful verification, the target skill node handle, node identifier, and matching confidence score are written to the context structure, and the "target node valid" flag is set. This context is atomically released to the path search module to ensure that subsequent steps can immediately use the verified target skill node to complete the unique mapping from the abstract target state to the discrete skill node.

[0122] S103. Search for feasible paths from the current skill node to the target skill node in the skill tree, and generate a task plan consisting of at least one skill node based on the feasible paths.

[0123] In this step, the process begins with the main planning thread having obtained the verified current skill node and target skill node. A dynamic search tree is maintained in memory, rooted at the current skill node. Edges represent skill transfers between nodes that can be directly executed by the robot, with edge attributes including transfer cost, execution time, and collision risk flags. The thread first pushes the root node onto the open list and initializes the path cost to zero. Then, an iterative loop is entered: each time, the node with the minimum cost is selected from the open list as the expansion node, and all successor skill nodes of that node are quickly obtained using a pre-generated adjacency index.

[0124] For each subsequent skill node, a lightweight collision and constraint detection function is invoked to determine whether the skill transfer from the extended skill node to the subsequent skill node exceeds joint limits or conflicts with transient obstacles. Transfers that fail the detection are immediately discarded. Candidate nodes that pass the detection are assigned a new cumulative cost and, after being sorted using a heuristic cost evaluation function, are pushed into the open list. At the same time, extended nodes are moved to the closed list to prevent duplicate extensions.

[0125] When the skill node with the lowest cost that pops up happens to be the target skill node, the loop terminates. The system then backtracks along the parent pointer chain, recording the skill nodes passed through in sequence, thus obtaining an ordered sequence of nodes from the current skill node to the target skill node, which constitutes a feasible path. Finally, the thread encapsulates this sequence into a task plan, writes it to the shared cache, and sets the plan's validity flag for subsequent calls, completing collision-free and cost-controllable skill-level path planning.

[0126] S104. In accordance with the task plan, the skill operations encapsulated in each skill node are called in sequence to drive the embodied intelligent robot to complete the task instructions.

[0127] In this step, after confirming that the task plan is valid, the execution thread first applies a read lock to the sequence of skill nodes within the plan to prevent concurrent modifications by upstream planning threads. Then, it extracts the first skill node in sequence to obtain a description of the skill operation it encapsulates. The parameter templates pre-set in the description are populated in real-time by real-time sensing data, generating specific trajectories, force control thresholds, input / output timing sequences, and durations. The same description also lists the required end effector, vacuum loop, vision window, and bus bandwidth. Based on the listed information, the thread requests resource allocation from the resource arbitration service. If any resource is occupied by a higher-priority task, the execution thread enters a timed retry waiting phase until all resources are successfully locked.

[0128] Once locking is complete, the trajectory and force control curve are downloaded to the servo controller, and the synchronization timer starts. Simultaneously, the perception fusion thread continuously uploads pose, torque, and digital status at the corresponding frequency. The monitoring thread periodically compares the feedback value with the allowable deviation band. If the pose error or torque exceeds the threshold, deceleration or regression to the previous safe skill node is immediately triggered. If the entire process remains within the deviation band and the timer reaches the set duration, the current skill node is considered completed, resources are released, and the current skill node field on the blackboard is updated to the handle of the completed node.

[0129] After a node switch, the execution thread checks if a successor node exists in the sequence:

[0130] If it exists, repeat the entire process of parameter filling, resource request, download curve, and closed-loop monitoring. If the end of the sequence has been reached, report the completion event to the upper-level scheduling system, release the plan lock, and set the global idle flag.

[0131] When any skill node fails, the failure type and a snapshot of the situation are recorded, and the process reverts to the nearest known safe node. An exception code is then reported, and the system awaits a replanning instruction. Through sequential node-by-node invocation, real-time closed-loop monitoring, and resource arbitration, the embodied intelligent robot can complete all skill operations sequentially without human intervention, ultimately achieving the final target state specified in the task instruction.

[0132] This application provides a skill tree-based control method for embodied intelligent robots. First, the target state in the task instruction is mapped to the corresponding target skill node in the skill tree. Then, a feasible path from the current skill node to the target skill node is searched in the skill tree to obtain the task plan. The skill operations encapsulated in each skill node are sequentially called according to the task plan to drive the embodied intelligent robot to complete the task instruction. By mapping the target state to skill tree nodes in one step and then searching for feasible paths, the task plan can be automatically generated, improving the reusability of skills in the embodied intelligent robot. By encapsulating indivisible basic skill operations into atomic-level meta-skill nodes and quantifying their functional differences using action feature parameters, the system can automatically discover meta-skill nodes with similar functions without manual classification, and then cluster them to generate reusable composite skill nodes. These composite skill nodes are exposed with a unified interface, allowing similar tasks to directly call templates without redeveloping the underlying action sequences, significantly improving skill reusability. When scenario parameters or process requirements change, only the corresponding skill nodes need to be added, deleted, or adjusted, and the combination relationships updated. The rest of the skill tree remains unchanged, thus reducing the workload of global rewriting caused by hard coding to local modifications, significantly reducing maintenance costs and improving deployment efficiency. Ultimately, the skill tree, in the form of standardized nodes, encapsulates all the robot's executable capabilities, providing a modular resource pool for task planning that is readily available. This enables embodied intelligent robots to quickly adapt to task changes in flexible manufacturing, logistics warehousing, and service scenarios, achieving efficient and stable multi-step collaborative operations.

[0133] Figure 2 A flowchart illustrating a skill tree-based embodied intelligent robot control method provided in this application embodiment. Figure 2 .like Figure 2 As shown, the method includes:

[0134] S201. Obtain the skill node to be executed and its corresponding prerequisite execution conditions from the task plan, and determine whether the current environment information obtained by parsing the task instructions meets the prerequisite execution conditions.

[0135] In this step, the skill nodes in the task plan are arranged sequentially, but the action unit encapsulated in each node cannot be directly activated in every scenario. Internally, it records the prerequisite execution conditions, including the end-effector pose range, gripping force range, vacuum lower limit, visual positioning reliability, distance to surrounding obstacles, and digital input level status. If these conditions are ignored and execution is performed blindly, the embodied intelligent robot may collide with the workpiece, slip, or fail to insert, leading to task interruption or even equipment damage. Therefore, before actually executing the skill operation corresponding to the skill node, the skill node to be executed and its prerequisite execution conditions must be extracted from the task plan. Then, the current environmental information obtained from real-time parsing of the task instructions is compared item by item with these conditions. Only after all conditions are met is the action phase allowed, thus ensuring the continuity and safety of the action chain.

[0136] Specifically, after confirming that the task plan is valid, the main control thread reads the currently executed skill node in sequence and accesses its internal description area through the node handle to extract the list of prerequisite execution conditions. This list provides six categories of conditions in a fixed order: geometry, force control, vacuum, vision, obstacles, and digital quantities. Each category of condition is accompanied by an upper and lower limit for allowable deviation. At the same time, the perception fusion thread has summarized the latest acquired images, torque, air pressure, laser point cloud, and digital I / O status into the current environmental information based on the sensor configuration words carried in the task instruction, and written it to the shared cache. After obtaining a snapshot of this cache, the main control thread starts a step-by-step comparison: comparing whether the current pose of the end point falls within the geometric range described by the node; comparing whether the force sensor feedback value is within the set force control range; checking whether the vacuum pressure is higher than the lower limit; reading the visual positioning confidence field to confirm that it is higher than the node's required threshold; calculating the distance to the nearest obstacle based on the point cloud grid map to determine whether it is greater than the safety interval; and verifying whether the digital input level is consistent with the requirements of the skill node to be executed.

[0137] S202. If satisfied, the skill operation encapsulated in the skill node to be executed is invoked, the execution result is monitored, and the next skill node is executed according to the task plan, or the task plan is updated, based on the execution result.

[0138] In this step, after confirming that all pre-execution conditions are met, the main control thread immediately unpacks the skill operation description within the skill node to be executed, obtaining the trajectory curve, force control threshold, duration, input / output timing, and resource usage list. It then requests the resource arbitration service to lock the end effector, vacuum loop, vision window, and bus bandwidth. Once all resources are in place, the trajectory and force control curve are downloaded to the servo controller, and a synchronization timer is started, initiating the movement of the embodied intelligent robot. During the movement, the perception fusion thread uploads pose, torque, air pressure, and digital status at fixed intervals, while the monitoring thread continuously compares the real-time feedback with the allowable deviation range in the skill operation description. If the pose error or torque peak exceeds the upper limit, deceleration or reversal is immediately triggered, an abnormal snapshot is recorded, resources are released, and an execution failure event is reported to the host computer. If the entire process remains within the deviation range and the timer reaches the set duration, execution is considered successful, resources are released, and the current skill node field on the blackboard is updated to the handle of the newly completed node.

[0139] Upon successful completion, the main control thread checks if there are any subsequent skill nodes in the node sequence within the task plan. If so, it extracts the next skill node to be executed according to the node sequence, re-enters the precondition comparison process, and achieves sequential progress. If the skill node to be executed is at the end of the node sequence, it reports the task completion event to the upper-level scheduling system, releases the task plan lock, and sets the global idle flag.

[0140] In the event of execution failure, a new executable path is obtained: The candidate skill nodes corresponding to the skill node to be executed are re-searched in the skill tree, ensuring that the candidate skill stage and the sub-target state associated with the skill node to be executed are the same. An executable path from the candidate skill node to the target skill node is then searched in the skill tree, and the task plan is updated accordingly.

[0141] Alternatively, retrieve the skill node to be executed from the task plan, which is immediately adjacent to the next skill node. Then, search the skill tree for an executable path from a candidate skill node to the next skill node immediately adjacent to the skill node to be executed, and replace the corresponding sequence fragment in the task plan with the executable path.

[0142] In one possible implementation, the execution result of embodied intelligent robot skills is influenced by both the environmental context and skill parameters. Fixed default parameters are difficult to adapt to dynamic working conditions, resulting in fluctuations in the success rate of the same skill node under different times, workpiece postures, or temperature and humidity conditions. By continuously recording execution logs and extracting high-success-rate samples, the correspondence between "environmental context and skill parameters" can be automatically summarized. This allows for the provision of recommended skill parameters that best match the real-time environment for the next call, achieving node-level self-optimization and reducing manual intervention and repeated trial and error.

[0143] The implementation process is as follows:

[0144] Generate execution logs for the skill nodes to be executed and write the execution logs to the log database. The execution logs include: the environment context vector when the skill node to be executed is invoked, the actual skill parameters used, and the corresponding execution results.

[0145] Periodically extract historical logs of the same skill node from the log library to build a sample set, and divide the sample set into multiple clusters using a preset algorithm. Clusters with an execution success rate higher than the success rate threshold are selected as clusters to be verified.

[0146] For each cluster to be verified, calculate the Gaussian joint distribution of the cluster's environment context vector and skill parameters to obtain the conditional probability, and write the conditional probability into the node configuration table as the parameter recommendation model for the skill node to be executed.

[0147] When the skill node to be executed is invoked again, the real-time environment context vector is used as input, and the parameter recommendation model is used to generate the appropriate recommended skill parameters. The default parameters inside the skill node to be executed are then replaced with the recommended skill parameters.

[0148] Specifically, after the skill node to be executed completes its action, the main control thread immediately collects the environmental context vector at that time, including end-effector pose deviation, torque baseline, steady-state air pressure value, visual confidence level, distance to surrounding obstacles, and temperature and humidity readings. Simultaneously, it records the actual skill parameter trajectory peak, force control threshold, duration, input / output level sequence, and execution result flag, packages these data into an execution log, and writes it to a non-volatile log library. The writing process uses a sequential append method to ensure that no records are lost even with high-frequency calls.

[0149] Once the logs for the same skill node accumulate to a set size, the background maintenance thread periodically reads them all to construct a sample set. The sample set is first cleaned, removing invalid records from abnormal interruptions or sensor disconnections. Then, a preset algorithm is used to divide the data into clusters, ensuring high cohesion and low coupling within each cluster in terms of environmental context and skill parameter space. Subsequently, the execution success rate of each cluster is calculated; clusters with success rates exceeding a threshold are marked as clusters to be verified, while the rest are discarded.

[0150] For each cluster to be validated, the system calculates the joint distribution of the environment context vector and skill parameters, and further derives the conditional probability, which is the probability distribution of each skill parameter value given any environment context vector. This conditional probability is written into the node configuration table of the corresponding skill node in a lookup table format, forming a parameter recommendation model. Simultaneously, the model version number and update time are recorded for traceability.

[0151] When the skill node is invoked again, the main control thread first collects the real-time environment context vector. Using this vector as input, it retrieves the latest parameter recommendation model from the node configuration table and generates recommended skill parameters through the principle of maximum probability or weighted sampling, overriding the node's internal default parameters. Then, it enters the precondition verification and execution process to ensure that the recommended parameters are validated in the real-time environment.

[0152] Through log-driven online learning, skill parameters can continuously converge to a high-success-rate parameter range during runtime, significantly reducing retry and downtime caused by parameter mismatch. The parameter recommendation model is stored in probabilistic form, balancing robustness and diversity. Even with minor environmental drift, it can provide the most likely successful parameter combination, improving the first-time pass rate. The model is stored in a node configuration table, bound to the node lifecycle, with version controllable and hot-update support, allowing for iterative optimization without production downtime. Ultimately, all nodes in the entire skill tree possess self-optimization capabilities, enabling the robot to maintain high success rates and low maintenance costs in flexible manufacturing, logistics warehousing, and service scenarios, achieving a closed loop of experience accumulation and performance evolution.

[0153] S203. If not satisfied, determine the candidate skill node corresponding to the skill node to be executed.

[0154] Among them, the sub-target states corresponding to the skill node to be executed and the candidate skill node are the same.

[0155] In this step, if the prerequisite execution conditions are not met, forcibly continuing to call the skill node to be executed will inevitably lead to collisions, slippage, or exceeding limits, causing task interruption and equipment risks. At this time, keeping the original target state unchanged and only changing the path to achieve the target state can restore execution feasibility with minimal modifications, avoiding the computational and time overhead caused by global replanning. At the same time, through local replacement and repeated verification, a closed loop of condition-replacement-re-verification is formed to ensure that the task chain always progresses towards the predetermined target state, and anomalies are reported in a timely manner when all feasible branches are exhausted to prevent infinite loops.

[0156] Specifically, upon detecting that the current environment information does not meet the prerequisite execution conditions, the main control thread immediately pauses the skill node to be executed, maintains the target state unchanged, and triggers a candidate search: using the sub-target state corresponding to the skill node to be executed as the key, it searches for all skill nodes with the same sub-target state in the skill tree node mapping area, and forms a candidate list in descending order of compatibility with the current node. The first item in the list is taken as a candidate skill node, ensuring that it can also output the original sub-target state.

[0157] S204. Starting from the candidate skill node and ending at the next skill node in the task plan, determine the local path within the skill tree, and replace the corresponding fragment in the task plan according to the local path to form an updated task plan.

[0158] In this step, after identifying candidate skill nodes, the system sets each candidate skill node as a local starting point and the next adjacent skill node in the task plan as a local ending point. It then calls the path search service within the skill tree to search for feasible paths only between these two points. The search scope is limited to the two levels above and below the original level to avoid introducing additional risks due to excessive span. After obtaining the local path, the original faulty segment in the task plan is overwritten with the path node sequence to form an updated task plan. Simultaneously, a version number increment is applied to the plan to prevent concurrent threads from misusing the old sequence.

[0159] S205. Repeat the pre-execution condition check. Based on the execution result of the called skill node, continue to execute the next skill node according to the task plan, or update the steps of the task plan, until the target state is reached, or until there are no candidate skill nodes in the skill tree that meet the pre-conditions. If so, the task plan is determined to be uncompleted and an exception is reported.

[0160] In this step, after the execution plan is updated, the main control thread re-enters the pre-execution condition verification: it reads the real-time environment information again and compares it item by item with the condition list of candidate skill nodes. If the comparison passes, it immediately calls the encapsulated skill operation and continuously monitors feedback during execution. If execution is successful, it continues to proceed according to the updated task plan, reads the next skill node, and repeats the condition-execution-monitoring process. If execution fails or the conditions are still not met, it falls back to the next item in the candidate list, and performs local path search and fragment replacement again until the list is exhausted.

[0161] When the candidate list has no feasible items, or the local path search returns an empty set, the system determines that there are no replacement possibilities within the skill tree that meet the preconditions. It immediately releases all resources, reports an incompleteness anomaly to the higher-level scheduling system, and attaches the last recorded reason for failure and an environmental snapshot for manual or higher-level scheduling decisions. Through this loop, when the current environmental information does not meet the preconditions for execution, it prioritizes the smallest possible replacement, keeping the target state unchanged, and gradually consuming feasible branches. This improves the task success rate, avoids unnecessary global recalculation, and achieves efficient and safe anomaly self-recovery.

[0162] This application provides a skill tree-based control method for embodied intelligent robots. Before each execution call, a pre-execution condition check is performed, enabling real-time perception of environmental changes and rejection of actions that do not meet the conditions. This fundamentally avoids collisions, exceeding limits, or slippage, improving the success rate of single executions. When conditions are not met, candidate skill nodes are quickly searched within the skill tree using the sub-target state as an anchor point, and local path segments are used to replace the original plan, achieving a closed loop of "condition-replacement-re-check," significantly reducing the computational power and downtime caused by global replanning. This closed loop is executed cyclically until the target state is reached, or an anomaly is reported promptly when candidates are exhausted, ensuring the continuity and safety of task progress. This substantially improves the embodied intelligent robot's capabilities in flexible manufacturing, logistics warehousing, and service scenarios, including line switching, obstacle avoidance, and fault tolerance. By generating an execution log containing environmental context vectors, actual skill parameters, and execution results for each skill node to be executed, high-success-rate samples can be automatically accumulated over long-term operation. By utilizing a conditional probability model derived from clustering and joint distribution calculations, nodes acquire the ability to recommend parameters that are adaptive to the environment, replacing fixed default parameters and significantly reducing retries, pauses, and manual parameter tuning workload caused by parameter mismatch. The parameter recommendation model is continuously updated with logs, enabling online evolution at the node level and improving the average success rate and stability of all skill nodes across the entire tree. Ultimately, the embodied intelligent robot can automatically select the most likely successful skill parameters even when facing dynamic disturbances such as changes in temperature and humidity, workpiece tolerances, and wear and aging, extending fault-free uptime, reducing maintenance costs, and achieving a virtuous cycle of experience accumulation and performance improvement.

[0163] Figure 3 A flowchart illustrating a skill tree-based embodied intelligent robot control method provided in this application embodiment. Figure 3 This embodiment provides a detailed explanation of the steps for adding a new composite skill node to the skill tree. For example... Figure 3 As shown, the method includes:

[0164] S301. Analyze the historical instruction task execution logs to identify skill node sequences with an execution success rate greater than or equal to the preset success rate.

[0165] In this step, we consider that different task instructions often repeatedly produce the same or similar skill node sequences. If we start path searching and parameter adaptation from scratch every time, it would repeatedly consume computing power and increase cycle time. By automatically analyzing historical task execution logs, we solidify sequences that have been successfully verified multiple times and are used frequently as recommended composite skill nodes, which can be directly called in subsequent tasks, reducing the burden of online planning.

[0166] Specifically, the stored historical instruction task execution logs are read at fixed intervals. Each log entry contains a task identifier, a skill node sequence, an execution result flag, and a timestamp. The logs are grouped according to the task identifier, and then sorted by timestamp within the same group, forming an ordered set of records distinguished by task.

[0167] Next, each set is filtered: only records with a successful execution result are retained, while entries that failed or were interrupted are removed. After filtering, the skill node sequence of each record is traversed, and completely identical sequences are mapped to the same temporary slot. Each occurrence is incremented in the slot. After the traversal is complete, the temporary slots store the successful execution counts of each skill node sequence. The execution success rate is calculated based on the successful execution counts and the total number of executions.

[0168] Subsequently, the execution success rate is compared with the preset success rate: if the execution success rate of a skill node sequence is greater than or equal to the preset success rate, the sequence is marked as a candidate sequence, and the time of the most recent success and the average execution cycle are recorded for subsequent encapsulation and confirmation prompts. If the success rate is lower than the preset success rate, the sequence is discarded, and the next slot is processed. After scanning and comparing all temporary slots, the skill node sequence is output.

[0169] S302. Based on the skill node sequence, construct recommended composite skill nodes, and output confirmation prompts based on the recommended composite skill nodes.

[0170] In this step, after obtaining the skill node sequence, the unique identifier, input / output interfaces, resource requirements, and parameter passing relationships of each skill node are recorded according to the sequence. Simultaneously, serial or parallel dependencies between adjacent nodes are marked. Subsequently, the entire sequence is encapsulated into a recommended composite skill node description, generating a unified external interface. This interface exposes only the input of the first node and the output of the last node, hiding the intermediate processes and forming a highly cohesive, reusable template.

[0171] After encapsulation, a confirmation prompt is output through the human-computer interaction channel: an information page pops up in the graphical interface, displaying a summary of the recommended composite skill node functions, the expected average beat rate, the success rate percentage, the number of child nodes, and a resource usage overview; it also provides three selectable buttons: confirm, reject, and postpone. If a voice or messaging channel is used on-site, the same content is converted into a text broadcast or short message, awaiting operator feedback.

[0172] S303. After receiving feedback information in response to the confirmation prompt, add the recommended composite skill node to the skill tree.

[0173] In this step, the feedback port is continuously monitored within a preset waiting time limit. Once a confirmation feedback is received, the recommended composite skill node description is immediately written into the skill tree adjacency table, a new identifier is assigned, and parent-child relationships are established. If a rejection feedback is received, the sequence is added to the "Don't show again" set. If there is no response within the timeout period, it is postponed by default, retaining its candidate status for presentation in the next round of analysis. The entire process does not require system downtime; the online task continues to execute. The confirmation result only affects whether the sequence is solidified into the tree, thus balancing the security of automated data accumulation with manual review.

[0174] The implementation process is as follows:

[0175] Retrieve the original skill node sequence to which the skill node sequence belongs;

[0176] Obtain the first skill node immediately preceding the original skill node sequence, and the second skill node immediately following the original skill node sequence;

[0177] Insert the recommended composite skill node into the skill tree, and establish the parent-child relationship between the recommended composite skill node and the first skill node, as well as the parent-child relationship between the recommended composite skill node and the second skill node.

[0178] Specifically, upon receiving confirmation feedback, the system immediately retrieves the original occurrence record corresponding to the recommended composite skill node from the log database, extracts the complete skill node sequence of the first successful record, and uses it as the original skill node sequence. By locating the beginning and end of the encapsulated subsequence within this original skill node sequence, the system obtains the first skill node immediately preceding it and the second skill node immediately following it.

[0179] Subsequently, a unique identifier is assigned to each recommended composite skill node, and a description is written to the node, including ordered handles to its internal child nodes, unified input / output interfaces, and resource requirements. Next, the adjacency list is updated: the pointers to the first node in the skill node sequence within the first skill node's child node list are replaced with pointers to the recommended composite skill node, establishing a parent-child relationship between the first and recommended composite skill nodes. The child node list of the recommended composite skill node is then set to point to the second skill node, completing the parent-child relationship between them. The levels previously occupied by subsequences are entirely replaced by the new node, maintaining the same tree height. The old subsequence nodes still exist as leaves, allowing for finer-grained calls, thus balancing reusability and structural compatibility. After insertion, the system incrementally updates the index and version number and publishes a node addition event to the upper-level path search service, enabling subsequent planning to immediately recognize the new shortcut and quickly activate the accumulated sequence.

[0180] In another possible implementation, considering that a composite skill node contains multiple meta-skill nodes and logical control nodes such as sequence, parallel, and delay logic, if it is presented only with text or parameter tables, users would need to memorize a large number of abstract fields, making planning difficult and prone to errors. By converting the control logic into draggable icons through a graphical interface, users can adjust the process without writing code, reducing the development problem that originally required professional programming to a simple on-site deployment problem, thereby significantly lowering the application threshold and subsequent optimization workload.

[0181] The implementation process is as follows:

[0182] The graphical interface displays multiple meta-skill nodes contained in the composite skill node and the logical control node located between each meta-skill node, wherein the logical control node includes at least one of sequence node, parallel node or delay node.

[0183] In response to the user's drag-and-drop operation on the logic control node, update the connection relationship within the composite skill node;

[0184] Based on the updated connection relationships, generate the corresponding updated task plan and execute the updated task plan.

[0185] Graphical drag-and-drop transforms complex logic into intuitive connections, allowing on-site process personnel to quickly adjust cycle times, optimize parallel processing, or set delays without needing to master programming languages, significantly reducing the difficulty and complexity of task planning. The same composite skill node can be modified visually multiple times without recompilation; subsequent product changes or process fine-tuning only require redeployment, greatly shortening changeover time. The platform-based, low-code approach reduces reliance on professional developers, significantly lowering application deployment costs. All changes are automatically version-recorded, creating a traceable process evolution path, further reducing the workload of subsequent updates and optimizations, and achieving a virtuous cycle of experience accumulation and continuous improvement.

[0186] This application provides a skill tree-based embodied intelligent robot control method. By automatically analyzing historical instruction task execution logs, it can accurately identify skill node sequences that repeatedly occur in actual production lines and have a success rate consistently higher than preset standards, and encapsulate them into recommended composite skill nodes. After manual confirmation, this node is seamlessly inserted into the existing skill tree, establishing a parent-child relationship with upstream and downstream first and second skill nodes to form a highly reliable shortcut verified on-site. Subsequently, when similar tasks occur again, path search will prioritize this shortcut, significantly shortening online planning time and cycle time, and improving overall equipment efficiency. Simultaneously, because the recommended composite skill node retains atomic-level node descriptions, it can still be called or modified with fine granularity, balancing reusability and flexibility. As production continues, new high-success-rate sequences are constantly being accumulated, and the skill tree grows more shortcuts on its own. Embodied intelligent robots thus possess the self-evolving ability to "get smarter with use." In flexible manufacturing, multi-variety, small-batch production, and cross-scenario services, they continuously reduce changeover and debugging costs, minimize manual programming intervention, and extend fault-free operation cycles, ultimately achieving a virtuous cycle of experience assetization, continuous performance optimization, and decreasing maintenance costs. Graphical drag-and-drop transforms complex logic into intuitive connections, allowing on-site process personnel to quickly adjust cycle times, optimize parallel processing, or set delays without needing to master programming languages, significantly reducing the difficulty and complexity of task planning. The same composite skill node can be visually modified multiple times without recompilation. Subsequent product changes or process fine-tuning only require redeployment, greatly shortening changeover time. The platform-based low-code approach reduces reliance on professional developers, significantly lowering application deployment costs. All changes are automatically recorded, forming a traceable process evolution path, further reducing the workload of subsequent updates and optimizations, achieving a virtuous cycle of experience accumulation and sustainable improvement.

[0187] Figure 4 This is a schematic diagram of the structure of a skill tree-based embodied intelligent robot control device provided in an embodiment of this application. Figure 4 As shown, the skill tree-based embodied intelligent robot control device 40 includes: a parsing module 401, a plan generation module 402, and a control module 403, wherein:

[0188] The parsing module 401 is used to obtain the current skill node and the target state indicated by the task instruction in response to receiving the task instruction;

[0189] The plan generation module 402 is used to match the target state with the pre-built skill tree and determine the target skill node corresponding to the target state. The skill tree contains multiple skill nodes, and each skill node encapsulates the skill operation that the embodied intelligent robot can perform and the state that can be achieved after execution.

[0190] The plan generation module 402 is also used to search for feasible paths from the current skill node to the target skill node in the skill tree, and generate a task plan consisting of at least one skill node based on the feasible path.

[0191] The control module 403 is used to sequentially call the skill operations encapsulated in each skill node according to the task plan, so as to drive the embodied intelligent robot to complete the task instructions.

[0192] In one possible implementation, the control module 403 is further configured to:

[0193] Obtain multiple basic skill operations that the embodied intelligent robot can perform, and encapsulate each basic skill operation into a corresponding meta-skill node, where the meta-skill node is an atomic action unit that cannot be further decomposed;

[0194] Extract the action feature parameters of each meta-skill node, and calculate the composite compatibility between each meta-skill node based on the action feature parameters. The composite compatibility is used to indicate the compatibility level of multiple meta-skill nodes performing the same composite skill operation in different orders.

[0195] Based on the composite compatibility, multiple meta-skill nodes are divided into multiple clusters using a clustering analysis algorithm, and each cluster is encapsulated as a composite skill node. The composite skill node is used to indicate a reusable skill template composed of at least two meta-skill nodes.

[0196] Construct a skill tree based on meta-skill nodes and composite skill nodes.

[0197] In one possible implementation, the control module 403 is further configured to:

[0198] Obtain the skill nodes to be executed and their corresponding prerequisites from the task plan;

[0199] Determine whether the current environment information obtained from parsing the task instructions meets the prerequisites for execution;

[0200] If the conditions are met, the skill operation encapsulated in the skill node to be executed is invoked, and the execution result is monitored.

[0201] Based on the execution results, continue to execute the next skill node according to the task plan, or update the task plan;

[0202] If the conditions are not met, then the candidate skill nodes corresponding to the skill node to be executed are determined, wherein the sub-target states corresponding to the skill node to be executed and the candidate skill nodes are the same;

[0203] Starting from the candidate skill node and ending at the next skill node in the task plan, a local path is determined within the skill tree, and the corresponding fragment in the task plan is replaced according to the local path to form an updated task plan.

[0204] Repeat the precondition verification. Based on the execution result of the called skill node, continue to execute the next skill node according to the task plan, or update the steps of the task plan, until the target state is reached, or until there are no candidate skill nodes in the skill tree that meet the preconditions. If so, the task plan is determined to be uncompleted and an exception is reported.

[0205] In one possible implementation, after monitoring the execution result, the control module 403 is further configured to:

[0206] Generate execution logs for the skill nodes to be executed and write the execution logs to the log database. The execution logs include: the environment context vector when the skill node to be executed is invoked, the actual skill parameters used, and the corresponding execution results.

[0207] Periodically extract historical logs of the same skill node from the log library to build a sample set, and divide the sample set into multiple clusters using a preset algorithm. Clusters with an execution success rate higher than the success rate threshold are selected as clusters to be verified.

[0208] For each cluster to be verified, calculate the Gaussian joint distribution of the cluster's environment context vector and skill parameters to obtain the conditional probability, and write the conditional probability into the node configuration table as the parameter recommendation model for the skill node to be executed.

[0209] When the skill node to be executed is invoked again, the real-time environment context vector is used as input, and the parameter recommendation model is used to generate the appropriate recommended skill parameters. The default parameters inside the skill node to be executed are then replaced with the recommended skill parameters.

[0210] In one possible implementation, the control module 403 is further configured to:

[0211] Analyze historical command and task execution logs to identify skill node sequences with an execution success rate greater than or equal to a preset success rate;

[0212] Based on the skill node sequence, a recommended composite skill node is constructed, and a confirmation prompt is output based on the recommended composite skill node;

[0213] After receiving feedback in response to the confirmation prompt, the recommended composite skill node will be added to the skill tree.

[0214] In one possible implementation, the control module 403 is further configured to:

[0215] Retrieve the original skill node sequence to which the skill node sequence belongs;

[0216] Obtain the first skill node immediately preceding the original skill node sequence, and the second skill node immediately following the original skill node sequence;

[0217] Insert the recommended composite skill node into the skill tree, and establish the parent-child relationship between the recommended composite skill node and the first skill node, as well as the parent-child relationship between the recommended composite skill node and the second skill node.

[0218] In one possible implementation, the control module 403 is further configured to:

[0219] The graphical interface displays multiple meta-skill nodes contained in the composite skill node and the logical control node located between each meta-skill node, wherein the logical control node includes at least one of sequence node, parallel node or delay node.

[0220] In response to the user's drag-and-drop operation on the logic control node, update the connection relationship within the composite skill node;

[0221] Based on the updated connection relationships, generate the corresponding updated task plan and execute the updated task plan.

[0222] This embodiment provides a skill tree-based embodied intelligent robot control device, which can execute the skill tree-based embodied intelligent robot control method provided in the above-described method embodiment. Its implementation principle and technical effects are similar, and will not be described in detail here.

[0223] Figure 5 This is a schematic diagram of the structure of an electronic device provided in an embodiment of this application. Figure 5 As shown, the electronic device 50 includes a processor 501 and a memory 502 communicatively connected to the processor 501. Optionally, the electronic device 50 also includes a communication component 503. The processor 501, memory 502, and communication component 503 are connected via a bus 504.

[0224] Memory 502 stores instructions executed by the computer;

[0225] The processor 501 executes computer execution instructions stored in the memory 502 to implement the skill tree-based embodied intelligent robot control method described above.

[0226] At least one processor 501 may be a central processing unit (CPU), an application-specific integrated circuit (ASIC), or one or more integrated circuits configured to implement the embodiments of this application.

[0227] Optionally, in specific implementations, the processor 501 and memory 502 are implemented independently. In this case, the processor 501 and memory 502 can be interconnected via a bus to complete communication between them. The bus can be an Industry Standard Architecture (ISA) bus, a Peripheral Component Interconnect (PCI) bus, or an Extended Industry Standard Architecture (EISA) bus, etc. Buses can be categorized as address buses, data buses, control buses, etc., but this does not imply that there is only one bus or one type of bus.

[0228] Optionally, in a specific implementation, if the processor 501 and the memory 502 are integrated on a single chip, the processor 501 and the memory 502 can communicate through an internal interface.

[0229] This application also provides a computer storage medium storing computer execution instructions, which, when executed by a processor, implement the aforementioned technical solution of the embodied intelligent robot control method based on a skill tree.

[0230] The aforementioned computer-readable storage medium can be implemented by any type of volatile or non-volatile storage device or a combination thereof, such as static random access memory (SRAM), electrically erasable programmable read-only memory (EEPROM), erasable programmable read-only memory (EPROM), programmable read-only memory (PROM), read-only memory (ROM), magnetic storage, flash memory, magnetic disk, or optical disk. The computer-readable storage medium can be any available medium accessible to a general-purpose or special-purpose computer.

[0231] An exemplary readable storage medium is coupled to a processor, enabling the processor to read information from and write information to the readable storage medium. Alternatively, the readable storage medium can be an integral part of the processor. Both the processor and the readable storage medium can reside in an Application Specific Integrated Circuit (ASIC). Alternatively, the processor and the readable storage medium can exist as discrete components in the control device of a garment handling apparatus.

[0232] This unit division is merely a logical functional division; in actual implementation, there may be other division methods. For example, multiple units or components may be combined or integrated into another system, or some features may be ignored or not executed. Furthermore, the coupling or direct coupling or communication connection shown or discussed may be indirect coupling or communication connection through some interfaces, devices, or units, and may be electrical, mechanical, or other forms.

[0233] The units described as separate components may or may not be physically separate. The components shown as units may or may not be physical units; that is, they may be located in one place or distributed across multiple network units. Some or all of the units can be selected to achieve the purpose of this embodiment according to actual needs.

[0234] In addition, the functional units in the various embodiments of the present invention can be integrated into one processing unit, or each unit can exist physically separately, or two or more units can be integrated into one unit.

[0235] If this function is implemented as a software functional unit and sold or used as an independent product, it can be stored in a computer-readable storage medium. Based on this understanding, the technical solution of this invention, or the part that contributes to the prior art, or a part of the technical solution, can be embodied in the form of a software product. This computer software product is stored in a storage medium and includes several instructions to cause a computer device (which may be a personal computer, server, or network device, etc.) to execute all or part of the steps of the methods indicated in the various embodiments of this invention. The aforementioned storage medium includes various media capable of storing program code, such as USB flash drives, portable hard drives, read-only memory (ROM), random access memory (RAM), magnetic disks, or optical disks.

[0236] Those skilled in the art will understand that all or part of the steps of the above-described method embodiments can be implemented by hardware related to program instructions. The aforementioned program can be stored in a computer-readable storage medium. When executed, the program performs the steps of the above-described method embodiments; and the aforementioned storage medium includes various media capable of storing program code, such as ROM, RAM, magnetic disks, or optical disks.

[0237] The technical solutions of this application have been described above with reference to the preferred embodiments shown in the accompanying drawings. However, it is readily understood by those skilled in the art that the scope of protection of this application is obviously not limited to these specific embodiments. The above embodiments are only used to illustrate the technical solutions of this application and are not intended to limit them. Although this application has been described in detail with reference to the foregoing embodiments, those skilled in the art should understand that modifications can still be made to the technical solutions described in the foregoing embodiments, or equivalent substitutions can be made to some or all of the technical features therein. 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 embodiments of this application.

Claims

1. A method for controlling an embodied intelligent robot based on a skill tree, characterized in that, The method includes: In response to receiving a task instruction, obtain the current skill node and the target state indicated by the task instruction; The target state is matched with the attainable states associated with each skill node in the pre-built skill tree, and the skill node that matches the target state is determined as the target skill node. The skill tree contains multiple skill nodes, and each skill node encapsulates the skill operation that the embodied intelligent robot can perform and the state that can be achieved after execution. Based on the state transition relationship between skill nodes, a feasible path is searched in the skill tree to transition from the current state encapsulated by the current skill node to the target state encapsulated by the target skill node, and a task plan consisting of at least one skill node is generated according to the feasible path. The skill operations encapsulated in each skill node are invoked sequentially according to the task plan to drive the embodied intelligent robot to complete the task instructions.

2. The method according to claim 1, characterized in that, Before obtaining the current skill node and target state, the method further includes: The system acquires multiple basic skill operations that the embodied intelligent robot can perform, and encapsulates each basic skill operation into a corresponding meta-skill node, wherein the meta-skill node is an indivisible atomic action unit; Extract the action feature parameters of each meta-skill node, and calculate the composite compatibility between each meta-skill node based on the action feature parameters. The composite compatibility is used to indicate the compatibility level of multiple meta-skill nodes performing the same composite skill operation in different orders. Based on the composite compatibility, multiple meta-skill nodes are divided into multiple clusters using a clustering analysis algorithm, and each cluster is encapsulated as a composite skill node. The composite skill node is used to indicate a reusable skill template composed of at least two meta-skill nodes. A skill tree is constructed based on the meta-skill nodes and the composite skill nodes.

3. The method according to claim 1, characterized in that, The sequential invocation of skill operations encapsulated in each skill node according to the task plan includes: Obtain the skill nodes to be executed and their corresponding prerequisites from the task plan; Determine whether the current environment information obtained by parsing the task instruction meets the prerequisite execution conditions; If the conditions are met, the skill operation encapsulated in the skill node to be executed is invoked, and the execution result is monitored. Based on the execution result, continue executing the next skill node according to the task plan, or update the task plan; If the conditions are not met, then a candidate skill node corresponding to the skill node to be executed is determined, wherein the sub-target states corresponding to the skill node to be executed and the candidate skill node are the same; Starting from the candidate skill node and ending at the next skill node in the task plan, a local path is determined within the skill tree, and the corresponding segment in the task plan is replaced according to the local path to form an updated task plan. Repeat the precondition verification, and continue to execute the next skill node according to the task plan based on the execution result of the called skill node, or update the steps of the task plan, until the target state is reached, or until there are no candidate skill nodes in the skill tree that meet the preconditions. If so, the task plan is determined to be uncompleted and an exception is reported.

4. The method according to claim 3, characterized in that, After monitoring the execution results, the method further includes: Generate the execution log of the skill node to be executed, and write the execution log to the log library. The execution log includes: the environment context vector when the skill node to be executed is invoked, the actual skill parameters used, and the corresponding execution result. Periodically extract historical logs of the same skill node from the log library to construct a sample set, and divide the sample set into multiple clusters using a preset algorithm. Clusters with an execution success rate higher than the success rate threshold are selected as clusters to be verified. For each cluster to be verified, calculate the Gaussian joint distribution of the cluster's environment context vector and skill parameters to obtain the conditional probability, and write the conditional probability as the parameter recommendation model for the skill node to be executed into the node configuration table; When the skill node to be executed is invoked again, the real-time environment context vector is used as input, and the parameter recommendation model is used to generate suitable recommended skill parameters, and the default parameters inside the skill node to be executed are replaced according to the recommended skill parameters.

5. The method according to claim 2, characterized in that, The method further includes: Analyze historical command and task execution logs to identify skill node sequences with an execution success rate greater than or equal to a preset success rate; Based on the skill node sequence, a recommended composite skill node is constructed, and a confirmation prompt is output based on the recommended composite skill node; Upon receiving feedback in response to the confirmation prompt, the recommended composite skill node is added to the skill tree.

6. The method according to claim 5, characterized in that, Adding the recommended composite skill node to the skill tree includes: Retrieve the original skill node sequence to which the skill node sequence belongs; Obtain the first skill node immediately preceding the skill node sequence and the second skill node immediately following the skill node sequence from the original skill node sequence; The recommended composite skill node is inserted into the skill tree, and a parent-child relationship is established between the recommended composite skill node and the first skill node, as well as a parent-child relationship between the recommended composite skill node and the second skill node.

7. The method according to claim 1, characterized in that, The method further includes: The graphical interface displays multiple meta-skill nodes contained in the composite skill node and logical control nodes located between each meta-skill node, wherein the logical control node includes at least one of sequence nodes, parallel nodes, or delay nodes. In response to the user's drag operation on the logical control node, update the connection relationship within the composite skill node; Based on the updated connection relationships, a corresponding updated task plan is generated and executed.

8. A skill tree-based embodied intelligent robot control device, characterized in that, It includes: a parsing module, a plan generation module, and a control module, among which: The parsing module is used to obtain the current skill node and the target state indicated by the task instruction in response to receiving the task instruction; The plan generation module is used to match the target state with the achievable states associated with each skill node in the pre-built skill tree, and to determine the skill node that matches the target state as the target skill node. The skill tree contains multiple skill nodes, and each skill node encapsulates the skill operation that the embodied intelligent robot can perform and the state that can be achieved after execution. The plan generation module is also used to search in the skill tree for a feasible path from the current state encapsulated by the current skill node to the target state encapsulated by the target skill node based on the state transition relationship between skill nodes, and generate a task plan consisting of at least one skill node based on the feasible path. The control module is used to sequentially call the skill operations encapsulated in each skill node according to the task plan, so as to drive the embodied intelligent robot to complete the task instructions.

9. An electronic device, characterized in that, include: A processor, and a memory communicatively connected to the processor; The memory stores computer-executed instructions; The processor executes computer execution instructions stored in the memory to implement the method as described in any one of claims 1 to 7.

10. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores computer-executable instructions, which, when executed by a processor, are used to implement the skill tree-based embodied intelligent robot control method as described in any one of claims 1 to 7.

Images