Human activity program closed-loop generation method and system

Abstract

Disclosed in the present invention are a human activity program closed-loop generation method and system. The method comprises: inputting initial scene information and an activity description, and generating an initial activity program by means of a task planning model; checking a verification code of actions corresponding to the activity program, and if it is determined that the current action is executable, sending same to a simulator for execution, and if it is determined that the current action is non-executable, using the verification code to modify the activity program; checking an execution state of the activity program, and if the corresponding actions can be successfully executed in a simulation environment, acquiring a post-execution state returned by the simulation environment, and if the corresponding actions fail to be executed, on the basis of error information returned by the simulation environment, using a program correction model to modify the activity program again; and outputting the final modified activity program. The present invention provides a method of automatically generating an activity program in a closed-loop manner on the basis of an activity description input by a user, and the activity program can be dynamically corrected during execution, thereby greatly improving the executability of the activity program.

Description

A method and system for generating closed-loop human activity programs Technical Field

[0001] This invention relates to the field of computer graphics technology, and in particular to a method and system for generating closed-loop human activity programs. Background Technology

[0002] With the rise and development of concepts like virtual universes and embodied intelligence, there is an urgent desire to construct a virtual digital world that closely resembles the real world. As a reflection of humanity in the digital world, digital humans play a crucial role in interacting with the virtual environment. To achieve different interactive tasks, corresponding activity programs need to be designed for digital humans. Currently, many game companies design various activity programs for different virtual characters to make games more realistic and natural, thereby enhancing user immersion. However, designing these digital human activities requires designers to have extensive design experience and professional expertise, resulting in significant economic and time costs. Therefore, how to reduce the cost of generating human activity programs and automatically generate them in a user-friendly manner has become an important issue.

[0003] Recent work has used trained models or large language models to generate human activity programs in an open-loop manner; however, the executability of these programs is not high. Furthermore, because of the open-loop nature, if an instruction in the program fails to execute, the activity ends, and there is no way to perform subsequent error correction.

[0004] Existing systems for generating activity programs using closed-loop mechanisms mainly fall into three categories: the first is tasks related to human activity program generation; the second is tasks related to completing tasks using a closed-loop approach; and the third is tasks related to using code as memory. Past work on human activity program generation tasks primarily fell into two categories: the first used trained models to generate activity programs, learning a large number of activity instruction-activity program pairs; the second used pre-trained large language models, relying on cue engineering to directly generate activity programs. This second method combined the advantages of trained and large language models by fine-tuning the large language model. However, these methods are all open-loop models; once the program is generated, it cannot be modified. During execution, if any action fails, the entire task fails.

[0005] Therefore, existing technologies still need improvement. Summary of the Invention

[0006] The technical problem to be solved by the present invention is that, in view of the defects of the prior art, the present invention provides a closed-loop human activity program generation method and system to solve the problem that the existing methods for generating activity programs in a closed loop cannot achieve automatic error correction.

[0007] The technical solution adopted by this invention to solve the technical problem is as follows:

[0008] In a first aspect, the present invention provides a method for generating a closed-loop human activity program, comprising:

[0009] Input the initial scene information and activity description, and generate the initial activity program through the task planning model;

[0010] The verification code corresponding to the action in the activity program is checked. If the current action is determined to be executable, it is sent to the simulator for execution. If the current action is determined to be unexecutable, the activity program is modified using the verification code. The verification code is the code summarized based on the error correction experience of the corresponding action during the model training process.

[0011] Check the execution status of the activity program. If the corresponding action can be executed successfully in the simulation environment, obtain the execution status returned by the simulation environment. If the corresponding action fails to execute, modify the activity program again using the program correction model based on the error information returned by the simulation environment.

[0012] Output the final modified program.

[0013] In one implementation, the step of checking the verification code corresponding to the action of the activity program, if it is determined that the current action is executable, then it is sent to the simulator for execution; if it is determined that the current action is not executable, then the activity program is modified using the verification code, including:

[0014] Retrieve the verification code corresponding to the action of the activity program from the procedural memory;

[0015] Based on the found verification code, it is determined whether the current action is executable. If the current action is determined to be unexecutable, a code update plan is generated and the activity program is modified using the verification code. If the current action is determined to be executable, it is sent to the simulator for execution.

[0016] In one implementation, the step of checking the execution status of the activity program, if the corresponding action can be successfully executed in the simulation environment, then obtaining the post-execution status returned by the simulation environment; if the corresponding action fails to execute, then modifying the activity program again using a program correction model based on the error information returned by the simulation environment, including:

[0017] Check the execution status of the activity program to determine whether the corresponding action of the activity program can be successfully executed in the simulation environment;

[0018] If the execution is successful in the simulation environment, the state change information of the simulation environment is obtained;

[0019] If execution fails in the simulation environment, the error information of the active program in the simulation environment is obtained, and the active program is modified again using the program correction model based on the error information.

[0020] In one implementation, modifying the active program again using the program correction model based on the error information includes:

[0021] Within the set maximum number of post-execution error corrections, based on the error information of the active program executed in the simulation environment, the program correction model is used to generate a correction scheme, and the active program is corrected according to the correction scheme to obtain an updated active program. After the update, the corresponding action instructions are executed from the position of the error.

[0022] Determine whether the corrected action was executed successfully;

[0023] If the execution is successful, the next instruction in the active procedure will continue to be executed until all instructions in the active procedure have been executed, or the maximum number of error correction attempts has been reached.

[0024] In one implementation, the method further includes:

[0025] After each training session, the action verification code corresponding to the action instruction that malfunctioned in the simulation environment is obtained, resulting in the old, defective action verification code.

[0026] Extract experience information from successful error correction during training from historical error correction data;

[0027] Based on the old, defective action verification code and the experience information from successful error correction, a new, optimized action verification code is output using an experience summary model.

[0028] In one implementation, obtaining the experience information on successful error correction during the reasoning process from the error correction history information includes:

[0029] Obtain execution information from the point of error execution to the point of successful re-execution or skipping of the action instruction, and obtain the experience information of successful error correction.

[0030] Secondly, the present invention provides a closed-loop human activity program generation system, comprising:

[0031] The task planning module is used to input initial scene information and activity descriptions, and generate initial activity programs through the task planning model;

[0032] The pre-execution error correction module is used to check the verification code of the corresponding action of the activity program. If it is determined that the current action can be executed, it is sent to the simulator for execution. If it is determined that the current action cannot be executed, the verification code is used to modify the activity program. The verification code is the code summarized based on the error correction experience of the corresponding action during the model training process.

[0033] The post-execution error correction module is used to check the execution status of the activity program. If the corresponding action can be successfully executed in the simulation environment, the post-execution status returned by the simulation environment is obtained. If the corresponding action fails to execute, the activity program is modified again using the program correction model based on the error information returned by the simulation environment.

[0034] The error correction experience summary module is used to summarize the experience of the corresponding action from execution error to successful re-execution during the training process, and generate the check code for the corresponding action for pre-execution error correction during the inference process.

[0035] Thirdly, the present invention provides a terminal, comprising: a processor and a memory, wherein the memory stores a closed-loop human activity program generation program, and the closed-loop human activity program generation program, when executed by the processor, is used to implement the operation of the closed-loop human activity program generation method as described in the first aspect.

[0036] Fourthly, the present invention also provides a medium, which is a computer-readable storage medium, storing a closed-loop human activity program generation program, which, when executed by a processor, is used to implement the operation of the closed-loop human activity program generation method as described in the first aspect.

[0037] The present invention, by employing the above technical solution, has the following effects:

[0038] This invention generates an initial activity program through a task planning model and checks the verification code of the corresponding actions in the activity program. If the current action is executable, it is sent to the simulator for execution; if the current action is not executable, the verification code is used to modify the activity program. Furthermore, when the corresponding action is executed successfully, the execution status returned by the simulation environment is obtained; if the corresponding action fails, based on the error information returned by the simulation environment, the activity program is modified again using a program correction model, and the final modified activity program is output. This invention provides a method for automatically generating activity programs in a closed-loop manner based on user-input activity descriptions, which can dynamically correct the activity program during execution, significantly improving the executability of the activity program. Attached Figure Description

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

[0040] Figure 1 is a flowchart of the closed-loop human activity program generation method in this invention.

[0041] Figure 2 is a schematic diagram of the closed-loop human activity program generation in this invention.

[0042] Figure 3 is a schematic diagram of the reasoning process in this invention.

[0043] Figure 4 is a schematic diagram of the learning process in this invention.

[0044] Figure 5 is a schematic diagram of the test results in this invention.

[0045] Figure 6 is a functional schematic diagram of the terminal in one implementation of the present invention.

[0046] The objectives, features, and advantages of this invention will be further explained in conjunction with the embodiments and with reference to the accompanying drawings. Detailed Implementation

[0047] To make the objectives, technical solutions, and advantages of this invention clearer and more explicit, the invention will be further described in detail below with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are merely illustrative of the invention and are not intended to limit the invention.

[0048] Exemplary methods

[0049] Existing systems for generating activity programs using closed-loop methods mainly fall into three categories: the first is the task of generating human activity programs; the second is related to completing tasks using a closed-loop approach; and the third is related to using code as memory. Past work on human activity program generation tasks primarily fell into two categories: the first used trained models to generate activity programs, learning a large number of activity instruction-activity program pairs; the second used pre-trained large language models, relying on cue engineering to directly generate activity programs. This second method combined the advantages of trained and large language models by fine-tuning the large language model. Therefore, existing human activity program generation methods all use an open-loop approach to generate activity programs. This means that once an instruction in the program malfunctions, the activity ends, lacking self-correction capabilities.

[0050] To address the above technical problems, this invention provides a closed-loop human activity program generation method. This method generates an initial activity program using a task planning model and checks the verification code of the corresponding actions within the activity program. If the current action is executable, it is sent to the simulator for execution; if the current action is not executable, the verification code is used to modify the activity program. Furthermore, when the corresponding action is successfully executed, the post-execution status returned by the simulation environment is obtained; if the corresponding action fails to execute, based on the error information returned by the simulation environment, the activity program is modified again using a program correction model, and the final modified activity program is output. This invention provides a method for automatically generating activity programs in a closed-loop manner based on user-input activity descriptions, which can dynamically correct the activity program during execution, significantly improving the executability of the activity program.

[0051] As shown in Figure 1, this embodiment of the invention provides a method for generating a closed-loop human activity program, comprising the following steps:

[0052] Step S100: Input the initial scene information and activity description, and generate the initial activity program through the task planning model.

[0053] This embodiment addresses the problem of generating human activity programs. The objective of this embodiment is to enable digital humans (i.e., virtual humans) to generate reasonable and executable activity programs based on high-level descriptions provided by humans (e.g., the activity description of "surfing the internet") and the states of objects and characters in a scene. These activity programs can consist of a series of action instructions, which include actions and the objects being manipulated, for example, [WALK]. <chair>(Walking-Chair), [SIT] <chair>(Sit down - on a chair), [SWITCHON] <computer>(Open - Computer) and other action commands.

[0054] Based on the above task description, the method provided in this embodiment builds a system for inputting activity instructions to generate activity programs in a closed loop, and summarizes the experience of successful error correction in the form of code, thus realizing the function of automatically generating activity programs in a closed loop.

[0055] The system in this embodiment provides a closed-loop framework based on a trained model combined with a large language model to solve the problem of generating human activity programs. This framework utilizes the trained model to output a high-performance initial result, and then leverages the contextual capabilities of the large language model to correct errors in execution. From generating an initial activity program from an input activity description to executing the instructions in the activity program line by line and self-correcting, the system in this embodiment designs a complete solution process. Therefore, the method in this embodiment, which uses a large language model to automatically correct errors in the activity program based on scenario execution feedback information, can summarize the error correction experience into general, action-level code and store it for self-correction before execution.

[0056] In this embodiment, the human activity program generation task requires input of an initial scene S0 and an activity description D, and then outputs an activity program P = {I}. i |i∈N}. Wherein, an active program contains N instructions, each instruction I i =[A i O i1 O i2 ,K i ], including action A i Object O, and the flag K that determines whether to skip the instruction. i If K i If K is 0, it means the instruction will be executed; if K is 0, it means the instruction will be executed. i If the value is 1, it means that the instruction will be skipped.

[0057] This embodiment uses three models: a task planning model, a program correction model, and an experience summary model.

[0058] As an example, this embodiment uses a pre-trained Scene-Aware APG (Scene-Aware Model) as the task planning model, responsible for generating initial activity procedures based on the initial scene and activity description. It also uses GPT3.5turbo as the procedure correction model, responsible for taking error feedback and historical execution information as input, and outputting a corrective action plan. Finally, it uses GPT4o as an experience summarization model, responsible for taking error correction history information and old, flawed action verification code as input, and outputting a new, optimized action verification code.

[0059] Figure 2 illustrates the overall process of generating a closed-loop human activity program. First, in the initial stage of the task, scene information S0 and activity description D are input, and an initial activity program P = Planner(S0,D) is generated using a task planning model. Subsequently, the instructions in the program are executed sequentially, one by one. During this execution, the contextual capabilities of the large language model are used to correct errors, thus realizing the process from generating an initial activity program from the input activity description to executing the instructions in the activity program one by one and self-correcting errors.

[0060] As shown in Figure 1, this embodiment of the invention provides a method for generating a closed-loop human activity program, comprising the following steps:

[0061] Step S200: Check the verification code of the action corresponding to the activity program. If it is determined that the current action is executable, it is sent to the simulator for execution. If it is determined that the current action is not executable, the activity program is modified using the verification code. The verification code is the code summarized based on the error correction experience of the corresponding action during the model training process.

[0062] In this embodiment, after the initial activity program is generated through the task planning model, in order to ensure that the activity program can run in the preset virtual environment, it is necessary to perform pre-execution error correction. That is, the error correction code is used to check whether the instruction will be executed successfully. If the execution fails, the error correction will be performed in advance to avoid the occurrence of errors.

[0063] Specifically, in one implementation of this embodiment, step S200 includes the following steps:

[0064] Step S201: Search the verification code of the action corresponding to the activity program from the procedural memory;

[0065] Step S202: Based on the found verification code, determine whether the current action is executable. If the current action is determined to be unexecutable, generate a code update plan and use the verification code to modify the activity program. If the current action is determined to be executable, send it to the simulator for execution.

[0066] In this embodiment, as shown in Figure 3, a detailed example of the reasoning process of the method in this embodiment is illustrated, which includes three key stages: initialization, pre-execution error correction, and post-execution error correction.

[0067] In the initial phase of the task, an initial activity program P = Planner(S0, D) is first generated using a task planning model. Subsequently, the instructions in the program are executed sequentially, one by one. Before each instruction is executed, pre-execution error correction is performed, that is, based on the action A in the instruction... i The corresponding verification code is retrieved from the program memory to determine whether error correction is needed. If error correction is needed, the active program is updated according to the error correction logic of the verification code, i.e., the current action instruction is skipped; if error correction is not needed, it is directly sent to the simulation environment for execution.

[0068] As an example, the pre-execution error correction process in this embodiment is as follows:

[0069] If the validation code determines that the instruction will result in an error, it will first generate a code update scheme ΔP. i =V(S) i ,I i After updating the activity program using this update scheme, it is then sent to the simulation environment for execution. As shown in the example in Figure 2, the action instruction of the activity program is to turn on the light. The digital human intends to turn on the light, but the verification code detects that the light is already on. Therefore, it performs pre-execution error correction processing on the instruction to turn on the light, that is, it marks the instruction to be skipped. Subsequent execution will then skip this instruction and continue.

[0070] In this embodiment, during the pre-execution error correction process, if the verification code does not find any errors in the instructions, the initial activity program is directly placed into the simulation environment for execution; wherein, the simulation environment is a virtual environment simulated based on the initial scene information, such as an indoor scene (bedroom scene, living room scene), an outdoor scene, or other work activity scene.

[0071] In this embodiment, during the execution of the active program in the simulation environment, if the execution is successful in the simulation environment, the state change information of the simulation environment is obtained. If the instruction is executed incorrectly in the simulation environment, the simulation environment will provide an error feedback message F so that the active program can be modified again later.

[0072] As shown in Figure 1, this embodiment of the invention provides a method for generating a closed-loop human activity program, comprising the following steps:

[0073] Step S300: Check the execution status of the activity program. If the corresponding action can be successfully executed in the simulation environment, obtain the execution status returned by the simulation environment. If the corresponding action fails to execute, modify the activity program again using the program correction model according to the error information returned by the simulation environment.

[0074] Step S400: Output the final modified activity program.

[0075] Since the method provided in this embodiment generates the active program in a closed-loop manner, during the execution of the active program, if it executes successfully in the simulation environment, the state change information of the simulation environment is obtained; if an instruction fails to execute, the active program is updated using the large language model (i.e., the GPT3.5turbo program correction model) to correct the error. Furthermore, this embodiment provides a code-based memory model; once error correction is successful, the error correction logic is recorded so that the active program can be further optimized based on the recorded error correction information.

[0076] Specifically, in one implementation of this embodiment, step S300 includes the following steps:

[0077] Step S301: Check the execution status of the activity program and determine whether the action corresponding to the activity program can be successfully executed in the simulation environment;

[0078] Step S302: If the execution is successful in the simulation environment, obtain the state change information of the simulation environment;

[0079] Step S303: If the execution fails in the simulation environment, obtain the error information of the active program in the simulation environment, and modify the active program again using the program correction model based on the error information.

[0080] Specifically, in one implementation of this embodiment, step S303, which involves modifying the active program again using the program correction model based on the error information, includes:

[0081] Step S303a: Within the set maximum number of error corrections after execution, based on the error information of the active program executed in the simulation environment, a correction scheme is generated using the program correction model, and the active program is corrected according to the correction scheme to obtain an updated active program. After the update, the corresponding action instruction continues to be executed from the position of the error.

[0082] Step S303b: Determine whether the corrected action was successfully executed;

[0083] Step S303c: If the execution is successful, continue to execute the next instruction in the active program until all instructions in the active program have been executed, or the maximum number of error corrections has been reached after execution.

[0084] In this embodiment, in the simulation environment, if the execution of an activity instruction fails, a large language model is used as a corrector based on the error information to output a correction scheme for the executed activity program. This correction scheme is then used to update the activity program to correct the error. If the execution is successful, the next instruction in the program is executed. The activity ends when all instructions in the activity program have been executed, or when the maximum number of error corrections has been reached.

[0085] In this embodiment, the execution error is mainly caused by a mismatch between the action and the scene state. For example, if the character is already standing, executing [STANDUP] will result in an error; or, for example, if an apple is inside a closed container, executing [GRAB] will cause an error. <apple>The command "(Grab - Apple)" will result in an error. In this embodiment, the error correction method is to skip the current redundant command (for example, if the character is already standing, the command to stand should be skipped), or to insert some extra commands before the erroneous command so that the originally erroneous command can be executed successfully (for example, inserting a command to open the container before the command to grab an object in a closed container).

[0086] As an example, the post-execution error correction process in this embodiment is as follows:

[0087] If the verification code does not find any errors in the instructions, it is directly placed into the simulation environment for execution. During the execution of the active program, this embodiment will use a program correction model, inputting historical execution information and outputting a modification plan ΔP for the active program. i =Corrector(S0,D,[I0,F0],...[I i ,F i The modified program was then used to update the activity, and execution resumed from the point of error. As shown in Figure 3, in the example, the digital human attempted to grab a toy from a drawer, but the drawer was closed, causing an error. The program correction model then inserted an instruction to open the drawer, allowing subsequent execution to continue successfully.

[0088] In one implementation of this embodiment, the present invention provides a closed-loop human activity program generation method, which further includes the following steps:

[0089] Step S501: After each training session, obtain the action verification code corresponding to the action instruction that malfunctioned in the simulation environment, and obtain the old defective action verification code.

[0090] Step S502: Obtain experience information on successful error correction during training from the error correction history information;

[0091] Specifically, in one implementation of this embodiment, obtaining the experience information of successful error correction during the reasoning process from the error correction history information includes: obtaining the execution information of the action instruction from the time of execution error to the time of successful re-execution or skipping, and obtaining the experience information of successful error correction.

[0092] Step S503: Based on the old defective action verification code and the experience information of successful error correction, a new optimized action verification code is output using the experience summary model.

[0093] In this embodiment, as shown in Figure 4, an example of the learning process of the method provided in this embodiment is illustrated.

[0094] After each training session, if an instruction fails to execute in the simulation environment, it indicates that the corresponding action verification code is flawed and the error has not been detected and corrected. Initially, for each action, successful error correction experience during training is collected (error correction experience refers to the process from an action execution error to the action being successfully re-executed / skipped). This experience is used to summarize the model and optimize the action verification code V. new =Summarizer(S j ,D,[I j ,F j ],...[I i ,F i ],V old In this way, the method provided in this embodiment has the ability to learn autonomously, and can continuously optimize the verification code to update the program before errors occur, thereby avoiding errors and greatly improving execution efficiency.

[0095] As shown in Figure 3, the example illustrates that the code validating the grabbing action failed because it lacked logic to verify whether the object to be grabbed was placed inside a closed container. After the failure, the program corrected the model's reasoning by inserting an instruction to open the container, and the grabbing instruction was successfully executed again. As shown in Figure 4, this error-correction experience was input into the experience summary model, optimizing the action validation code to include the logic to verify whether the object is placed inside a closed container and to provide corresponding error-correction methods.

[0096] The experiment in this embodiment is divided into a training phase and a testing phase. The training phase allows learning after inference, while the testing phase does not. In the training phase, 100 samples were randomly selected from the training set, and inference and learning were performed on these 100 samples.

[0097] The method in this embodiment was tested on a virtual home simulation environment. The main evaluation indicators of the task are the rationality and executability of the activity procedure. Rationality refers to the semantic relevance between the activity procedure and the activity description, while executability indicates whether the activity procedure can be successfully executed in the target scene instance.

[0098] In this embodiment, 100 samples were randomly selected from the original training set for learning, and then tested on the complete test set of 2415 samples. As shown in Figure 5, the test results demonstrate that, based on the current best method Scene awareAPG, adding the method in this embodiment can improve the executability from 0.767 to 0.993 and the completion rate from 0.573 to 0.756, showing a significant improvement in error correction capability.

[0099] It is worth mentioning that the task planning module in this embodiment can be implemented with different networks. This embodiment uses Scene awareAPG as the network. In other implementations, it can be replaced with other networks, such as RAG or GPT4. The program correction module and the experience summary module can also be replaced with other large language models, such as GPT3, GPT4, and other versions. These alternative schemes based on this embodiment should all fall within the protection scope of this embodiment.

[0100] This embodiment achieves the following technical effects through the above technical solution:

[0101] This embodiment generates an initial activity program through a task planning model and checks the verification code of the corresponding actions in the activity program. If the current action is executable, it is sent to the simulator for execution; if the current action is not executable, the verification code is used to modify the activity program. When the corresponding action is executed successfully, the execution status returned by the simulation environment is obtained; if the corresponding action fails to execute, the activity program is modified again using a program correction model based on the error information returned by the simulation environment, and the final modified activity program is output. This embodiment provides a method for automatically generating activity programs in a closed-loop manner based on user-input activity descriptions, which can dynamically correct the activity program during execution, greatly improving the executability of the activity program.

[0102] Exemplary device

[0103] The task planning module is used to input initial scene information and activity descriptions, and generate initial activity programs through the task planning model;

[0104] The pre-execution error correction module is used to check the verification code of the corresponding action of the activity program. If it is determined that the current action can be executed, it is sent to the simulator for execution. If it is determined that the current action cannot be executed, the verification code is used to modify the activity program. The verification code is the code summarized based on the error correction experience of the corresponding action during the model training process.

[0105] The post-execution error correction module is used to check the execution status of the activity program. If the corresponding action can be successfully executed in the simulation environment, the post-execution status returned by the simulation environment is obtained. If the corresponding action fails to execute, the activity program is modified again using the program correction model based on the error information returned by the simulation environment.

[0106] The error correction experience summary module is used to summarize the experience of the corresponding action from execution error to successful re-execution during the training process, and generate the check code for the corresponding action for pre-execution error correction during the inference process.

[0107] This embodiment achieves the following technical effects through the above technical solution:

[0108] This embodiment generates an initial activity program through a task planning model and checks the verification code of the corresponding actions in the activity program. If the current action is executable, it is sent to the simulator for execution; if the current action is not executable, the verification code is used to modify the activity program. When the corresponding action is executed successfully, the execution status returned by the simulation environment is obtained; if the corresponding action fails to execute, the activity program is modified again using a program correction model based on the error information returned by the simulation environment, and the final modified activity program is output. This embodiment provides a method for automatically generating activity programs in a closed-loop manner based on user-input activity descriptions, which can dynamically correct the activity program during execution, greatly improving the executability of the activity program.

[0109] Based on the above embodiments, the present invention also provides a terminal, the principle block diagram of which can be shown in Figure 6.

[0110] The terminal includes: a processor, a memory, an interface, a display screen, and a communication module connected via a system bus; wherein, the processor of the terminal provides computing and control capabilities; the memory of the terminal includes a storage medium and internal memory; the storage medium stores the operating system and computer programs; the internal memory provides an environment for the operation of the operating system and computer programs in the storage medium; the interface is used to connect to external devices; the display screen is used to display relevant information; and the communication module is used to communicate with a cloud server or other devices.

[0111] When executed by the processor, this computer program is used to implement the closed-loop human activity program generation method.

[0112] Those skilled in the art will understand that the principle block diagram shown in Figure 6 is merely a block diagram of a portion of the structure related to the present invention and does not constitute a limitation on the terminal to which the present invention is applied. A specific terminal may include more or fewer components than those shown in the figure, or may combine certain components, or may have different component arrangements.

[0113] In one embodiment, a terminal is provided, comprising: a processor and a memory, the memory storing a closed-loop human activity program generation program, which, when executed by the processor, is used to implement the operation of the closed-loop human activity program generation method described above.

[0114] In one embodiment, a storage medium is provided, wherein the storage medium stores a closed-loop human activity program generation program, which, when executed by a processor, is used to implement the operation of the closed-loop human activity program generation method described above.

[0115] Those skilled in the art will understand that all or part of the processes in the methods of the above embodiments can be implemented by a computer program instructing related hardware. The computer program can be stored in a non-volatile storage medium, and when executed, it can include the processes of the embodiments of the methods described above. Any references to memory, storage, database, or other media used in the embodiments provided by this invention can include both non-volatile and volatile memory.

[0116] In summary, this invention provides a closed-loop human activity program generation method and system, comprising: inputting initial scene information and activity description; generating an initial activity program through a task planning model; checking the verification code of the corresponding action in the activity program; if the current action is determined to be executable, it is sent to a simulator for execution; if the current action is determined to be inexecutable, the activity program is modified using the verification code; checking the execution status of the activity program; if the corresponding action can be successfully executed in the simulation environment, the post-execution status returned by the simulation environment is obtained; if the corresponding action fails to execute, the activity program is modified again using a program correction model based on the error information returned by the simulation environment; and outputting the final modified activity program. This invention provides a method for automatically generating activity programs in a closed-loop manner based on user-input activity descriptions, which can dynamically correct the activity program during execution, significantly improving the executability of the activity program.

[0117] It should be understood that the application of the present invention is not limited to the examples above. Those skilled in the art can make improvements or modifications based on the above description, and all such improvements and modifications should fall within the protection scope of the appended claims.< / apple> < / computer> < / chair> < / chair>

Claims

1. A closed loop human activity program generation method, characterized by, include: Input the initial scene information and activity description, and generate the initial activity program through the task planning model; The verification code corresponding to the action in the activity program is checked. If the current action is determined to be executable, it is sent to the simulator for execution. If the current action is determined to be unexecutable, the activity program is modified using the verification code. The verification code is the code summarized based on the error correction experience of the corresponding action during the model training process. Check the execution status of the activity program. If the corresponding action can be executed successfully in the simulation environment, obtain the execution status returned by the simulation environment. If the corresponding action fails to execute, modify the activity program again using the program correction model based on the error information returned by the simulation environment. Output the final modified program.

2. The closed loop human movement program generation method of claim 1, wherein, The verification code for the corresponding action of the activity program is checked. If the current action is determined to be executable, it is sent to the simulator for execution. If the current action is determined to be unexecutable, the verification code is used to modify the activity program, including: Retrieve the verification code corresponding to the action of the activity program from the procedural memory; Based on the found verification code, it is determined whether the current action is executable. If the current action is determined to be unexecutable, a code update plan is generated and the activity program is modified using the verification code. If the current action is determined to be executable, it is sent to the simulator for execution.

3. The closed loop human movement program generation method of claim 1, wherein, The process involves checking the execution status of the activity program. If the corresponding action can be successfully executed in the simulation environment, the post-execution status returned by the simulation environment is obtained. If the corresponding action fails to execute, the activity program is modified again using a program correction model based on the error information returned by the simulation environment. This includes: Check the execution status of the activity program to determine whether the corresponding action of the activity program can be successfully executed in the simulation environment; If the execution is successful in the simulation environment, the state change information of the simulation environment is obtained; If execution fails in the simulation environment, the error information of the active program in the simulation environment is obtained, and the active program is modified again using the program correction model based on the error information.

4. The closed loop human movement program generation method of claim 3, wherein, The step of modifying the active program again using the program correction model based on the error information includes: Within the set maximum number of post-execution error corrections, based on the error information of the active program executed in the simulation environment, the program correction model is used to generate a correction scheme, and the active program is corrected according to the correction scheme to obtain an updated active program. After the update, the corresponding action instructions are executed from the position of the error. Determine whether the corrected action was executed successfully; If the execution is successful, the next instruction in the active procedure will continue to be executed until all instructions in the active procedure have been executed, or the maximum number of error correction attempts has been reached.

5. The closed loop human movement program generation method of claim 1, wherein, The method further includes: After each training session, the action verification code corresponding to the action instruction that malfunctioned in the simulation environment is obtained, resulting in the old, defective action verification code. Extract experience information from successful error correction during training from historical error correction data; Based on the old, defective action verification code and the experience information from successful error correction, a new, optimized action verification code is output using an experience summary model.

6. The closed loop human movement program generation method of claim 5, wherein, The step of obtaining experience information on successful error correction during the reasoning process from the error correction history information includes: Obtain execution information from the point of error execution to the point of successful re-execution or skipping of the action instruction, and obtain the experience information of successful error correction.

7. A closed loop human movement program generation system characterized by, include: The task planning module is used to input initial scene information and activity descriptions, and generate initial activity programs through the task planning model; The pre-execution error correction module is used to check the verification code of the corresponding action of the activity program. If it is determined that the current action can be executed, it is sent to the simulator for execution. If it is determined that the current action cannot be executed, the verification code is used to modify the activity program. The verification code is the code summarized based on the error correction experience of the corresponding action during the model training process. The post-execution error correction module is used to check the execution status of the activity program. If the corresponding action can be executed successfully in the simulation environment, the post-execution status returned by the simulation environment is obtained. If the corresponding action fails to execute, the activity program is modified again using the program correction model according to the error information returned by the simulation environment. The error correction experience summary module is used to summarize the experience of the corresponding action from execution error to successful re-execution during the training process, and generate the check code for the corresponding action for pre-execution error correction during the inference process.

8. A terminal, characterized by comprising: include: The processor and memory, wherein the memory stores a closed-loop human activity program generation program, which, when executed by the processor, is used to implement the operation of the closed-loop human activity program generation method as described in any one of claims 1-6.

9. A computer-readable storage medium, characterized in that, The computer-readable storage medium stores a closed-loop human activity program generation program, which, when executed by a processor, is used to implement the operation of the closed-loop human activity program generation method as described in any one of claims 1-6.

Images