A robot task planning method, apparatus and device

Abstract

The present disclosure belongs to the technical field of robots, and particularly relates to a robot task planning method, device and equipment. The method comprises generating a backbone task plan of a target scene based on constraint conditions for an abstract task description by using a large language model, wherein the backbone task plan is a preliminary step for executing a task corresponding to the abstract task description, the preliminary step comprises a series of combinations formed by operations, objects of the operations and relationships between the objects, and the constraint conditions comprise scene constraint conditions and operation constraint conditions; performing answer set encoding based on the backbone task plan, when a first answer set program is instantiated, only the objects directly related to the operations in the backbone task plan are instantiated, a loop-tolerable reduction constant is generated, a second answer set program is generated based on the loop-tolerable reduction constant; and a task plan executable by a robot is generated based on the second answer set program.

Description

TECHNICAL FIELD

[0001] The present disclosure belongs to the technical field of robots, and particularly relates to a robot task planning method, device and equipment. BACKGROUND

[0002] Robot task planning relies on combining task descriptions with items in a scene to generate executable action sequences. Large language models (LLMs) are often used for task planning because they have common sense reasoning capabilities. However, LLMs have difficulty maintaining the coherence of key information when processing long tasks, especially when environmental constraint information needs to be considered, resulting in task plans that lack executability. Answer set programming (ASP) is a symbolic planning method that can provide comprehensive and explainable planning results. Therefore, combining LLMs with ASP for generating executable task plans for long tasks has become a research hotspot in the field of task planning.

[0003] However, the solving process of ASP in complex task scenarios often requires a large amount of computing time, especially when multiple items and environmental constraints are involved, the solving speed is too slow to meet the actual application requirements. SUMMARY

[0004] Embodiments of the present disclosure propose a robot task planning scheme based on LLM combined with ASP, which solves the problem of too long computing time of existing robot task planning schemes based on LLM combined with ASP.

[0005] A first aspect of embodiments of the present disclosure provides a robot task planning method, comprising:

[0006] generating a backbone task plan for a target scene based on constraint conditions using a large language model for an abstract task description, wherein the backbone task plan is a preliminary step for executing a task corresponding to the abstract task description, and the preliminary step includes a combination of a series of operations, objects of the operations, and relationships between the objects, and the constraint conditions include scene constraint conditions and operation constraint conditions;

[0007] performing answer set encoding based on the backbone task plan, and when instantiating a generated first answer set program, only instantiating the objects directly related to the operations in the backbone task plan, generating a loop-tolerable reduction constant, and generating a second answer set program based on the loop-tolerable reduction constant;

[0008] generating a robot executable task plan based on the second answer set program.

[0009] In some embodiments, the generating a backbone task plan for a target scene based on constraint conditions using a large language model for an abstract task description comprises:

[0010] Using a large language model to describe abstract tasks, an initial plan for the target scenario is generated based on constraints.

[0011] The initial plan is then subjected to a rule-based syntax checker to perform syntax checks and correct syntax errors.

[0012] Based on semantic similarity analysis, the accuracy of the operations and objects in the initial plan is ensured, and the backbone task plan is generated.

[0013] In some embodiments, the encoding of the response set based on the backbone task plan includes:

[0014] The coding rules for the answer set are determined based on the aforementioned operational constraints;

[0015] The operations, objects of the operations, and relationships between the objects in the backbone task plan are converted into answer set codes.

[0016] In some embodiments, instantiating only the objects directly related to the operations in the backbone task plan and generating a cycle-tolerant shrinkable constant includes:

[0017] Extract a second set of constants directly related to the operation from the backbone task plan;

[0018] Verify whether the second set of constants is the cyclically reducible constant. If the second set of constants is not the cyclically reducible constant, repeat the above steps.

[0019] In some embodiments, after generating the loop-tolerant shrinkable constant, the method further includes:

[0020] Based on computational integrity, the loop-compatible shrinkable constant is expanded to generate a third set of constants;

[0021] The program generates the second answer set based on the third set of constants.

[0022] In some embodiments, expanding the cyclically tolerant shrinkage constant based on computational integrity includes:

[0023] Identify the loop rules in the task;

[0024] Based on the aforementioned loop rules, the loop can be expanded to accommodate shrinking constants.

[0025] In some embodiments, extracting the second set of constants directly related to the operation from the backbone task plan includes:

[0026] The objects of the operations in the backbone task plan constitute the first set of constants;

[0027] For each operation in the backbone task plan, determine the scope of influence of the operation, delete constants that do not belong to the scope of influence in the first set of constants, generate a second set of constants, and use the second set of constants as the loop-tolerant shrinkable constants.

[0028] In some embodiments, verifying whether the second set of constants is the cyclically scalable constant includes:

[0029] If the third answer set of the third answer set program generated based on the second constant set has a corresponding first answer set in the first answer set program and satisfies that the third answer set is a subset of the first answer set; and

[0030] If each first answer set in the first answer set program has a corresponding third answer set in the third answer set program and the third answer set is a subset of the first answer set;

[0031] Then it is confirmed that the second set of constants is the cycle-tolerant shrinkable constant;

[0032] Otherwise, the second set of constants is not the loop-compatible shrinkable constant.

[0033] A second aspect of this disclosure provides a robot task planning apparatus, comprising:

[0034] The backbone task plan generation module is used to generate a backbone task plan for a target scenario based on constraints by using a large language model to analyze an abstract task description. The backbone task plan is a preliminary step for executing the task corresponding to the abstract task description. The preliminary step includes a series of combinations formed by operations, objects of the operations, and relationships between the objects. The constraints include scenario constraints and operation constraints.

[0035] The answer set encoding module is used to encode the answer set based on the backbone task plan. When instantiating the generated first answer set program, it only instantiates the objects that are directly related to the operation in the backbone task plan, generates a loop-compatible shrinking constant, and generates a second answer set program based on the loop-compatible shrinking constant.

[0036] The task planning module is used to generate a task plan that the robot can execute based on the second answer set program.

[0037] A third aspect of this disclosure provides a robot task planning device, including a memory and a processor:

[0038] The memory is used to store computer programs;

[0039] The processor is configured to implement the method described in any of the first aspects of this disclosure when executing the computer program.

[0040] In summary, the robot task planning method, apparatus, and device provided in the embodiments of this disclosure first utilize LLM to generate a backbone task plan to accelerate the answer set programming process. Using the backbone task plan as input to the ASP reduces the search space, thereby accelerating the solution process. Then, based on the loop-tolerant reduction technique, it identifies constant quantum sets in the ASP program that do not affect the solution set. Since the large computational load of ASP solutions is mainly due to the excessively large definition of variable fields, identifying those constant quantum sets that can be omitted without affecting the overall solution set of the program can significantly reduce the computational burden during ASP program instantiation. Thus, while ensuring computational integrity, it significantly accelerates the generation of executable plans. Attached Figure Description

[0041] The features and advantages of this disclosure will be more clearly understood by referring to the accompanying drawings, which are schematic and should not be construed as limiting the scope of this disclosure in any way.

[0042] Figure 1 This is a schematic diagram of a computer system to which this disclosure applies;

[0043] Figure 2 This is ASP code that uses the actions wash and find to illustrate robot task planning;

[0044] Figure 3 This is a system framework diagram of a two-stage robot task planning method according to some embodiments of the present disclosure;

[0045] Figure 4 This is a flowchart illustrating a robot task planning method according to some embodiments of the present disclosure;

[0046] Figure 5 Based on Figure 4 The methods described in S410-S430 are used for task planning timelines in complex task environments;

[0047] Figure 6 This is a comparison table of the executability and target condition recall rate (GCR) of various task planning algorithms;

[0048] Figure 7 This is a schematic diagram of a robot task planning device according to some embodiments of the present disclosure;

[0049] Figure 8 This is a schematic diagram of a robot task planning device according to an embodiment of the present disclosure. Detailed Implementation

[0050] In the following detailed description, numerous specific details of this disclosure are set forth by way of example in order to provide a thorough understanding of the relevant disclosure. However, it will be apparent to those skilled in the art that this disclosure may be practiced without these details. It should be understood that the terms “system,” “apparatus,” “unit,” and / or “module” used in this disclosure are a method of distinguishing different parts, elements, sections, or components at different levels in a sequential arrangement. However, these terms may be replaced by other expressions if they can achieve the same purpose.

[0051] It should be understood that when a device, unit, or module is referred to as being "on," "connected to," or "coupled to" another device, unit, or module, it may be directly connected to or coupled to, or communicate with, other devices, units, or modules, or there may be intermediate devices, units, or modules present, unless the context explicitly indicates otherwise. For example, the term "and / or" as used in this disclosure includes any one and all combinations of one or more of the associated listed items.

[0052] The terminology used in this disclosure is for the purpose of describing particular embodiments only and is not intended to limit the scope of this disclosure. As shown in this specification and claims, unless the context clearly indicates otherwise, words such as "a," "an," "an," and / or "the" do not specifically refer to the singular and may include the plural. Generally speaking, the terms "comprising" and "including" only indicate the inclusion of explicitly identified features, integrals, steps, operations, elements, and / or components, and such expressions do not constitute an exclusive list, in which other features, integrals, steps, operations, elements, and / or components may also be included.

[0053] Referring to the following description and accompanying drawings, these and other features and characteristics, operating methods, functions of related structural elements, combinations of parts, and economics of manufacture of this disclosure can be better understood, wherein the description and drawings form part of the specification. However, it is clearly understood that the drawings are for illustrative and descriptive purposes only and are not intended to limit the scope of protection of this disclosure. It is understood that the drawings are not drawn to scale.

[0054] Various structural diagrams are used in this disclosure to illustrate various variations of embodiments according to this disclosure. It should be understood that the preceding or following structures are not intended to limit this disclosure. The scope of protection of this disclosure is defined by the claims.

[0055] Figure 1 This is a schematic diagram of a computer system applicable to this disclosure. Figure 1The system shown includes a task planning server connected to robot data in the target scene. The task planning server generates task planning for the robot in the target scene based on abstract task descriptions, operational constraints, and scene constraints.

[0056] Robot task planning refers to the sequence of executable operations for a robot formed based on a task description. The task planning server can be a single machine, a cluster, or a distributed server. The task planning server is deployed with a Large Language Model (LLM). LLM is a large-scale deep learning model primarily used for natural language understanding, possessing common-sense reasoning capabilities.

[0057] LLM's commonsense reasoning ability allows it to formulate preliminary steps for a task based on its understanding of the task description. However, when dealing with long-running tasks, especially those requiring consideration of environmental constraints, LLM struggles to maintain the coherence of key information, resulting in task plans lacking executability. To address this issue, researchers have attempted to integrate external tools, such as knowledge-based feedback, local checker feedback, or feedback from physical environment interactions, to influence subsequent planning outputs of LLM through prompts. However, this text-based feedback lacks convergence guarantees and cannot ensure that LLM ultimately generates an executable plan.

[0058] Answer Set Programming (ASP), as a symbolic programming method, offers comprehensive and interpretable planning results, making it a potential solution to the lack of executability in LLM-based task planning methods.

[0059] A simple ASP program consists of three parts: facts, rules, and output. Facts and rules are used to describe the problem; output is used to view the results. Facts describe the state of the real world; rules are used for reasoning.

[0060] ASP programs include constants (such as various operation objects), predicates (such as various operations), and variables. In essence, ASP programs do not support variables. Variables during coding are only for convenience. In the actual solution, these variables will be replaced by all the constants that appear in the program, which is called instantiation.

[0061] An atomic formula without variables is called an "instantiated atomic formula," or basic atom. A common logic program (i.e., an ASP program with variables) is a finite set of rules, in the form of:

[0062] A0←A1,…,A m ,not A m+1 ..., not An .

[0063] Where Ai (0≤i≤n) are atoms, and n≥1. We can also rewrite the rule r of the above form as head(r) ← body(r). Where body(r) includes positive and negative conditions, i.e., body + (r) = {A1, ..., A} m} and body - (r)={A m+1 A n In an ASP program, Π is "instantiated," meaning all rules within it have been instantiated and no longer contain any variables. Π is "safe," meaning every variable appearing in a rule also appears in the positive condition body. + In the basic atoms of (r). The security of ASP programs is achieved through the use of domain predicates, which are unary predicates that are given as facts and are true for all constants covered by variables in the program.

[0064] The Herbrand universe of an ASP program, denoted as HU(Π), is the set of all constants. Given a set Variables and a set The instantiation result of the constant, rule r is This represents the set of all possible constant substitution combinations. The instantiation result of the ASP program Π is Π| HU(Π) =∪ r∈Π r| HU(Π) Given an interpretation I, i.e., I is a set of instantiated atomic formulas, I satisfies a field rule r if head(r) ∈ I if and only if and An explanation of I is a model of Π if and only if I satisfies Π| HU(Π) All instance rules in J. If no other model J makes... Then model I is the smallest.

[0065] Next, we define the answer set of an ASP program with variables. Given an ASP program Π and an interpretation I, the Gelfond-Lifschitz reduction I is on I, denoted as: Π I This is used to remove rules that do not meet the conditions from the instantiation result of Π. After reduction, Π I It has a unique minimal model. An explanation I is a response set of Π if and only if I is a minimal model of Π. I An ASP program may have zero, one, or more sets of answers as a solution.

[0066] Positive dependency graph G of ASP program ΠΠ It is a directed graph with vertex Π|| HU(Π) The atomic formula in [the text]. If the head of rule r contains A and the positive condition of body contains B, i.e., A∈head(r) and B∈body. + If (r), then there is an arc from A to B. A set of strongly connected instantiation atom formulas L is called a cycle of Π. For each cycle L, the instantiation rule r∈Π| HU(Π) It is the external support of L, where the external support rules of L constitute R. - (L, Π), and defined by the iterative formula LF(L, Π):

[0067]

[0068] Robot task planning problems can be encoded as ASP programs, where each set of responses corresponds to a plan, i.e., a sequence of executable actions for that problem. This disclosure uses Clingo (an efficient ASP solver) to solve the planning task incrementally. By defining action and state transition specifications, it progressively verifies whether the target state is satisfied, ultimately generating the execution sequence.

[0069] This section uses the actions `wash` and `find` ("washing" and "finding") as examples to illustrate the coding of robot actions. The code is as follows: Figure 2 As shown. Figure 2 In the code, line 1 activates Clingo's incremental computation model. Lines 2, 9, and 20 divide the encoding into a static part, a state transition specification, and a part checking the target condition. Lines 3 and 4 define the domain predicates for the corresponding constants. Lines 5 and 6 define the names of possible actions. Line 7 defines the initial state, and line 8 specifies the task to be completed. Line 10 selects the operation to be performed at time t. Lines 11-13 define the effect and prerequisites of the action `wash`, and lines 14 and 15 define the action `find`. Lines 16-18 establish the inertia rules for the predicates `hand_empty(C)`, `same_loc(C,O)`, and `clean(O)`. Line 19 defines the target state constraints for the task. Line 21 checks whether the target condition is satisfied at time t. Finally, line 22 allows Clingo to only display results of the form `occurs(A,t)` that occur in the answer set of its computations. Clingo can compute the set of answers for this encoding and return “occurs(find(2),1).occurs(wash(2),2).” as the task plan.

[0070] Following the above coding scheme, we can introduce more actions and predicates to specify real-world robot task planning problems. In indoor robot task planning, handling a large number of constants and actions often leads to low coding efficiency. Overly large variable fields result in slow ASP program solvers, making it difficult to meet the practical application requirements of robot task planning.

[0071] To address the issue of slow ASP solution speed in robot task planning based on LLM combined with ASP, this disclosure proposes a two-stage robot task planning method, the system framework of which is as follows: Figure 3 As shown. Specifically, firstly, LLM is used to generate a backbone task plan, which serves as input to the ASP; then, based on the cyclically commensurable reduction technique, the constant quantum set in the ASP program that does not affect the solution set is identified, and a task plan executable by the robot is generated.

[0072] Figure 4 This is a flowchart illustrating a robot task planning method according to some embodiments of the present disclosure. In some embodiments, the robot task planning method is... Figure 1 The task planning server shown executes the robot task planning method, which includes the following steps:

[0073] S410, using a large language model to generate a backbone task plan for the target scenario based on constraints of the abstract task description, wherein the backbone task plan is the preliminary steps for executing the task corresponding to the abstract task description, the preliminary steps include a series of combinations formed by operations, objects of the operations, and relationships between the objects, and the constraints include scenario constraints and operation constraints.

[0074] The goal of robot task planning is to generate an executable sequence of robot operations based on the task specified in the abstract task description. An abstract task description often describes a "vision," and only by concretizing it into a target scenario can the actual tasks to be performed be obtained. For example, the abstract task description "get a banana" needs to be broken down into specific tasks such as "open the refrigerator door," "take out the fruit basket containing bananas," and "take a banana from the fruit basket" based on a concrete scenario in order to generate an executable sequence of operations.

[0075] Specifically, the LLM first generates an initial plan based on the task description and environmental information.

[0076] Then review the initial plan A grammatical evaluation is performed, using a rule-based grammar checker to identify illogical or malformed operation information. Based on this error feedback, the LLM iteratively regenerates a new task plan. This inspection process continues until the plan is finalized. Satisfy all syntactic criteria or reach the maximum iteration limit k max .

[0077] Finally, semantic similarity analysis is used to ensure the accuracy of operations and objects, and cosine similarity method is used for term evaluation. The semantic relevance of actions and objects in the code to the corresponding entities in the environment. This ultimately generates the skeleton plan τ. s Specifically, this module calculates... The semantic relevance of terms is assessed by comparing the embedding vectors of actions and objects in the context with those in the actual scene. in and These represent the embedding vectors of actions and objects in the "plan" and "environment," respectively. For example, the plan instruction "Open TV" should be "Switch on TV," because "Open" is not suitable for describing the action of operating a TV. Similarly, "walk kitchencounter" should be corrected to "walk tokitchen," because there is no location named "kitchencounter" in the environment. The skeleton plan τ generated at this stage s This will be used as input to ASP for further optimization of the task plan.

[0078] The plan s As a coarse solution, it includes the preliminary steps of task execution (such as actions and target states), reducing the search space for ASP solutions.

[0079] In the backbone task plan "Open the refrigerator door", "Take out the fruit basket containing bananas" and "Take a banana from the fruit basket" generated based on the abstract task description of "Eat a banana", each task includes an operation (open, take out, take), an operation object (refrigerator door, banana, fruit basket), and the relationship between multiple operation objects (such as the positional relationship between banana and fruit basket, and the positional relationship between fruit basket and refrigerator).

[0080] LLM (Layered Modeling) visualizes abstract task descriptions based on various constraints. Common constraints include operational constraints, such as the timing constraints of various operations, and scenario constraints, such as the positional constraints of various operation objects.

[0081] S420, based on the backbone task plan, the answer set is encoded. When instantiating the generated first answer set program, only the objects directly related to the operation in the backbone task plan are instantiated, a loop-tolerant shrinking constant is generated, and a second answer set program is generated based on the loop-tolerant shrinking constant.

[0082] Specifically, the first step is to perform ASP coding based on the backbone task plan:

[0083] Encode the robot motion model (such as operational constraints) into ASP rules; convert the skeleton task plan and scene constraints into ASP code.

[0084] Then, a loop-tolerant reduction technique is used to reduce the computational load during ASP instantiation and accelerate the solution process. Specifically, a variable field reduction technique is employed, instantiating only task-related variables and eliminating unnecessary computations. This method can effectively filter out task-irrelevant objects and narrow the search space. For example, when performing the task of "placing a chair next to a table," the pen on the table is irrelevant, so pen-related states and constraints can be ignored.

[0085] To ensure consistency with the complete solution even when certain objects or conditions are ignored, this disclosure employs a cyclically accommodative reduction technique. This technique reduces the size of constants by identifying ignorable sets of constants in the ASP code, while maintaining the integrity of the potential solution set. The core idea is that even when some minor objects or conditions are ignored, the result remains consistent with the complete solution. This process is achieved by identifying and removing sets of objects that have no impact on task execution, thereby significantly reducing the computational load during the solution process and accelerating the generation of the executable plan. Finally, based on the optimized code, the ASP outputs a complete and executable task plan τ. f .

[0086] Specifically, a set D of constants related to operations is extracted from the skeleton task plan. For each operation in the skeleton task plan, based on the scope of influence of the operation, constants outside the scope of influence of the operation are removed from D, ultimately generating...

[0087] This disclosure is verified based on the following rules. Is it a loop-tolerant shrinking constant of D?

[0088] Given an ASP program Π (with variables), one set of... constant Is the cyclic resizable of ∏ if

[0089] 1. There exists a set I of responses to the original program ∏ such that , where I D It is a set of answers from Π|D.

[0090] 2. For each answer set I in Π, there exists an answer set ID in Π|D such that

[0091] Intuitively speaking, the requirements The rules and newly introduced loop formulas can be extended And I′ to satisfy.

[0092] If verified, If the loop in D is not a shrinkable constant, then based on the scope of the operation, continue filtering out objects irrelevant to the task within D, and repeatedly generate them. Until verified It is the loop-tolerant shrinking constant of D.

[0093] Finally, based on the cyclic compatibility reduction constant. Answer set generation program Π * .

[0094] In some embodiments of this disclosure, a cyclically compatible shrinkage constant is obtained. Subsequently, based on the completeness of the solution, it may be necessary to include the elements appearing in ∏. HU(P) Additional constants added to the atoms of the cycle L This is used to expand the loop-tolerant shrinkable constants. The occurrence of expanded constants depends on whether these constants appear in binary predicates associated with constants in D. For example, binary predicates such as on(o1,o2), in(o1,o2), and close(o1,o2).

[0095] One embodiment of this disclosure provides an example of cyclically tolerant scaling based on the task of "setting up a table":

[0096] Example task: Set up the table

[0097] 1. Define the original ASP program Π

[0098] Suppose we have an ASP program Π that describes all possible rules for setting up table tasks (but this example program may also include rules for washing, walking, etc.):

[0099] 1. has_object(table1).

[0100] 2. has_object(chair1).

[0101] 3. has_object(chair2).

[0102] 4. place(chair1, table1).

[0103] 5. place(chair2, table1).

[0104] 6.←place(chair1,X),place(chair2,X),X≠table1.

[0105] % Rules related to the "wash" task

[0106] 7. has_object(broom1).

[0107] 8. clean(broom1,room1).

[0108] 9. dirty (room1).

[0109] 10. ←clean(broom1,X), dirty(X).

[0110] % Rules related to "movement" tasks

[0111] move(robot1,location1).

[0112] 12.at(robot1,location1).

[0113] 13.←move(robot1,X),at(robot1,X).

[0114] % Other rooms, items, and other irrelevant variables

[0115] has_object(pen1).

[0116] on(pen1, table2).

[0117] in(room2,house1).

[0118] 17. at (chair3, room2).

[0119] 2. Preliminary Explanation

[0120] The initial solution provided by the large model is "setting up the table," meaning we need to ensure that the chairs are correctly placed next to the table. Based on this solution, we choose a set of constants D associated with it for reduction: Related constant set D = {table1, chair1, chair2}

[0121] 3. Generate simplified ASP programs Π|D

[0122] We generate a simplified ASP program Π| based on the constant set D. D :

[0123] 1. has_object(table1).

[0124] 2. has_object(chair1).

[0125] 3. has_object(chair2).

[0126] 4. place(chair1, table1).

[0127] 5. place(chair2, table1).

[0128] 6.←place(chair1,X),place(chair2,X),X≠table1.

[0129] This program Π| D It is a simplified version of the original program Π, containing only elements from the constant set D.

[0130] Note that in this example, the simplified program is structurally identical to the original program because D already includes all the program's key constants.

[0131] 4. Application loop can be reduced.

[0132] To verify whether D = {table1, chair1, chair2} is a cyclically reducible loop, we need to check...

[0133] Check the following two conditions:

[0134] There exists a set I of responses to the original program Π such that Where ID is Π| D A collection of answers.

[0135] For each set of answers I in Π, there exists Π| D One of the answer sets I D , making

[0136] Verification process:

[0137] 1. Check Π| D The answer set:

[0138] Possible responses include placing chair1 and chair2 next to table1.

[0139] • These answer sets must satisfy the constraints in Π, such as ←place(chair1,X),place(chair2,X),X≠table1.

[0140] 2. Verify the answer set of the original program Π:

[0141] ●We check if the answer set in Π contains Π| D All the answers in the set.

[0142] For example, if one of the answer sets in Π is to place chair1 and chair2 next to table1,

[0143] Then this solution set is in Π| D It should also exist in China.

[0144] Example: Suppose that a valid set of responses I in Π is:

[0145] place(chair1, table1).

[0146] place(chair2, table1). In Π| D In the middle, we can find I D ,For example:

[0147] place(chair1, table1).

[0148] place(chair2, table1). Obviously, Therefore, D satisfies the first condition. For the answer set I in each Π, as described above, I D In Π| D It can also be found in [the database], satisfying the second condition.

[0149] 5. Determine if the cyclic compatibility reduction requirement is met.

[0150] Since D satisfies the above two conditions, D = {table1,chair1,chair2} is a cyclically inclusive reduction of Π. This means that we can omit constants not in D during computation, thereby reducing computational complexity while maintaining the validity of the solution.

[0151] Summarize

[0152] In practical applications, by selecting the relevant constant set D, and simplifying the ASP program Π| based on this set, D We can reduce the computational burden by utilizing loop-tolerant reduction. The verification process includes ensuring that the answer set of the simplified program can be mapped to the answer set of the original program, and ensuring that there is a corresponding answer set of the simplified program for each answer set of the original program.

[0153] S430, Based on the second answer set program, generate a task plan that the robot can execute.

[0154] Specifically, through calculation The solutions obtained from the answer set reflect the task planning results optimized through the skeleton plan.

[0155] One embodiment of this disclosure uses the Virtual Home (VH) simulator v2.3.0 to simulate robot activities in a home environment. Figure 4 The methods described in S410-S430 have been verified.

[0156] Three LLMs were used: GPT-3.5, GPT-4, and Llama3-8b, all accessed via their API interfaces. The semantic inspection module used the all-MiniLM-L6-v2 model to embed actions and objects. The logic processing employed the Clingo v5.6.2 ASP solver.

[0157] Task planning is evaluated based on two key metrics: Executability (Exec) and General Recall (GCR). Exec checks the plan's ability to execute in the simulator, particularly the adaptability of actions and objects (focusing on syntax checking and basic behavioral logic). GCR compares the degree of matching between the plan's state before and after execution and the target state; the calculation method is as follows:

[0158]

[0159] Where |·| represents the number of state and relation changes. C gt This represents the ideal state after the plan is executed. This state defines the objects and the relationships between them, and is also known as the reference answer. It is the standard answer that the plan should achieve. initial The initial state represents the state before the plan is executed, encompassing all objects in the environment and their relationships. It is the starting point for the environmental state during plan execution. c′ represents the final state after plan execution, reflecting the actual impact of the plan on the environment, including changes in objects and their relationships. This state is the result of the plan's execution.

[0160] In addition, the average length of action sequences and the runtime of ASP planning were evaluated before and after the introduction of efficiency strategies.

[0161] The verification results show that:

[0162] Efficiency improvement:

[0163] like Figure 5 As shown, LMWITE FASTASP (LMWITH FASTASP is...) Figure 4 The methods described in S410-S430 significantly improve the efficiency of ASP inference when dealing with complex task environments, reducing the inference time from more than 2 hours to less than 20 seconds.

[0164] Improved executability and goal achievement:

[0165] like Figure 6As shown, the LMWITEFASTASP framework significantly outperforms other existing methods in both executability and target condition recall rate (GCR). In particular, in terms of executability, it achieves an execution success rate of over 90%, which indicates that it not only accelerates task planning but also effectively generates executable plans that conform to robot-specific constraints.

[0166] Specifically, Figure 6 In this paper, we conduct a detailed comparison with two representative task planning methods (Zero-shot Planner and ProgPrompt). These two methods represent different paths that LLM attempts to take to improve the executability of task planning by integrating external tools: Zero-shot Planner uses knowledge base feedback and local checkers to provide error information, while ProgPrompt optimizes the task plan through information from physical environment interactions. However, these methods still suffer from poor task plan executability when dealing with complex environments. As... Figure 6 As shown, LMWITEFASTASP significantly outperforms these baseline methods in terms of implementability and goal achievement.

[0167] As can be seen, this disclosure ensures computational integrity by reducing the computational burden during the instantiation process, while significantly accelerating the generation of executable plans.

[0168] Figure 7 This is a schematic diagram of a robot task planning device according to some embodiments of the present disclosure. Figure 7 As shown, the robot task planning device 700 includes a backbone task plan generation module 710, an answer set encoding module 720, and a task planning module 730. In some embodiments of this disclosure, the robot task planning function is... Figure 1 The task planning server is executed as shown. Among them:

[0169] The backbone task plan generation module 710 is used to generate a backbone task plan for a target scenario based on constraints by using a large language model to analyze an abstract task description. The backbone task plan is a preliminary step for executing the task corresponding to the abstract task description. The preliminary step includes a series of combinations formed by operations, objects of the operations, and relationships between the objects. The constraints include scenario constraints and operation constraints.

[0170] The answer set encoding module 720 is used to encode the answer set based on the backbone task plan. When instantiating the generated first answer set program, it only instantiates the objects that are directly related to the operation in the backbone task plan, generates a loop-tolerant shrinking constant, and generates a second answer set program based on the loop-tolerant shrinking constant.

[0171] The task planning module 730 is used to generate a task plan that can be executed by the robot based on the second answer set program.

[0172] One embodiment of this disclosure provides a robot task planning device. For example... Figure 8 As shown, the robot task planning device 800 includes a memory 820 and a processor 810. The memory 820 is used to store computer programs; the processor 810 is used to implement... Figure 4 The method described in S410-S430.

[0173] In summary, the robot task planning method, apparatus, and device provided in the embodiments of this disclosure first utilize LLM to generate a backbone task plan to accelerate the answer set programming process. Using the backbone task plan as input to the ASP reduces the search space, thereby accelerating the solution process. Then, based on the loop-tolerant reduction technique, it identifies constant quantum sets in the ASP program that do not affect the solution set. Since the large computational load of ASP solutions is mainly due to the excessively large definition of variable fields, identifying those constant quantum sets that can be omitted without affecting the overall solution set of the program can significantly reduce the computational burden during ASP program instantiation. Thus, while ensuring computational integrity, it significantly accelerates the generation of executable plans.

[0174] Those skilled in the art will clearly understand that, for the sake of convenience and brevity, the specific working process of the devices and modules described above can be referred to the corresponding descriptions in the foregoing device embodiments, and will not be repeated here.

[0175] Although the subject matter described herein is provided in the general context of execution on a computer system in conjunction with an operating system and applications, those skilled in the art will recognize that other implementations can also be executed in conjunction with other types of program modules. Generally, program modules include routines, programs, components, data structures, and other types of structures that perform specific tasks or implement specific abstract data types. Those skilled in the art will understand that the subject matter described herein can be practiced using other computer system configurations, including handheld devices, multiprocessor systems, microprocessor-based or programmable consumer electronics, minicomputers, mainframes, etc., and can also be used in distributed computing environments where tasks are performed by remote processing devices connected via a communication network. In a distributed computing environment, program modules may reside on both local and remote memory storage devices.

[0176] Those skilled in the art will recognize that the units and method steps of the various examples described in conjunction with the embodiments disclosed herein can be implemented in electronic hardware, or a combination of computer software and electronic hardware. Whether these functions are implemented in hardware or software depends on the specific application and design constraints of the technical solution. Those skilled in the art can use different methods to implement the described functions for each specific application, but such implementation should not be considered beyond the scope of this disclosure.

[0177] It should be understood that the specific embodiments described above are merely illustrative or explanatory of the principles of this disclosure and do not constitute a limitation thereof. Therefore, any modifications, equivalent substitutions, improvements, etc., made without departing from the spirit and scope of this disclosure should be included within the protection scope of this disclosure. Furthermore, the appended claims are intended to cover all variations and modifications falling within the scope and boundaries of the appended claims, or equivalent forms of such scope and boundaries.

Claims

1. A robot task planning method, characterized in that, include: Using a large language model, an abstract task description is used to generate a backbone task plan for the target scenario based on constraints. The backbone task plan is the preliminary steps for executing the task corresponding to the abstract task description. The preliminary steps include a series of combinations formed by operations, objects of the operations, and relationships between the objects. The constraints include scenario constraints and operation constraints. The response set is encoded based on the backbone task plan. When instantiating the generated first response set program, only the objects directly related to the operation in the backbone task plan are instantiated. A loop-tolerant shrinking constant is generated, and a second response set program is generated based on the loop-tolerant shrinking constant. Based on the second set of answers, the program generates a task plan that the robot can execute.

2. The method according to claim 1, characterized in that, The process of using a large language model to describe abstract tasks and generate a backbone task plan for the target scenario based on constraints includes: Using a large language model to describe abstract tasks, an initial plan for the target scenario is generated based on constraints. The initial plan is then subjected to a rule-based syntax checker to perform syntax checks and correct syntax errors. Based on semantic similarity analysis, the accuracy of the operations and objects in the initial plan is ensured, and the backbone task plan is generated.

3. The method according to claim 1, characterized in that, The encoding of the response set based on the backbone task plan includes: The coding rules for the answer set are determined based on the aforementioned operational constraints; The operations, objects of the operations, and relationships between the objects in the backbone task plan are converted into answer set codes.

4. The method according to claim 3, characterized in that, The step of instantiating only the objects directly related to the operations in the backbone task plan and generating a loop-tolerant shrinkable constant includes: Extract a second set of constants directly related to the operation from the backbone task plan; Verify whether the second set of constants is the cyclically reducible constant. If the second set of constants is not the cyclically reducible constant, repeat the above steps.

5. The method according to claim 4, characterized in that, After the generation loop can be reduced to a constant, it also includes: Based on computational integrity, the loop-compatible shrinkable constant is expanded to generate a third set of constants; The program generates the second answer set based on the third set of constants.

6. The method according to claim 5, characterized in that, The expansion of the loop-tolerant shrinkable constant based on computational integrity includes: Identify the loop rules in the task; Based on the aforementioned loop rules, the loop can be expanded to accommodate shrinking constants.

7. The method according to claim 4, characterized in that, The step of extracting the second set of constants directly related to the operation from the backbone task plan includes: The objects of the operations in the backbone task plan constitute the first set of constants; For each operation in the backbone task plan, determine the scope of influence of the operation, delete constants that do not belong to the scope of influence in the first set of constants, generate a second set of constants, and use the second set of constants as the loop-tolerant shrinkable constants.

8. The method according to claim 4, characterized in that, The step of verifying whether the second set of constants is the cyclically scalable constant includes: If the third answer set of the third answer set program generated based on the second constant set has a corresponding first answer set in the first answer set program and satisfies that the third answer set is a subset of the first answer set; Each first answer set in the first answer set program has a corresponding third answer set in the third answer set program, and the third answer set is a subset of the first answer set. Then it is confirmed that the second set of constants is the cycle-compatible shrinkable constant; Otherwise, the second set of constants is not the loop-compatible shrinkable constant.

9. A robot task planning device, characterized in that, include: The backbone task plan generation module is used to generate a backbone task plan for a target scenario based on constraints by using a large language model to analyze an abstract task description. The backbone task plan is a preliminary step for executing the task corresponding to the abstract task description. The preliminary step includes a series of combinations formed by operations, objects of the operations, and relationships between the objects. The constraints include scenario constraints and operation constraints. The answer set encoding module is used to encode the answer set based on the backbone task plan. When instantiating the generated first answer set program, it only instantiates the objects that are directly related to the operation in the backbone task plan, generates a loop-compatible shrinking constant, and generates a second answer set program based on the loop-compatible shrinking constant. The task planning module is used to generate a task plan that the robot can execute based on the second answer set program.

10. A robot task planning device, characterized in that, Including memory and processor: The memory is used to store computer programs; The processor is configured to, when executing the computer program, implement the method according to any one of claims 1-8.

Images