CN116468131B

CN116468131B - Automatic AI (advanced technology attachment) driven project method and system based on staged retraining

Info

Publication number: CN116468131B
Application number: CN202310726403.3A
Authority: CN
Inventors: 肖华熙; 陈瑞琪; 钱云潇; 孙江昊
Original assignee: Chengdu Singularity Software Co ltd
Current assignee: Chengdu Singularity Software Co ltd
Priority date: 2023-06-19
Filing date: 2023-06-19
Publication date: 2023-09-01
Anticipated expiration: 2043-06-19
Also published as: CN116468131A

Abstract

The invention discloses an AI driving project automation method and system based on staged retraining, and relates to the technical field of intelligent informatization. The method comprises the following steps: performing a target task in the project implementation using the artificial intelligence model; training the artificial intelligent model in stages to internalize the knowledge structure related to the project; generating a training set required by periodic retraining according to information generated in the project implementation process by using an artificial intelligent model; auditing the execution result of the target task by using the artificial intelligent model, and re-executing the task when the evaluation standard is not met; project integration is carried out by using an artificial intelligent model; an artificial intelligence model which has internalized the knowledge structure of the related project in the past is selected for the new project to realize the multiplexing of the model. The invention provides a scheme for fundamentally solving the problem of context length limitation of the artificial intelligent model, and provides an effective way for the automatic implementation of large and medium-sized projects.

Description

Automatic AI (advanced technology attachment) driven project method and system based on staged retraining

Technical Field

The invention relates to an intelligent informatization technology, in particular to an AI driving project automation method and system based on staged retraining.

Background

With the rapid development of artificial intelligence technology, a Generative artificial intelligence model, such as a Generative Pre-trained Transformer (abbreviated as GPT), particularly such as GPT-3 and GPT-4 of OpenAI, has emerged as a strong ability to understand and solve problems, and as technology progresses, the ability becomes stronger. However, in practical applications, such artificial intelligence models face a key challenge: context length limitation. For example, GPT-4 of OpenAI currently has an 8K/32K token number context length limit. This limitation is detrimental to the application of such artificial intelligence models to automated implementation of large or medium-sized projects.

In order to successfully apply artificial intelligence techniques to automated implementations of large or medium-sized projects, we need to find methods to overcome or at least alleviate the context length limitation problem of artificial intelligence models.

One possible solution is to decompose the project layer by layer (or module by module) until the task is resolved that can accommodate the context length limitations of the artificial intelligence model. For each such task, we can let the artificial intelligence model perform, e.g., generate code, documents, etc. However, there is often a correlation between tasks, and artificial intelligence models can perform tasks efficiently only after providing information about the relevant tasks. This means that this approach is difficult to solve, and is only applicable to specific application scenarios, such as scenarios with less correlation between tasks.

The main solution of the current comparison is to combine a vector database and a abstract extraction technology, and the main points are as follows: generating abstract and vector according to the information generated when the task is executed, such as the requirement, the execution result and the like, and storing the vector, the corresponding information and the abstract into a vector database; when a new task is processed, retrieving a summary corresponding to the most relevant vector from a vector database according to the requirement of the current task, using the summary as background information for executing the task, and acquiring corresponding original information to regenerate the summary when necessary; these summaries are entered into the artificial intelligence model along with task requirements, which instruct them to perform tasks. The advantage of this approach is that by looking up the most relevant information and abstracting it, the context length limitations of the artificial intelligence model are greatly alleviated. However, the limitations of this approach are also apparent: its effectiveness is highly dependent on the accuracy of vectorization, retrieval and summarization techniques, which determines whether sufficient background information is available to perform a task; using the summary to replace the original information introduces information loss; for large projects, the amount of data may be excessive even if the background information required to perform certain tasks is extracted as a summary. Thus, while this solution alleviates the context length limitation problem of artificial intelligence models to some extent, it does not fundamentally address this challenge.

Disclosure of Invention

In order to overcome at least the above-mentioned shortcomings in the prior art, the present application aims to provide an AI-driven project automation method and system based on staged retraining.

In a first aspect, an embodiment of the present application provides an AI-driven project automation method based on staged retraining, including:

the task of acquiring the target item can be an initial task of the target item or a new task generated in the implementation process of the target item;

taking the task needing to be used in the first artificial intelligent model as a target task;

inputting the requirement of the target task to the first artificial intelligent model, and acquiring feedback content of the first artificial intelligent model;

checking whether the feedback content meets the requirement of the target task according to a preset evaluation standard, and interacting with the first artificial intelligent model again when the feedback content is required;

taking the feedback content meeting the requirements of the target task as an execution result of the target task, or sorting and forming the execution result of the target task according to the interaction content and the feedback content;

generating a training set according to the information generated in the implementation process of the target item in a staged manner;

And using the training set to conduct staged retraining on the first artificial intelligent model so that the first artificial intelligent model internalizes the knowledge structure related to the target item.

In one possible implementation, the generating of the training set includes:

and generating a training set by the first artificial intelligent model or other artificial intelligent models with corresponding functions and knowledge structures according to the information generated in the implementation process of the target project.

In one possible implementation, verifying whether the feedback content meets the target task requirement according to a preset evaluation criterion includes:

auditing by a second artificial intelligence model: if the verification is passed, the feedback content is used as an execution result of the target task; if the auditing is not passed, interacting with the first artificial intelligent model again, generating new feedback content, and carrying out the auditing again; the second artificial intelligence model is a first artificial intelligence model or other artificial intelligence models with corresponding functions and knowledge structures.

In one possible implementation, the method further includes:

and after all the tasks of the target project are successfully executed, integrating by the first artificial intelligent model, and generating an implementation result of the project according to the execution result of each task.

In one possible implementation, the method further includes:

when a new project is started, if the new project has correlation with the existing project, an artificial intelligent model which internalizes the knowledge structure of the related project is selected as a first artificial intelligent model of the new project.

In a second aspect, an embodiment of the present application provides an AI-driven project automation system based on staged retraining, comprising:

the task management module is configured to acquire a task of a target project, wherein the task can be an initial task of the target project or a new task generated in the implementation process of the target project; taking the task needing to be used in the first artificial intelligent model as a target task;

the artificial intelligence interaction module is configured to input the requirement of the target task to the first artificial intelligence model and acquire feedback content of the first artificial intelligence model;

the auditing module is configured to audit whether the feedback content meets the requirement of the target task according to a preset evaluation standard and interact with the first artificial intelligent model again when required;

the result generation module is configured to take feedback content meeting the requirements of the target task as an execution result of the target task or arrange the feedback content according to the interaction content and the feedback content to form the execution result of the target task;

The training set generation module is configured to generate a training set according to information generated in the implementation process of the target item;

a model training module configured to use the training set to retrain the first artificial intelligence model in stages to internalize the knowledge structure associated with the target item by the first artificial intelligence model.

In one possible implementation, the training set generating module is further configured to:

In one possible implementation, the auditing module is further configured to:

In one possible implementation, the result generation module is further configured to:

In one possible implementation, the method further includes:

the model selection module is configured to select an artificial intelligent model which internalizes the knowledge structure of the related project before as a first artificial intelligent model of the new project if the new project has correlation with the existing project when the new project is started.

In order to solve the defects of the prior art, the invention provides a solution based on staged retraining. In this scenario, an artificial intelligence model (e.g., GPT-3 of OpenAI) may receive periodic retraining during project implementation, such as by GPT Fine tuning (Fine-tuning) to learn and internalize project-related knowledge structures. In this way, the model can be made to use the learned knowledge about the project in the subsequent implementation of the project. In this way, the information corresponding to the internalized knowledge structure is not required to be input as the context into the artificial intelligence model in the task execution process, so that the problem of the limitation of the context length is solved. Although the effect of this scheme depends on the quality of retraining and the quality of training set generation under the current technical conditions, and also requires higher retraining costs, it is still a scheme that fundamentally overcomes the problem of context length limitation of artificial intelligence models.

In embodiments of the present application, the training set required for staged retraining may be automatically generated by the artificial intelligence model based on information generated during the project implementation. In addition, during a task implementation process, the artificial intelligence model can also audit the task execution results and re-execute all or part of the task when the evaluation criteria are not met. When the artificial intelligent model participates in the implementation process of the project in the whole course in the mode, the artificial intelligent model has all knowledge of the project, and final project integration can be completed.

By adopting the technical methods, after the initial requirement of the project is input, the project implementation can be completely and automatically completed by artificial intelligence. Therefore, the application provides a method for fundamentally solving the problem of context length limitation of the artificial intelligent model, and provides an effective way for the automated implementation of large or medium-sized projects.

Drawings

The accompanying drawings, which are included to provide a further understanding of embodiments of the application and are incorporated in and constitute a part of this specification, illustrate embodiments of the application and together with the description serve to explain the principles of the application. In the drawings:

FIG. 1 is a flow chart of an AI-driven project automation method based on staged retraining in accordance with an embodiment of the application;

FIG. 2 is a schematic diagram of a system architecture according to an embodiment of the present application;

FIG. 3 is a schematic diagram of another system architecture according to an embodiment of the present application.

Detailed Description

For the purpose of making the objects, technical solutions and advantages of the embodiments of the present application more apparent, the technical solutions of the embodiments of the present application will be clearly and completely described with reference to the accompanying drawings in the embodiments of the present application, and it should be understood that the drawings in the present application are for the purpose of illustration and description only and are not intended to limit the scope of the present application. In addition, it should be understood that the schematic drawings are not drawn to scale. A flowchart, as used in this disclosure, illustrates operations implemented according to some embodiments of the present application. It should be understood that the operations of the flow diagrams may be implemented out of order and that steps without logical context may be performed in reverse order or concurrently. Furthermore, one or more other operations may be added to or removed from the flow diagrams by those skilled in the art under the direction of the present disclosure.

In addition, the described embodiments are only some, but not all, embodiments of the application. The components of the embodiments of the present application generally described and illustrated in the figures herein may be arranged and designed in a wide variety of different configurations. Thus, the following detailed description of the embodiments of the application, as presented in the figures, is not intended to limit the scope of the application, as claimed, but is merely representative of selected embodiments of the application. All other embodiments, which can be made by a person skilled in the art without making any inventive effort, are intended to be within the scope of the present application.

Referring to fig. 1 in combination, a flow chart of an AI-driven project automation method based on staged retraining according to an embodiment of the present invention may be applied to an AI-driven project automation system based on staged retraining in fig. 2 and 3, and further, the method may specifically include the following descriptions of steps S1 to S7.

S1: the task of acquiring the target item can be an initial task of the target item or a new task generated in the implementation process of the target item;

s2: taking the task needing to be used in the first artificial intelligent model as a target task;

s3: inputting the requirement of the target task to the first artificial intelligent model, and acquiring feedback content of the first artificial intelligent model;

s4: checking whether the feedback content meets the requirement of the target task according to a preset evaluation standard, and interacting with the first artificial intelligent model again when the feedback content is required;

s5: taking the feedback content meeting the requirements of the target task as an execution result of the target task, or sorting and forming the execution result of the target task according to the interaction content and the feedback content;

S6: generating a training set according to the information generated in the implementation process of the target item in a staged manner;

s7: and using the training set to conduct staged retraining on the first artificial intelligent model so that the first artificial intelligent model internalizes the knowledge structure related to the target item.

In the embodiment of the application, the initial task refers to a task existing at the beginning of implementation of the target item. A target item may have multiple initial tasks, which typically occur in complex items, which may involve different fields, which may need to be processed simultaneously or sequentially at the beginning of the target item. The initial tasks of a target item may be independent of each other or may be related to each other to some extent.

New tasks may be continually generated during the implementation of the target item. These new tasks may be dynamically generated based on the implementation of the project, such as the results of the execution of the completed or stage completed tasks, the current project state, the problems encountered, or new requirements. Typically, new tasks are generated when tasks for target items are performed, e.g., subtasks may be resolved when tasks for target items are performed, and relatively independent tasks may be generated. In the embodiment of the application, the tasks of the types are collectively called as "tasks" without confusion.

When the embodiment of the application is implemented, the task of the acquired target project can come from an initial task or can come from a new task generated in the implementation process of the target project. Typically, when implementing the target item, we will first perform the initial task.

In the embodiment of the application, preferably, each task of the obtained target item is used as a target task, and the target task is executed according to the method of the embodiment of the application, including interaction with the first artificial intelligent model, feedback acquisition, audit and the like. It should be appreciated that during the implementation of the target item, new tasks may be generated, and that both the new tasks and the initial tasks need to be processed and completed during the implementation of the target item. The implementation of the project can be generalized as: executing the existing tasks, generating new tasks, executing the new tasks and the like, and circularly carrying out until all the tasks are completed.

It should be understood that, in the implementation of the target item, the steps shown in this embodiment may be performed multiple times, and the sequence of the steps may also be changed as needed. For example, S1-S5 are performed in a loop to complete each task of the project. In each cycle, one task (corresponding to S1) of the item is acquired, the task is taken as a target task (corresponding to S2), and the target task (corresponding to S3-S5) is executed. Wherein S3-S4, S3-S5 can be cycled for multiple times until the corresponding target task is completed. Here, the S3-S4, S3-S5 cycles may be considered as internal cycles of the S1-S5 cycles. For another example, during the project implementation, a training set is generated in stages (corresponding to S6), and the first artificial intelligence model is retrained with the training set (corresponding to S7). This means that S6 and S7 may be performed several times during the project implementation. Furthermore, it should be noted that a plurality of tasks may be performed concurrently.

In the embodiment of the present application, "execution result of a task" refers broadly to "stage execution result of a task" and "final execution result of a task". When the task is only completed in stages and is not completed finally, the execution result of the task refers to the stage execution result of the task; when a task is finally completed (i.e., the task is completed), the execution result of the task refers to the final execution result of the task.

It should be understood that the execution result of a target task may include staged content generated when the project implementation is performed on a requirement analysis document, an overall design scheme, a module division scheme, a subsystem design document, etc., and may include content of a task generated by a task decomposition scheme, a task generation scheme, etc. When a target task breaks down subtasks, we generally consider that the task is completed in stages, and the output task decomposition scheme is a part of the stage execution result of the task; when the execution of the subtask is completed, the subtask is further executed; when the task is continuously executed, the method according to the embodiment of the application can continuously interact with the first artificial intelligent model, obtain feedback, conduct auditing and the like, and the task requirement information input into the first artificial intelligent model can be part of the initial requirement of the task or can contain new content. When a target task no longer breaks up a subtask, the execution of the task is typically the final generation of the task, such as software code or fragments, HDL code or fragments, circuit design documents or fragments, novel text or fragments, documents or fragments, pictures or photo sets, videos or fragments, animations or fragments, and the like. The subtasks decomposed by the target task are usually obtained as new tasks and executed, and the subtasks may be further decomposed by the task, that is, the decomposition of the task may be spread step by step.

When the embodiment of the application is implemented, the tasks executed in the implementation process of the target item can be effectively managed, for example, the information of the tasks and the relation between the tasks are organized in a logical tree mode, a list method or other modes. Preferably, the stored task information includes task execution status, interaction content when executing the task, execution result content of the task, and the like.

In the implementation of the embodiment of the present application, an ID (such as a name or a number) should be generally set for the target item. In addition to the requirements and other necessary information of the task, the information input to the first artificial intelligence model when executing the target task should generally include a prompt word, and the prompt word should generally include an item ID. This would facilitate the first artificial intelligence model to perform tasks using the knowledge structure of the item that has been internalized.

In the implementation process of the target project, when the first artificial intelligent model needs to be updated to enable the knowledge structure related to the target project to be internalized, the first artificial intelligent model is retrained in a staged mode; the training set required for the periodic retraining is generated according to information generated in the implementation process of the target project. In this way, in the subsequent implementation process of the project, such as when the incomplete target task is continuously executed or a new target task is executed, information corresponding to the knowledge structure which is already internalized into the first artificial intelligent model is not required to be input into the first artificial intelligent model as a context, so that the problem of limitation of the context length of the artificial intelligent model is effectively solved.

Some artificial intelligence models, such as GPT-3 of OpenAI, can internalize related knowledge structures via retraining, such as fine-tuning. During retraining, the model learns and understands the new information and then integrates this understood knowledge into its neural network in the form of parameter adjustments. The result of this process is that the neural network parameters of the artificial intelligence model will be adjusted to reflect that the model has internalized these new knowledge structures.

During the implementation of the target item, tasks of the target item are continuously executed, and each task is executed to generate some data (or information) generally. Such information may include the needs of the task, feedback content generated by the first artificial intelligence model, other information interacted with by the first artificial intelligence model, results of execution of the task, information generated through other channels (e.g., external data sources, expert knowledge, human team discussions, etc.), and so forth. All of this information pertains to information generated during the implementation of the project. By processing the information, for example, the execution result of the task and the key point of the interaction information are summarized, and a training set is generated. It should be noted that, although some information, such as the requirement of the initial task, is usually already present when the target item starts to execute, for convenience of description, they will be considered as information generated during the implementation of the target item in the embodiment of the present application. Similarly, the need for a task typically exists at the beginning of the task execution, but for ease of description, the present application embodiments will still consider them as information generated at the time of task execution. In addition, when generating the training set, incremental data generated during implementation of the target item is mainly used. That is, once some data is used to generate the training set, the data is typically not used to generate a new training set. But this is not absolute and some data may be used in generating the training set multiple times as desired.

While it is preferred that the training set be used to retrain the first artificial intelligence model in stages after the training set is generated, this is not required. The training sets may be used together to perform a stepwise retraining of the first artificial intelligence model after accumulating the plurality of training sets, or the training sets may be generated while performing a stepwise retraining of the first artificial intelligence model. In specific implementation, the method can be determined according to factors such as characteristics of the project, influence of a knowledge structure corresponding to the training set on a target task being executed or to be executed, calculation force requirements and the like.

Preferably, each time a target task is completed or completed in stages, a training set is generated according to the related information and other necessary information generated when the target task is executed, and the training set is used for training the first artificial intelligent model in stages. For example, when the overall design task is completed in stages, after decomposing out the subtasks, a training set is generated and stage retraining is performed. Thus, the first artificial intelligence model can use the already internalized global design pre-knowledge and task decomposition knowledge in performing the subtasks of the global design task. It is worth noting that this is just the preferred way, and in fact, the timing of the staged retraining is very flexible. In particular implementations, this may be determined based on factors such as dependencies between tasks. For example, the training set may be generated and retrained uniformly after the completion/staged completion of a plurality of tasks, the training set may be generated and retrained during the execution of one task, and the training set may be generated and retrained during the execution of a part of tasks.

In the embodiment of the application, even if the task is not executed by using the first artificial intelligent model, the training set can be generated according to the execution result of the task and other information to perform the stage retraining on the first artificial intelligent model. That is, even a fully or partially manually completed task may allow the first artificial intelligence model to internalize the relevant knowledge structure in this manner. In addition, even if the target task is executed by the first artificial intelligence model, the first artificial intelligence model may not be allowed to internalize the relevant knowledge structure of the task. For example, when the relevant information of the task does not contribute to the subsequent implementation of the project, the corresponding knowledge structure internalization may not be performed to save costs.

In embodiments of the present application, the first artificial intelligence model is generally referred to as the concept of an instance. It does not refer to just one model type (e.g., GPT-3 for OpenAI), but includes specific instances and their states. When the first artificial intelligence model is retrained, its state changes, for example its neural network parameters are adjusted, so that the model can apply newly learned knowledge to perform the target task.

In the embodiment of the application, the first artificial intelligence model can be a GPT or other artificial intelligence model, and also can be a collaborative system formed by a plurality of artificial intelligence models. For example, a collaborative work system consisting of GPT-3 of OpenAI and DALL.E2 of OpenAI is used as a first artificial intelligent model, and GPT-3 is responsible for interacting with a user in natural language and generating an image making prompt; DALL.E2 is responsible for generating pictures from cues provided by GPT-3. The collaborative system can be regarded as logically presented externally as an artificial intelligence model.

In the embodiment of the application, the module division and the task decomposition can be logically regarded as the corresponding relationship. For example, we can consider a module partition as a task or part of a task; the design or implementation (e.g., writing code) of a module may also be considered a task.

In the embodiment of the application, the task can be properly scheduled. If a task depends on other tasks that have not yet been completed, the task may be put aside until all the tasks it depends on are completed. When executing tasks, the tasks can be ordered and scheduled according to the dependency relationship and the priority among the tasks.

The embodiment of the application has wide applicability, for example, can be applied to software development projects, chip design projects, circuit design projects, novel writing projects, various document writing projects, picture making projects, video making projects, animation making projects and the like. The final content generated by these items includes, but is not limited to, software code, HDL code, circuit design documents, novels, documents, pictures, videos, animations, and the like.

In summary, the embodiment of the application provides an AI-driven project automation method based on staged retraining, which effectively overcomes the problem of context length limitation of an artificial intelligent model and provides an effective way for automation implementation of large or medium-sized projects.

In one possible implementation, the generating of the training set includes:

By way of example, based on information generated during implementation of a target item, an artificial intelligence model for generating a training set may process the information and generate the training set according to the following steps:

s601: and preprocessing related information generated in the implementation process of the target item so as to facilitate subsequent operation. The preprocessing operations may include removing redundant data, extracting critical information, sorting text formats, and the like.

S602: and constructing a training sample according to the preprocessed information. Each training sample typically contains one input and one desired output. The input may be a question or a prompt related to the target task; the desired output is then the correct answer or solution to the input. For example, in a software development project, the input might be "how to implement a user login function? The desired output is then the corresponding code segment or design.

S603: and combining the constructed training samples into a training set. The number of samples in the training set may be adjusted according to actual needs and other possible factors. When generating the training set, it may also be considered to mix related information from different tasks together to improve the model's ability to understand the overall knowledge structure of the project.

S604: the generated training set may be further optimized, if necessary. For example, the training set may be augmented by data enhancement techniques (e.g., text transformation, insert noise, etc.) to increase the generalization ability of the model; the training set may also be screened or ranked using a specific algorithm to facilitate more efficient learning of key knowledge points by the model.

After the above steps are completed, a training set for stepwise retraining of the first artificial intelligence model is obtained. The training set is utilized to perform staged retraining (e.g., by GPT fine tuning techniques) on the first artificial intelligence model, thereby internalizing the relevant knowledge structure of the target task and overcoming the context length limitation problem during subsequent implementation of the project.

It should be appreciated that the artificial intelligence model used to generate the training set may be a collaborative system of multiple artificial intelligence models, which may be considered to logically appear externally as one artificial intelligence model.

While there are many advantages to using artificial intelligence models to automatically generate a training set, in some cases, artificial intelligence models used to generate training sets may need to be trained specifically to better accommodate specific business fields and task requirements. This may include pre-training, fine-tuning, etc. the model to provide it with the ability to address specific field problems. In practical application, whether the artificial intelligent model needs to be trained pertinently can be determined according to factors such as project requirements and performance of the artificial intelligent model.

The process of generating the training set is a relatively cumbersome and prone to missed work. The manual treatment process may cause problems such as inefficiency and unstable quality. By the innovative method provided by the embodiment of the application, the training set for internalizing the related knowledge structure into the first artificial intelligent model is automatically generated by utilizing the artificial intelligent model, so that the accuracy and efficiency of the generation process can be improved to a great extent. Meanwhile, the artificial intelligent model has strong learning and understanding capability, and can better capture key information and knowledge structures in target tasks, thereby being beneficial to realizing the goal of staged retraining.

In summary, in the AI-driven project automation method based on staged retraining, an artificial intelligent model is utilized to automatically generate a training set for staged retraining as one of key innovation points, so that the automation processing of an important link in the project implementation process is realized. This not only further advances the process of automation implementation of the project, but also brings significant advantages in terms of improving the project execution efficiency and reducing the cost.

In one possible implementation, verifying whether the feedback content meets the requirement of the target task according to a preset evaluation criterion includes:

When the embodiment of the application is implemented, the auditing can comprise checking grammar, logic, technical accuracy and the like of the feedback content. When the audit is not passed, the second artificial intelligence model can provide improvement ideas or guidelines to the first artificial intelligence model to assist it in generating feedback content that better meets the target task requirements. Thus, the auditing process may be an iterative process until the content fed back by the first artificial intelligence model passes the auditing via the second artificial intelligence model. And a second artificial intelligent model which is possibly different from the first artificial intelligent model is introduced to automatically audit whether the feedback content meets the target task requirement, so that the audit efficiency is improved, the functional characteristics of different models are fully exerted, and the feedback content can be judged more objectively and comprehensively.

It should be appreciated that the second artificial intelligence model may be a collaborative system of multiple artificial intelligence models. For example, in this system, one artificial intelligence model may be responsible for syntax checking of feedback content, while another artificial intelligence model is responsible for checking the accuracy of task execution results. This collaborative system can be logically viewed as an integral artificial intelligence model. Meanwhile, the second artificial intelligence model can also be a first artificial intelligence model, and the first artificial intelligence model and the second artificial intelligence model are the same artificial intelligence model.

While there are a number of advantages to using an artificial intelligence model to perform an audit, in some cases, an artificial intelligence model for an audit may need to be trained specifically, such as pre-trained, fine-tuned, etc., in order to better perform the audit task.

In a word, by using the artificial intelligence model for automatic auditing, human intervention and errors can be reduced, thereby improving accuracy and efficiency of project execution. And an important link in the project implementation process is automatically processed, so that the project automation implementation process is promoted.

In one possible implementation, the method further includes:

In the implementation of the embodiment of the application, the first artificial intelligence model is generally only provided with the capability of executing the integration task after internalizing all or the core knowledge structures related to the target item. Preferably, the first artificial intelligence model is retrained at each stage of the target project implementation. Through such a stepwise retraining, the first artificial intelligence model will gradually learn and learn knowledge structures and information about the target item. When all tasks of the target project have been successfully performed, it is indicated that the first artificial intelligence model has internalized all knowledge structures related to the entire project. At this point, integration by the first artificial intelligence model becomes feasible. Specifically, the first artificial intelligence model may generate implementation results for the entire project based on dependencies between tasks, their respective execution results, and the like. For example, in a software development project, the first artificial intelligence model may generate makefile according to information such as code modules, documents, etc. of each subtask, and then compile object code of the generated software.

In an embodiment of the application, the first artificial intelligence model plays a core role in the project implementation process. Through the stepwise retraining, not only the problem of the limitation of the context length can be overcome, but also the first artificial intelligent model can learn and master the knowledge structure related to the target project step by step. This enables the first artificial intelligence model to participate all the way through the project implementation process and eventually complete the project integration. The method also realizes the automatic processing of an important link in the project implementation process, and advances the process of project automatic implementation.

In one possible implementation, the method further includes:

When the embodiment of the application is implemented, when a new project is started, the correlation analysis is carried out on the new project and the existing project. If the new project is found to have a strong correlation with the existing project, if the new project depends on the existing project, then the artificial intelligence model which has internalized the knowledge structure of the corresponding existing project can be selected as the first artificial intelligence model of the new project. For example, assume we have completed the development of a base library software project (ID BaseLib), while the newly launched project relies on the base library, requiring components of the base library to be reused in the code of the new project, such as using classes in the base library or calling functions in the base library, etc. In this case, we can select an artificial intelligence model that has internalized the underlying knowledge structure as the artificial intelligence model for the new project. Thus, in the implementation of the new project, the first artificial intelligence model may use components in the base library as needed in performing the target task. If necessary, to better guide the first artificial intelligence model to utilize the underlying library resources, its behavior can be guided by providing appropriate hint words, such as: "please multiplex the components in BaseLib as much as possible to accomplish the project task".

It should be appreciated that such multiplexing may include not only multiplexing of knowledge content, e.g., new projects using the generated content of existing projects, but also multiplexing and inheritance in terms of methods and skills, etc. For example, in processing tasks similar to existing projects, an artificial intelligence model internalizing the knowledge structure of the existing project is selected as the first artificial intelligence model of the new project, which will enable the first artificial intelligence model to directly apply knowledge and skills that it has learned in the existing project during the implementation of the new project, and to borrow from the general methods and principles that it learns in the existing project.

In the embodiment of the application, the multiplexing of two or more existing project knowledge structures can be supported, and the effect similar to multiple inheritance is realized. For example, if new item N has a strong correlation with existing items A, B and C, then an artificial intelligence model may be selected that internalizes the knowledge structure of some of the existing items (here, item A is assumed) and creates its duplicate instance O. Then, on the basis of instance O, instance O is retrained using the corresponding training sets of internalized project B and project C knowledge structures. In this way, instance O will internalize the knowledge structure of items A, B and C simultaneously. Instance O is then used as the first artificial intelligence model for new item N. The choice of the "certain existing project" is mainly dependent on factors such as the retraining workload. While we can select any existing item, such as any of A, B, C in this example, we will typically select the corresponding item that is heavy in retraining effort as the "certain existing item".

In the embodiment of the application, when the artificial intelligent model with the built-in knowledge structure of the existing project is selected as the first artificial intelligent model of the new project, a copy (or an instance is cloned) of the artificial intelligent model instance is usually created as the first artificial intelligent model of the new project. The reason for this is that retraining an artificial intelligence model adjusts its parameters so that its state changes, thereby affecting the performance and behavior of the model. By cloning an instance, we can ensure that staged training of the new project first artificial intelligence model during implementation of the new project does not affect the artificial intelligence model instances of the existing project.

Based on the same inventive concept, please refer to fig. 2 and 3, there is also provided an AI-driven project automation system based on staged retraining, comprising:

In the implementation process of the target items, preferably, the obtained task of each target item is used as a target task and is executed through an artificial intelligent interaction module, an auditing module and a result generation module.

In the implementation process of the target project, when the first artificial intelligent model needs to be updated to internalize a knowledge structure related to the target project, the model training module is used for carrying out staged retraining on the first artificial intelligent model; the training set required by the periodic retraining is generated by a model training module according to information generated in the implementation process of the target project. It should be appreciated that the model training module training set generation module may be used multiple times in stages during the implementation of the target item.

When embodiments of the present application are implemented, the task management module should typically provide a human-machine interface and/or interfaces for users and/or other artificial intelligence models to enter initial tasks for the target item.

The task management module may employ a logical tree approach, a list approach, or other approaches to organize task information and relationships between tasks for the project. In general, the stored task information may include requirements of the task, execution status of the task, interactive contents when the task is executed, execution result contents of the task, and the like.

And if the result generated by the result generation module contains the new task generation, the new task information is preferably provided for the task management module for unified management.

The task management module can also be responsible for the distribution scheduling of tasks, and after a new task is added to the task management module, the task management module can acquire the new task and distribute the new task to the corresponding module for execution.

The auditing module preferably proceeds through the artificial intelligence interaction module when re-interaction with the first artificial intelligence model is required.

The system also comprises a target task execution module, wherein the target task execution module is configured to take the artificial intelligent interaction module, the auditing module and the result generation module as sub-modules thereof to cooperatively complete interaction, auditing and result generation of one target task.

The training set generating and retraining module can be further arranged to take the training set generating module and the model training module as sub-modules thereof, and the first artificial intelligent model is retrained in a staged mode after the training set is generated.

In particular, the modules should be co-processed. For example, the task management module is closely cooperated with the artificial intelligent interaction module, the auditing module and the result generation module to jointly complete task execution of the target project.

In the embodiment of the application, when interaction with the artificial intelligent model is needed, such as inputting information, obtaining feedback, interaction discussion, inputting information for auditing, obtaining auditing results, obtaining a generated training set, inputting the training set for retraining, creating an artificial intelligent model copy (or cloning an instance based on an artificial intelligent model instance), and selecting an appropriate mode according to an interface provided by an artificial intelligent model provider. The artificial intelligence model provider defined interface may be an HTTP-based API, an RPC-based API, an SDK-based API, or the like.

In summary, the embodiments of the present application provide an AI-driven project automation system based on staged retraining, which aims to solve the problem of context length limitation of artificial intelligence models and provide an effective way for automated implementation of large or medium-sized projects.

For example, referring to fig. 2, an architecture scheme of an embodiment of the present application is shown. In this example scenario, each time a target task is performed or completed in stages, the training set generation and retraining module is invoked to generate a training set according to the relevant information generated during the task execution, and retrain the first artificial intelligence model.

For example, referring to fig. 3, an architecture scheme of an embodiment of the present application is shown. Unlike the scheme shown in fig. 2, this scheme does not retrain the first artificial intelligence model when each task is completed or completed in stages, but calls the training set generation and retraining module in stages according to factors such as dependencies among tasks of the target project, generates a training set according to related information generated in the project implementation process, and retrains the first artificial intelligence model.

In the schemes shown in fig. 2 and 3: generating a training set and auditing using the first artificial intelligence model, wherein the auditing can be performed by using a second artificial intelligence model different from the first artificial intelligence model when the actual project is implemented, and generating the training set by using other artificial intelligence models different from the first artificial intelligence model; and retraining the first artificial intelligent model after generating the training set by using a training set generation and retraining module comprising a training set generation sub-module and a model retraining sub-module.

In one possible implementation, the auditing module is further configured to:

In one possible implementation, the method further includes:

By way of example, a specific implementation is also provided, which is applied to a software development project. When an item is started, firstly, selecting a proper artificial intelligent model as a first artificial intelligent model according to the relevance of the item and the existing item. In this example, we choose one GPT model instance that has internalized the existing project-related knowledge structure and create its duplicate instance as the first artificial intelligence model. At the same time, we will use the same artificial intelligence model as a second artificial intelligence model to be responsible for auditing.

We consider all tasks to be performed in an item as target tasks. For each target task: inputting task demands and related prompt words into a first artificial intelligent model, after feedback is obtained, auditing by a second artificial intelligent model, and re-interacting when needed until auditing passes and a task execution result is obtained; when the task execution is completed or the phase is completed, a training set is generated according to information generated during the task execution using the first artificial intelligence model.

In the project implementation process: taking an initial task (namely a software development task) as a first target task, and generating a demand analysis task and an overall design task when the initial task is executed; the method comprises the steps of sequentially executing a demand analysis task and an overall design task, wherein the overall design task divides a module and generates a module design task when being executed; respectively executing the design tasks of each module, and after each module design task is completed, generating a corresponding code writing task; code writing tasks of all modules are executed respectively, and final software codes are generated; after all tasks are successfully executed, integrating by the first artificial intelligent model to generate a makefile, further compiling a software target code, and submitting the contents of the software source code, the generated document and the like to a version library. In this process, the first artificial intelligence model is retrained in stages. In this way, in the implementation of the project, it is not necessary to input information corresponding to the knowledge structure that has been internalized into the first artificial intelligence model as context to the first artificial intelligence model. For example, when executing code writing tasks of a module, no background information such as a requirement specification, an overall design, etc. need be input as context to the first artificial intelligence model.

It should be noted that in this example, each target task or phase is completed with a corresponding training set generated, but this training set is not necessarily immediately used to retrain the first artificial intelligence model. The time of retraining can be controlled by the first artificial intelligence model according to factors such as dependency among tasks, and a batch of training sets can be accumulated and used for stepwise retraining of the first artificial intelligence model.

In the project implementation process, tasks are decomposed layer by layer until all target tasks are no longer decomposed. The execution result will be the final generated content, such as a requirement analysis document, software code, etc. The results of the execution of certain tasks (e.g., overall design tasks) include both overall design solution documents and subtask decomposition solutions.

It should be noted that in this example, the demand analysis task and the overall design task are generated when the initial task is performed, but this is not a limitation of the present embodiment. Indeed, the overall design task may be generated entirely upon execution of the demand analysis task. How the hierarchical relationships between tasks are organized depends on the nature of the project and the choice of developer and may also be affected by the characteristics of the selected artificial intelligence model, such as the functionality and knowledge structure.

Notably, to achieve complete automation of a software development project, the initial requirements of the project must be sufficiently detailed. In the actual project implementation process, multiple interactions with the first artificial intelligence model may be required to define the requirements during the execution phase of the requirement analysis task. The subsequent implementation is only possible in a fully automated manner.

It should be noted that, when the present embodiment is specifically implemented, it is generally necessary to implement a project management module, which generally coordinates task management, task addition, task distribution, task execution, training set generation, staged training execution, project integration, and the like.

By way of example, a specific implementation is also provided, which is applied to novice writing. In the project starting stage, firstly, according to the relevance of the project and the existing project, a proper artificial intelligent model is selected as a first artificial intelligent model. For novice writing, unless the content is inherited (e.g., as a continuation of a past work), the language style of the artificial intelligence model in which it generates text is more considered in selecting it, such as serious, regular, or humorous. In this example, we choose a GPT model instance that is fine-tuned to have the desired language generation style and create its replica instance as the first artificial intelligence model. At the same time, we will use the same artificial intelligence model as a second artificial intelligence model to be responsible for auditing. It should be noted that, with the development of the artificial intelligence technology, an artificial intelligence model may have multiple text generating styles at the same time, and we can put forward a demand through a suitable prompt word.

We consider all tasks to be performed in an item as target tasks. For each target task: inputting task demands and related prompt words into a first artificial intelligent model, carrying out optional interactive discussion, obtaining feedback (for example, enabling the first artificial intelligent model to sum up the execution result of the task according to interactive contents), auditing by a second artificial intelligent model, and re-interacting when needed until the auditing passes and the execution result of the task is obtained; when the task execution is completed or completed in a staged manner, a training set is generated by using the first artificial intelligent model according to the information generated during the task execution, and the training set is used for carrying out staged retraining on the first artificial intelligent model so as to internalize the relevant knowledge structure of the task.

In this example, we assume that the author's project needs are only writing novels, and no background content is provided for story-going, character design, etc.

We divide the novel writing process into two stages, design and writing. The design stage mainly relates to the design of story block, role setting, plot arrangement and the like. The writing stage is responsible for completing the specific writing of each chapter.

In the design process: taking an initial task (namely a writing novel task) as a first target task, and decomposing subtasks such as a summary design, a role design, a plot design and the like when the initial task is executed; these tasks may be performed with sub-tasks such as detailed design tasks for each character and detailed design tasks for each scenario; and executing the tasks respectively until all the tasks are completed, and generating writing tasks of each chapter. Each chapter writing task contains the requirement information such as a summary, a target and the like required for writing the chapter, and is usually presented in a key point form.

During writing: and respectively executing the writing tasks of each chapter. Ideally, when the writing requirement of each chapter is sufficient and clear, the writing task of each chapter can be automatically performed by the first artificial intelligence model. The method can also interact with the first artificial intelligent model first, clarify and further clarify the writing requirement of the section, and then the first artificial intelligent model is used for specific writing.

When the novels are released in an carried form, the corresponding chapters may be released after each chapter is completed. After writing of all chapters is completed, the programs and/or the first artificial intelligence model can be integrated to generate a complete novel text.

In the project implementation process, because each target task is correspondingly retrained to the first artificial intelligent model when the execution of the target task is completed or the execution of the target task is completed in a staged manner, the relevant knowledge structure of the corresponding task is internalized, and therefore, information corresponding to the internalized knowledge structure is not required to be input into the first artificial intelligent model as a context when one task is executed. For example, in performing a chapter writing task, background information such as story blocks, character designs, etc. need not be input as context to the first artificial intelligence model.

In the specific implementation of this embodiment, a project management module is generally required to coordinate links such as task management, task execution, training set generation, staged training implementation, chapter release, and full-text integration. In order to facilitate the author's full interaction with the first artificial intelligence model, it may also be desirable to provide an intuitive and easy-to-use human-machine interaction interface. In addition, in the prior art, an audit verification interface may be required for each chapter writing task so that the author may perform a final audit and verification of the chapter content generated by the first artificial intelligence model.

The present embodiment demonstrates the advantages of the AI-driven automation method and system based on staged retraining in overcoming the context length limitations. In the complex and specialized task of generating training sets required for periodic retraining, the artificial intelligent model is used for automatically generating the training sets, so that the burden of a novel author is greatly reduced. In addition, the author can not only discuss and summarize the scheme with the artificial intelligence model in the process of creation and design, but also write specific chapters by using the model, and the novel creative, the ideas and ideas to be expressed by the author are still controlled by the author.

By way of example, a specific implementation is also provided that is applied to an animation project. Under the prior art conditions, GPT-3, which relies on text-generated models such as OpenAI alone, is not satisfactory in the animation field. Thus, in this example, we also introduce other types of artificial intelligence models to cooperatively accomplish tasks. For example, an artificial intelligence model is introduced that can generate hand-drawn character images into animated character images, an artificial intelligence model is introduced that can generate background images from textual descriptions, and an artificial intelligence model is introduced that can generate animated fragments from textual descriptions. These different types of artificial intelligence models constitute a collaborative system and logically appear externally as an artificial intelligence model. Wherein, a generated language model (such as GPT-3 of OpenAI) is used as a pivot thereof and is responsible for man-machine interaction and converting the requirements of a producer described by natural language into commands or prompts required by other models. On the other hand, with the development of artificial intelligence technology, a multi-mode artificial intelligence model supporting text, image and sound mixed input and output may occur at the same time, and at this time, the requirement of the method can be met by using a single artificial intelligence model.

At project start-up, the appropriate artificial intelligence model is first selected as the first artificial intelligence model. Here we assume that this is a completely new animation and we choose an instance of the collaborative system model that already has the corresponding functionality as the first artificial intelligence model. At the same time, we will use the same first artificial intelligence model as the second artificial intelligence model to be responsible for auditing.

We consider all tasks to be performed in an item as target tasks. For each target task: inputting task demands and related prompt words into a first artificial intelligent model, carrying out optional interactive discussion, obtaining feedback (for example, enabling the first artificial intelligent model to sum up the execution result of the task according to interactive contents), auditing by a second artificial intelligent model, and re-interacting when needed until the auditing passes and the execution result of the task is obtained; when the task execution is completed or completed in stages, a training set is generated by using the first artificial intelligent model according to the information generated during the task execution, and the first artificial intelligent model is retrained by using the data set so as to internalize the relevant knowledge structure of the task. It should be noted that in performing certain tasks, it may be necessary to input non-text information such as hand-drawn images.

In this example, we assume that the project requirement of the producer is to produce only an animation, and that no transcript is provided, nor is content such as story conception, transcript, and the like.

We divide the animation process into two stages, design and clip production. The design stage mainly relates to story conception, scenario creation, scene design, segment design and the like; the segment making stage is responsible for completing the making of each animation segment.

In the design process: taking an initial task (namely, making an animation film) as a first target task, and decomposing subtasks such as story conception, scenario creation, scene design and the like when the initial task is executed; because of the dependencies among the tasks, the tasks are sequentially executed, and new tasks such as design tasks of various roles, segment design tasks and the like can be generated when the tasks are executed; and respectively executing the tasks according to the proper sequence until all the tasks are completed, and generating the making tasks of all the fragments. Each segment making task includes the required information such as the outline, role, background and the like required for making the segment.

In the process of making the fragments: and respectively executing each segment making task. Ideally, when the requirements of each segment production are sufficient and clear, the production tasks of the respective segments can be automatically performed by the first artificial intelligence model. The method can also be used for firstly interacting with the first artificial intelligent model, clarifying and further definitely requiring, and then specifically manufacturing by the first artificial intelligent model. In performing fragment production tasks, the first artificial intelligence may involve a number of multi-model collaboration internally to accomplish the corresponding task.

After all the fragments are manufactured, integrating by the program and/or the first artificial intelligent model to generate a complete animation, and outputting related documents and materials.

It should be noted that in this example, we only deal with some of the content of the animation, and in fact, the animation includes many other links, such as clipping, dubbing, sound effects, music, etc. in the synthesis stage.

In the project implementation process, because each target task is correspondingly retrained to the first artificial intelligent model when the execution of the target task is completed or the execution of the target task is completed in a staged manner, the relevant knowledge structure of the corresponding task is internalized, and therefore, information corresponding to the internalized knowledge structure is not required to be input into the first artificial intelligent model as a context when one task is executed. For example, in performing a clip production task, it is not necessary to input background information such as story conception, scenario creation, etc. as context to the first artificial intelligence model.

In the specific implementation of this embodiment, a project management module is generally required to coordinate links such as task management, task execution, training set generation, and staged training implementation. In addition, in order to facilitate the producer to interact with the first artificial intelligence model fully, it may be necessary to provide an intuitive and easy-to-use man-machine interface, provide a manual auditing interface, and so on. The interactive interface may also have a function of inputting pictures.

Cartoon making is a very complex process, but the present embodiment demonstrates that AI-driven automation methods and systems based on staged retraining can still play an important role in such complex projects.

Those of ordinary skill in the art will appreciate that the elements and algorithm steps described in connection with the embodiments disclosed herein may be embodied in electronic hardware, in computer software, or in a combination of the two, and that the elements and steps of the examples have been generally described in terms of function in the foregoing description to clearly illustrate the interchangeability of hardware and software. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the solution. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present application.

In the several embodiments provided by the present application, it should be understood that the disclosed apparatus and method may be implemented in other manners. For example, the apparatus embodiments described above are merely illustrative, e.g., the division of the units is merely a logical function division, and there may be additional divisions when actually implemented, e.g., multiple units or components may be combined or integrated into another system, or some features may be omitted or not performed. In addition, the coupling or direct coupling or communication connection shown or discussed with each other may be an indirect coupling or communication connection via some interfaces, devices, or elements, or may be an electrical, mechanical, or other form of connection.

The elements described as separate components may or may not be physically separate, and it will be apparent to those skilled in the art that elements and algorithm steps of the examples described in connection with the embodiments disclosed herein may be implemented as electronic hardware, computer software, or combinations of both, and that the elements and steps of the examples have been generally described functionally in the foregoing description so as to clearly illustrate the interchangeability of hardware and software. Whether such functionality is implemented as hardware or software depends upon the particular application and design constraints imposed on the solution. Skilled artisans may implement the described functionality in varying ways for each particular application, but such implementation decisions should not be interpreted as causing a departure from the scope of the present invention.

In addition, each functional unit in the embodiments of the present invention may be integrated in one processing unit, or each unit may exist alone physically, or two or more units may be integrated in one unit. The integrated units may be implemented in hardware or in software functional units.

The integrated units, if implemented in the form of software functional units and sold or used as stand-alone products, may be stored in a computer readable storage medium. Based on such understanding, the technical solution of the present invention is essentially or a part contributing to the prior art, or all or part of the technical solution may be embodied in the form of a software product stored in a storage medium, comprising several instructions for causing a computer device (which may be a personal computer, a server, a grid device, etc.) to perform all or part of the steps of the method according to the embodiments of the present invention. And the aforementioned storage medium includes: a U-disk, a removable hard disk, a Read-only memory (ROM), a random access memory (RAM, random Access Memory), a magnetic disk, or an optical disk, or other various media capable of storing program codes.

The foregoing description of the embodiments has been provided for the purpose of illustrating the general principles of the invention, and is not meant to limit the scope of the invention, but to limit the invention to the particular embodiments, and any modifications, equivalents, improvements, etc. that fall within the spirit and principles of the invention are intended to be included within the scope of the invention.

Claims

1. An AI-driven project automation method based on staged retraining, comprising:

acquiring a task of a target item, wherein the task is an initial task of the target item or a new task generated in the implementation process of the target item;

inputting the requirement of the target task to the first artificial intelligent model, and acquiring feedback content of the first artificial intelligent model; the demand is input in the form of at least one of text, image, and sound;

taking the feedback content meeting the requirements of the target task as an execution result of the target task, or sorting and forming the execution result of the target task according to the interactive content and the feedback content;

performing staged retraining on the first artificial intelligence model by using the training set to enable the first artificial intelligence model to internalize the knowledge structure related to the target item;

Verifying whether the feedback content meets the target task requirement according to a preset evaluation standard comprises the following steps:

2. The AI-driven project automation method of claim 1, wherein the training set generation comprises:

3. The AI-driven project automation method based on staged retraining of claim 1, further comprising:

4. The AI-driven project automation method based on staged retraining of claim 1, further comprising:

5. An AI-driven project automation system based on staged retraining, comprising:

the task management module is configured to acquire a task of a target project, wherein the task is an initial task of the target project or a new task generated in the implementation process of the target project; taking the task needing to be used in the first artificial intelligent model as a target task;

the artificial intelligence interaction module is configured to input the requirement of the target task to the first artificial intelligence model and acquire feedback content of the first artificial intelligence model; the demand is input in the form of at least one of text, image, and sound;

a model training module configured to use the training set to retrain the first artificial intelligence model in stages to internalize the knowledge structure associated with the target item by the first artificial intelligence model;

the auditing module is further configured to:

6. The AI-driven project automation system of claim 5, wherein the training set generation module is further configured to:

7. The AI-driven project automation system of claim 5, wherein the result generation module is further configured to:

8. The AI-driven project automation system based on staged retraining of claim 5, further comprising: