Task instruction construction method and task processing method

Abstract

The present application relates to a task instruction construction method and apparatus, a task processing method and apparatus, a computer device, a computer readable storage medium, and a computer program product. The task instruction construction method comprises: acquiring task information of a target task, and an instruction data set comprising a plurality of pieces of instruction information (S302); performing semantic analysis on the task information to determine a task type and a task requirement of the target task (S304); using query information matching the task type to guide a large model to select, from the instruction data set, candidate instructions matching the task type (S306); and determining, from among the candidate instructions, a task instruction satisfying the task requirement (S308), wherein the task instruction is used for guiding the large model to execute the target task. The method can improve the working efficiency during task instruction construction.

Description

Task instruction construction method and task processing method

[0001] CROSS-REFERENCE TO RELATED APPLICATIONS

[0002] This application claims priority to the Chinese patent application filed with the China Patent Office on February 21, 2024, with application number 202410191450.7 and application name “Task Instruction Construction Method and Task Processing Method”, all contents of which are incorporated by reference into this application. Technical Field

[0003] The present application relates to the field of computer technology, and in particular to a task instruction construction method, a task processing method, an apparatus, a computer device, a computer-readable storage medium, and a computer program product. Background Art

[0004] The large model can also be called a cornerstone model or foundation model. During pre-training, the large model has learned most of the knowledge and has good generalization ability. When applied to different downstream tasks, task instructions (prompts) are required to guide the model to generate the desired output.

[0005] Traditionally, business personnel construct task instructions based on specific tasks. This process relies on human-computer interaction, and the long data processing time consumes a large amount of computing resources. This leads to low efficiency in the task instruction construction process. Summary of the Invention

[0006] According to various embodiments of the present application, a task instruction construction method, a task processing method, an apparatus, a computer device, a computer-readable storage medium, and a computer program product are provided.

[0007] In one aspect, the present application provides a method for constructing a task instruction, which is executed by a computer device. The method comprises:

[0008] Obtaining task information of a target task and an instruction data set containing multiple instruction information;

[0009] Performing semantic analysis on the task information to determine the task type and task requirements of the target task;

[0010] Using query information adapted to the task type, guiding the large model to filter out candidate instructions matching the task type from the instruction dataset; and

[0011] From each of the candidate instructions, a task instruction that meets the task requirements is determined, wherein the task instruction is used to guide the large model to perform the target task.

[0012] On the other hand, the present application also provides a task processing method, which is executed by a computer device. The method includes:

[0013] Obtaining task requirements of a target task and pending information for the target task;

[0014] Based on the task requirements, reading a task instruction that matches the target task from an instruction set, wherein the task instruction is constructed based on the above-mentioned task instruction construction method; and

[0015] The information to be processed and the task instruction are input into a large model, wherein the large model, under the guidance of the task instruction, determines the processing result of the information to be processed according to the task requirements.

[0016] On the other hand, the present application also provides a task instruction construction device. The device includes:

[0017] A task information acquisition module is used to obtain task information of a target task and an instruction data set containing multiple instruction information;

[0018] A requirement determination module is used to perform semantic analysis on the task information to determine the task type and task requirements of the target task;

[0019] a candidate instruction screening module, configured to use query information adapted to the task type to guide the large model to screen candidate instructions matching the task type from the instruction dataset; and

[0020] A task instruction determination module is used to determine a task instruction that meets the task requirements from each candidate instruction, wherein the task instruction is used to guide the large model to perform the target task.

[0021] On the other hand, the present application also provides a task processing device. The device includes:

[0022] A module for obtaining information to be processed, used to obtain the task requirements of a target task and the information to be processed for the target task;

[0023] a task instruction reading module, configured to read a task instruction matching the target task from an instruction set based on the task requirement, wherein the task instruction is constructed by the task instruction constructing device; and

[0024] The task processing module is used to input the information to be processed and the task instructions into the large model, wherein the large model, under the guidance of the task instructions, determines the processing result of the information to be processed according to the task requirements.

[0025] In another aspect, the present application further provides a computer device comprising a memory and one or more processors, wherein the memory stores computer-readable instructions, and the one or more processors execute the steps of the method embodiments of the present application when executing the computer-readable instructions.

[0026] In another aspect, the present application further provides a computer-readable storage medium having computer-readable instructions stored thereon, which, when executed by one or more processors, perform the steps of the method embodiments of the present application.

[0027] In another aspect, the present application further provides a computer program product, comprising computer-readable instructions, which, when executed by one or more processors, perform the steps of the method embodiments of the present application.

[0028] The details of one or more embodiments of the present application are set forth in the accompanying drawings and the description below. Other features, objects, and advantages of the present application will become apparent from the description, drawings, and claims. BRIEF DESCRIPTION OF THE DRAWINGS

[0029] In order to more clearly illustrate the technical solutions in the embodiments of the present application, the following briefly introduces the drawings required for use in the description of the embodiments. Obviously, the drawings described below are only some embodiments of the present application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0030] FIG1 is a diagram illustrating an application environment of a task instruction construction method and a task processing method according to an embodiment;

[0031] FIG2 is a schematic diagram of the implementation process of a large model landing task in one embodiment;

[0032] FIG3 is a schematic diagram of a flow chart of a method for constructing a task instruction in one embodiment;

[0033] FIG4 is a schematic diagram of the structure of an encoder in one embodiment;

[0034] FIG5 is a schematic diagram of the structure of a decoder in one embodiment;

[0035] FIG6 is a schematic diagram of a process of constructing a task instruction in one embodiment;

[0036] FIG7 is a schematic diagram of a process of constructing a task instruction in another embodiment;

[0037] FIG8 is a schematic diagram of a process of constructing a task instruction in another embodiment;

[0038] FIG9 is a flow chart of a method for constructing a task instruction in another embodiment;

[0039] FIG10 is a schematic diagram of a process flow of a task processing method in one embodiment;

[0040] FIG11 is a schematic diagram of the implementation process of a large model landing task in another embodiment;

[0041] FIG12 is a structural block diagram of a task instruction construction device according to an embodiment;

[0042] FIG13 is a block diagram of a task processing device according to an embodiment;

[0043] FIG14 is a diagram showing the internal structure of a computer device according to one embodiment;

[0044] FIG15 is a diagram showing the internal structure of a computer device in another embodiment. DETAILED DESCRIPTION

[0045] The following will be combined with the drawings in the embodiments of this application to clearly and completely describe the technical solutions in the embodiments of this application. Obviously, the embodiments described are only part of the embodiments of this application, not all of the embodiments. Based on the embodiments in this application, all other embodiments obtained by ordinary technicians in this field without making creative efforts are within the scope of protection of this application.

[0046] In order to make the purpose, technical solutions and advantages of this application more clear, the following further describes this application in detail with reference to the accompanying drawings and embodiments. It should be understood that the specific embodiments described herein are only used to explain this application and are not intended to limit this application.

[0047] First, the professional terminology designed in this application is introduced.

[0048] Large models are a type of model in machine learning and artificial intelligence characterized by a large number of parameters and complex architecture. These models typically consist of multi-layer neural networks, with each layer containing a large number of neurons. Due to their size and complexity, training and inference of such models require significant computing resources, including processor time and memory space. Large models are often able to capture complex patterns and relationships in data, achieving excellent performance on various tasks such as image recognition, natural language processing, and speech recognition. Large models, also known as pre-training models or cornerstone models, refer to deep neural networks (DNNs) with large parameters. These models are trained on massive amounts of unlabeled data. Leveraging the function approximation capabilities of large-parameter DNNs, pretrained neural networks (PTMs) extract common features from the data. Through fine-tuning, efficient parameter fine-tuning (PEFT), and prompt-tuning techniques, these models are then suitable for downstream tasks. Therefore, large models can achieve ideal results in few-shot or zero-shot scenarios. Based on the data modality they process, PTMs can be categorized into language models (ELMO, BERT, GPT), vision models (swin-transformer, ViT, V-MOE), speech models (VALL-E), and multimodal models (ViBERT, CLIP, Flamingo, Gato). Multimodal models represent features from two or more data modalities. Large models are crucial tools for outputting AI-generated content (AIGC) and can also serve as a universal interface for connecting multiple task-specific models.

[0049] In computer science and natural language processing, a prompt, also known as a prompt or instruction, typically refers to the input text or questions given to a machine learning model to guide the model in generating the appropriate output. It can be a question, a sentence, a paragraph, or a set of instructions designed to guide the model to produce a specific answer or generate a specific type of text.

[0050] Prompt engineering is a strategic task in large models. It primarily involves designing and optimizing input prompts to guide the model to produce the desired output. This strategy can include selecting specific vocabulary and grammatical structures, or providing contextual information to help the model better understand the task requirements and generate more accurate responses.

[0051] Beam Search: A heuristic graph search algorithm used to search for a limited number of optimal solutions in a graph or tree. In generative models, beam search is used to reduce the search space and improve generation efficiency. At each step, it retains only the top N results with the highest prediction scores (N is the beam width), effectively narrowing the search space and improving search efficiency.

[0052] Large model implementation: refers to the process of transforming a large model from the theoretical research stage to the practical application stage.

[0053] The task instruction construction method and task processing method provided in the embodiments of the present application can be applied to the application environment shown in Figure 1. In this case, the terminal 102 communicates with the server 104 via a network. The communication network can be a wired network or a wireless network. Therefore, the terminal 102 and the server 104 can be directly or indirectly connected via wired or wireless communication. For example, the terminal 102 can be indirectly connected to the server 104 via a wireless access point, or the terminal 102 can be directly connected to the server 104 via the Internet, and this application does not limit this.

[0054] Among them, the terminal 102 can be, but is not limited to, various desktop computers, laptops, smart phones, tablets, Internet of Things devices and portable wearable devices. The Internet of Things devices can be smart speakers, smart TVs, smart air conditioners, smart car-mounted devices, etc. Portable wearable devices can be smart watches, smart bracelets, head-mounted devices, etc. The server 104 can be an independent physical server, or a server cluster or distributed system composed of multiple physical servers. It can also be a cloud server that provides basic cloud computing services such as cloud services, cloud databases, cloud computing, cloud functions, cloud storage, network services, cloud communications, middleware services, domain name services, security services, CDN (Content Delivery Network), and big data and artificial intelligence platforms. The data storage system can store data that the server 104 needs to process. The data storage system can be set up separately, integrated on the server 104, or placed on the cloud or other servers.

[0055] It should be noted that in the task instruction construction method and task processing method provided in the embodiments of this application, the execution subject of each step can be a computer device, which refers to an electronic device with data calculation, processing, and storage capabilities. Taking the solution implementation environment shown in Figure 1 as an example, the task instruction construction method and task processing method can be executed by terminal 102, or by server 104, or by terminal 102 and server 104 interacting and cooperating to execute them, and this embodiment of the application does not limit this.

[0056] Take the case where the terminal 102 executes the task instruction construction method and the task processing method as an example. As shown in Figure 2, the present application can be applied to the large model landing task, and the specific implementation process includes two stages: the task instruction construction stage, and the task processing stage based on the task instruction. Among them, the first stage can construct task instructions corresponding to multiple target tasks, and one target task can construct multiple task instructions, thereby obtaining an instruction set applied to the large model. The instruction set of the first stage can provide task instructions to the large model of the second stage. These task instructions can realize diversified instruction expressions and guide the large model to execute the target tasks corresponding to the task instructions.

[0057] Specifically, in the first stage, terminal 102 can obtain task information for a target task and an instruction dataset containing multiple instruction information. The task information can be entered into terminal 102 by a business operator or obtained from other devices. These other devices can be, for example, servers or other terminals. The instruction information can come from network data, public datasets, and editorial data. After obtaining the task information and instruction dataset, terminal 102 can perform semantic analysis on the task information to determine the task type and task requirements of the target task. Furthermore, using query information tailored to the task type, terminal 102 can guide the large-scale model to filter candidate instructions matching the task type from the instruction dataset, completing a preliminary screening of instructions. Finally, terminal 102 identifies task instructions that meet the task requirements from the candidate instructions obtained in the preliminary screening. In the second stage, terminal 102 can obtain the task requirements of the target task and the pending information for the target task. Based on the task requirements, terminal 102 then retrieves task instructions matching the target task from the instruction dataset constructed in the first stage. Finally, the pending information and task instructions are input into the large-scale model, allowing the large-scale model, guided by the task instructions, to determine the processing results for the pending information according to the task requirements.

[0058] It should be noted that the task instruction construction method and task processing method provided in the embodiments of the present application can be applied to various application fields, and there are no restrictions on the task type and task modality of the target task. Among them, the application fields can be, for example, health, finance, scientific research, law, education, etc., the task types can be, for example, sentiment analysis, professional examinations, programming languages, software development and problem finding, image understanding, mathematical and scientific problem solving, data comprehensive analysis, fact checking, games and entertainment, etc., and the task modality can be, for example, image, voice, text, etc. The task modality refers to the modality of the information to be processed during the task processing stage. Taking the sentiment analysis task as an example, in actual applications, the sentiment polarity analysis can be performed on images and text. For example, different texts can express different sentiment polarities; for example, a person's facial expressions, body movements, and spoken words can all be used to express sentiment polarity; for example, different images can also be used to express different sentiment polarities. Taking color as an example, blue can express melancholy and sadness, while red can express happiness and excitement. In other words, the sentiment analysis task can specifically refer to the sentiment polarity analysis of specific objects such as text, character images, or landscape images. Therefore, based on the task information of the sentiment analysis task, the terminal can filter out task instructions that meet the task requirements of the sentiment analysis task from the instruction data set containing multiple instruction information to guide the large model to perform the sentiment analysis task.

[0059] In one embodiment, as shown in FIG3 , a method for constructing a task instruction is provided. The method may be executed by a computer device, which may be the terminal or server shown in FIG1 . In this embodiment, the method is described by taking the terminal in FIG1 as an example, and includes the following steps:

[0060] Step S302 : Acquire task information of a target task and an instruction data set including a plurality of instruction information.

[0061] The target task refers to a task that requires the construction of task instructions. In other words, this application constructs task instructions for the target task. The specific task type of the target task is not unique and can include, for example, text classification, sentiment analysis, or content review. The task information of the target task refers to information used to describe the target task. This task information can include, for example, information about at least one modality: speech, text, or images. In a specific embodiment, the task information can refer to the task context. Taking the sentiment analysis task as an example, the task information can include, for example, "Sentiment analysis task, requires analyzing the sentiment polarity (positive / neutral / negative) of <specified object>," or "Perform sentiment analysis on <specified object> and determine the sentiment polarity (positive / neutral / negative)," etc. The specified object can be specified text or a specified image. In one possible implementation, the specified image can be an image contained in a short video, or an image of a person or a landscape. In one possible embodiment, the specified text can be conversation text in a conversation analysis scenario, or image text in an image analysis scenario. For example, the conversation script in a conversation scenario can be used as the conversation text, or the conversation text can be obtained by converting the conversation audio into text. For example, the text information contained in the image can be extracted to obtain the image text; the annotation information for the image can also be used as the image text; and the text information obtained by performing image semantic analysis on the image can also be used as the image text.

[0062] Instruction information refers to information that conforms to the grammatical structure of task instructions and can be used as candidate instructions for the input model. In the fields of computer science and natural language processing, text or questions are input to the machine learning model to guide the model to generate corresponding outputs. The input text or question is the instruction information, which can be a question, a sentence, a paragraph or a set of instructions. The purpose is to guide the model to produce a specific answer or generate a specific type of text. Furthermore, the data source of the instruction information may include network data, public data sets, and editorial writing. For example, the terminal can collect a large amount of raw data by crawling or downloading data, and then obtain an instruction data set containing multiple instruction information.

[0063] Specifically, the terminal can obtain the task information of the target task and an instruction data set containing multiple instruction information. The task information can be input into the terminal by the business personnel, or obtained by the terminal from other devices. The other devices may be, for example, servers or other terminals. In a specific embodiment, the present application can be applied to the construction of task instructions for specific target tasks. In this case, the task information of the target task can be provided to the terminal by the business personnel. In a specific embodiment, the present application can be applied to instruction engineering, that is, corresponding task instructions are constructed for multiple target tasks respectively. In this case, each target task can constitute a task set, and the terminal can sequentially take out different target tasks from the task set, obtain the task information of the target task, and construct the task instruction for the target task, thereby completing the construction of the task instruction for the task set.

[0064] Step S304: perform semantic analysis on the task information to determine the task type and task requirements of the target task.

[0065] Among them, the task type refers to the type of problem that the task is to solve. Specifically for this application, the task type can be, for example, a sentiment analysis task, an image understanding task, or a problem finding task, etc. The task requirement refers to the specific requirements of the task, that is, the purpose expected to be achieved by performing the task. Specifically, the terminal can determine the task type and task requirement of the target task by performing semantic analysis on the task information. Optionally, the terminal can extract type information and requirement information from the task information by performing semantic analysis on the task information, and further determine the character type represented by the type information and the task requirement represented by the requirement information. For example, when the task information is "sentiment analysis task, it is necessary to analyze the sentiment polarity of <specified text> (positive / neutral / negative)" or "perform sentiment analysis on <specified text> and determine the sentiment polarity (positive / neutral / negative)", the type information can include, for example, "sentiment analysis", the task type can be, for example, "sentiment analysis task", the requirement information can include, for example, "analyze the sentiment polarity of <specified text>", "determine sentiment polarity", and the task requirement can be, for example, "determine the sentiment polarity of <specified text> (positive / neutral / negative)". For another example, when the task information is "image recognition task, it is necessary to analyze whether <specified image> contains vehicle A" or "perform image recognition on <specified image> to determine whether it contains vehicle A", the type information may include "image recognition", the task type may be "image recognition task", and the requirement information may include "analyze whether <specified image> contains vehicle A", "determine whether it contains vehicle A", and the task requirement may be "determine whether <specified image> contains vehicle A".

[0066] In a specific embodiment, semantic analysis is performed on task information to determine the task type of the target task, including: obtaining multiple candidate task types; performing semantic analysis on the task information to determine the task semantics of the task information; determining the semantic similarity between each candidate task type and the task semantics; and determining the candidate task type with the highest semantic similarity as the task type of the target task.

[0067] Among them, the candidate task type is the task type that serves as a candidate. In practical applications, multiple candidate task types can be determined based on the common application scenarios of the model. For example, in the field of natural language processing, text classification, sentiment analysis, dialogue question and answer, etc. can be used as candidate task types; for the field of image processing, image classification, image recognition, image detection, etc. can be used as candidate task types. Semantic analysis is a method of analyzing semantic information based on natural language, which can specifically include lexical analysis, syntactic analysis, pragmatic analysis, contextual analysis, etc. Semantic similarity is used to characterize the semantic similarity between the candidate task type and the task information. The specific algorithm for calculating semantic similarity is not unique, for example, it can be cosine similarity, Euclidean distance, edit distance or Hamming distance, etc.

[0068] Specifically, after determining the task information of the target task, the terminal can determine the task type of the target task from multiple candidate task types. On the one hand, the terminal can obtain multiple candidate task types, and on the other hand, the terminal can also perform semantic analysis on the task information to determine the task semantics of the task information. Then, the terminal can calculate the semantic similarity between the candidate task type and the task semantics for each candidate task type, and finally determine the candidate task type with the highest semantic similarity as the task type of the target task. Exemplarily, the terminal can perform semantic analysis on the candidate task type to determine the candidate semantics of the candidate task type, and then calculate the similarity between the candidate semantics and the task semantics to obtain the semantic similarity between the candidate task type and the task semantics.

[0069] It should be noted that there is no single method for semantically analyzing task information. Optionally, the terminal can use a dictionary to automatically segment and tag the task information through lexical and syntactic analysis, enabling the terminal to understand the task information and determine its task semantics. Alternatively, the terminal can pre-configure a semantic model, input the feature representation of the task information into the semantic model, and determine the task semantics of the task information based on the output.

[0070] In this embodiment, by calculating the semantic similarity between task information and candidate task types, the candidate task type with the highest semantic similarity is determined as the task type of the target task, which can simplify the task type determination process and help further improve work efficiency.

[0071] Step S306 , using query information adapted to the task type, guides the large model to filter out candidate instructions that match the task type from the instruction data set.

[0072] Among them, the large model, also known as the pre-training model or cornerstone model, refers to a deep learning model with large-scale model parameters, which usually contains hundreds of millions, tens of billions, or even hundreds of billions of model parameters. The specific types of large models are not unique. For example, they can include large language models (LLM), large visual models, and large audio models, etc. Query information refers to information that guides the large model to perform instruction screening in the form of inquiries. It can be understood that the sentence structure of the query information is a question sentence, and the specific content of the query information may include asking whether the instruction information matches the task type. That is, the query information is specifically used to inquire whether the instruction information matches the task type.

[0073] Adapting the query information to the task type means that the query information contains keywords that represent the task type. For example, if the task type is "sentiment analysis task", the keyword that represents the task type is "sentiment analysis". In this case, the query information that is adapted to the task information may be "Can this instruction complete the sentiment analysis task?" or "Can this instruction guide the model to perform sentiment analysis?". If the task type is "image recognition task", the keyword that represents the task type is "image recognition". In this case, the query information that is adapted to the task information may be "Can this instruction complete the image recognition task?" or "Can this instruction guide the model to perform image recognition?".

[0074] Specifically, the terminal may determine query information based on the task type, and use the query information to guide the large model to perform matching analysis on the instruction information and the task type, thereby screening out candidate instructions that match the task type from the instruction data set.

[0075] In a specific embodiment, the terminal can obtain an information template of the query information, which includes task type information. Then, the terminal can replace the task type information with the task type of the target task to obtain the query information corresponding to the target task. Exemplarily, the information template of the query information can be, for example, "Can the following instructions perform Class A tasks?" or "Do the following instructions match Class A tasks?", where "Class A tasks" is the task type information. Thus, when the task type of the target task is a sentiment analysis task, the query information can be "Can the following instruction information perform the sentiment analysis task?" or "Do the following instructions match the sentiment analysis task?"; when the task type of the target task is an image recognition task, the query information can be "Can the following instruction information perform the image recognition task?" or "Do the following instructions match the image recognition task?". The image recognition task can specifically be to identify whether the target image is contained in the image. The target image can be, for example, image information of a target person or a target vehicle, etc. For example, in a vehicle networking scenario, it may be necessary to detect the location information of the target vehicle. Thus, by constructing corresponding task instructions, the large model can be guided to perform image recognition on a large number of traffic images, filter out traffic images containing the target vehicle, and further determine the location information of the target vehicle based on the traffic images containing the target vehicle.

[0076] It can be understood that since the large model has passed pre-training and has a certain understanding ability, it can complete the initial screening of instruction information by constructing query information through task type, and filter out candidate instructions that match the task type from multiple instruction data.

[0077] Taking the sentiment analysis task as an example, for the following three instruction information:

[0078] Instruction 1: "Please judge the sentiment polarity (positive / neutral / negative) of <sentence>"

[0079] Instruction message 2, "Is <sentence> positive or negative?";

[0080] Instruction message 3, “Help me do a small task and change the sentence to a positive one.”

[0081] For the above three instruction information, we can construct the query information "Can this instruction complete the sentiment analysis task?" and input it into the big model together with the instruction information. If the result returned by instruction information 1 is "yes", the result returned by instruction information 2 is "yes", and the result returned by instruction information 3 is "no", then instruction information 1 and instruction information 2 can be used as candidate instructions because they match the task type and continue to be screened subsequently. Instruction information 3 does not match the task type and needs to be discarded in this round of screening.

[0082] Step S308 : Determine a task instruction that meets the task requirement from the candidate instructions.

[0083] Among them, the task instructions are used to guide the large model to perform the target task. As mentioned above, the task type refers to the type of problem to be solved by the task, and the task requirement refers to the specific requirements of the task. That is to say, relatively speaking, the task type is a coarse-grained description of the task, and the task requirement is a fine-grained description of the task. Specifically, based on the task type, query information is constructed to guide the large model to complete the preliminary screening of instruction information. After obtaining the candidate instructions, it is necessary to further screen the task instructions from the candidate instructions. In this case, the screening target can be determined based on the task requirements, and then the task instructions that meet the task requirements can be screened from the candidate instructions. For example, the task instructions that meet the task requirements can be determined from the candidate instructions by manual labeling; the trained classification model can also be used to determine the task instructions that meet the task requirements from the candidate instructions; and the task requirements and candidate instructions can also be analyzed for semantic similarity, and the candidate instructions whose semantic similarity meets similar conditions can be determined as task instructions that meet the task requirements.

[0084] Taking the sentiment analysis task as an example, if the task requirement is "need to analyze the sentiment polarity (positive / neutral / negative) of the specified text," the two candidate instructions, "Please determine the sentiment polarity (positive / neutral / negative) for <sentence>" and "Is <sentence> positive or negative?", are not considered the target task instruction because the task requirement is a three-category task, while "Is <sentence> positive or negative?" is described as a two-category task (positive / negative). This does not meet the task requirement and therefore cannot be used as the target task instruction. In other words, for the aforementioned instruction information 1, instruction information 2, and instruction information 3, the final task instruction is instruction information 1.

[0085] The above-mentioned task instruction construction method obtains task information for a target task and an instruction dataset containing multiple instruction information; performs semantic analysis on the task information to determine the task type and task requirements of the target task; uses query information adapted to the task type to guide the large model to filter candidate instructions matching the task type from the instruction dataset; and determines, from each candidate instruction, a task instruction that meets the task requirements; wherein the task instruction is used to guide the large model to execute the target task. During the task instruction construction process, the large model is used to initially screen the instructions to obtain candidate instructions matching the task type, and then a secondary screening is performed based on the task requirements to obtain the task instruction. Using this method, on the one hand, it can automatically generate task instructions while ensuring the matching degree between the task instructions and the target task, which is conducive to improving the work efficiency during the task instruction construction process. On the other hand, by first screening the candidate instructions based on the coarse-grained task type, and then performing a secondary screening based on the fine-grained task requirements to obtain the task instruction, the workload of fine-grained screening can be reduced, and the work efficiency during the task instruction construction process can also be improved. Therefore, using this task instruction construction method can improve the work efficiency during the task instruction construction process, construct a large number of task instructions, and provide a foundation for the implementation of the large model.

[0086] In one embodiment, the task instruction construction method further includes: determining a target instruction set matching the target task from a plurality of candidate instruction sets based on the task requirements of the target task; and adding the task instruction to the target instruction set.

[0087] It can be understood that since task requirements refer to the specific requirements of the task, the task requirements of different tasks are usually different. That is, the task requirements correspond to the tasks one by one. Specifically, corresponding instruction sets can be configured for different tasks, and the instruction sets are used to store the task instructions of the corresponding tasks. In other words, for the target task, multiple task instructions corresponding to the target task can be constructed, and these task instructions can provide the large model with diversified instruction expressions for the target task to ensure that the large model can complete the target task with high quality under the guidance of the task instructions. In this embodiment, multiple task instructions for the same target task can be stored in the same target instruction set.

[0088] In a specific embodiment, the terminal can pre-configure the correspondence between task requirements and candidate instruction sets, and then, based on the task requirements of the target task and the correspondence between the task requirements and the candidate instruction sets, determine the target instruction set that matches the target task from multiple candidate instruction sets, and then add the constructed task instructions to the target instruction set.

[0089] In the above embodiment, corresponding target instruction sets are established for different target tasks, which can complete the batch construction of large model instruction sets and facilitate the rapid acquisition of required task instructions from the corresponding instruction sets according to different application requirements during the application process, which is conducive to further improving work efficiency.

[0090] In one embodiment, query information adapted to the task type is used to guide the large model to filter out candidate instructions that match the task type from the instruction data set, including: determining query information adapted to the task type; for each instruction information, combining the instruction information and the query information, determining input information that matches the instruction information; inputting the input information into the large model, and determining the instruction information as a candidate instruction when the output information of the large model indicates that the instruction information matches the task type.

[0091] Specifically, the terminal can perform keyword extraction on the task type of the target task, determine the keyword that characterizes the task type, and further determine the query information containing the keyword to ensure that the query information is adapted to the task type. Then, for each instruction information in the instruction data set, the instruction information and the query information are combined to determine the input information that matches the instruction information. Next, the terminal inputs the input information into the large model, so that the large model outputs a judgment result for the instruction information under the guidance of the query information. The judgment result may include that the instruction information matches the task type, and that the instruction information does not match the task type. Finally, when the output information of the large model characterizes that the instruction information matches the task type, the terminal determines the instruction information as a candidate instruction.

[0092] For example, the output information of the large model may include "yes" and "no," where "yes" indicates that the instruction information matches the task type, and "no" indicates that the instruction information does not match the task type. Thus, if the output information of the large model is "yes," the terminal may determine the instruction information as a candidate instruction, and if the output information is "no," the terminal may discard the instruction information.

[0093] In this embodiment, the query information that is suitable for the task type is first determined, and then the instruction information is combined with the query information to obtain the input information for the instruction information, so that the large model outputs the judgment result for the instruction information under the guidance of the query information. This is equivalent to being able to complete the screening of multiple instruction information based on the same query information, which is conducive to further improving work efficiency.

[0094] It should be noted that, based on the instruction information and the query information, there is no unique way to determine the input information that matches the instruction information.

[0095] In a specific embodiment, for the same target task, for the first instruction information, the terminal can splice the instruction information and the query information to determine the input information that matches the instruction information; for subsequent instruction information, the terminal can replace the instruction information contained in the previous input information with the current instruction information to obtain input information that matches the current instruction information.

[0096] In a specific embodiment, for each instruction, the terminal can determine the input information that matches the instruction by combining the instruction and the query. For example, in the sentiment analysis task, if the query is "Can this instruction complete the sentiment analysis task?", the input information might be "'Command A', can this instruction complete the sentiment analysis task?"

[0097] In a specific embodiment, combining the instruction information and the query information to determine the input information that matches the instruction information includes: determining the insertion position of the instruction information in the query information; inserting the instruction information into the query information according to the insertion position to obtain the input information that matches the instruction information.

[0098] Specifically, the query information includes associated information about the instruction information. For example, if the query information is "Can this instruction complete the sentiment analysis task?", the associated information about the instruction information is "this instruction." Therefore, based on the location of the associated information in the query information, the terminal can determine the insertion position of the instruction information in the query information. The instruction information is then inserted into the query information according to the insertion position, obtaining input information that matches the instruction information.

[0099] In an optional embodiment, the instruction information can be inserted at the same location as the associated information or at a location adjacent to the associated information. For example, if the query is "Can this instruction complete the sentiment analysis task?", the instruction information 'Instruction A' can be inserted at the same location as the associated information "This instruction," resulting in the input information being "Can 'Instruction A' complete the sentiment analysis task?"; or if the instruction information 'Instruction A' is inserted at a location adjacent to the associated information "This instruction," resulting in the input information being "Can 'Instruction A' complete the sentiment analysis task?"

[0100] In this embodiment, the insertion position of the instruction information is first determined in the query information, and then the instruction information is inserted into the query information according to the insertion position to obtain input information that matches the instruction information. By only determining the insertion position once, the insertion information that matches the instruction information can be quickly generated, which is conducive to further improving work efficiency.

[0101] In one embodiment, the large model includes an encoder and a decoder. In this embodiment, input information is input into the large model, and when the output information of the large model indicates that the instruction information matches the task type, the instruction information is determined as a candidate instruction, including: extracting features from the input information to obtain information features of the input information; inputting the information features into the encoder so that the encoder encodes the information features to obtain a hidden layer representation of the information features; and when the output information of the decoder indicates that the instruction information matches the task type, determining the instruction information as a candidate instruction.

[0102] Among them, the large model can be implemented based on the encoder-decoder structure. By inputting the input information into the encoding network, the feature extraction result of the encoding network for the input information, that is, the encoding information, can be obtained. By inputting the encoding information into the decoding network, the output information output by the decoding network can be obtained. This output information is the prediction information corresponding to the input information. The encoding network and the decoding network are both N-layer structures. The encoding network is a cascade structure of N encoders, and the decoding network is a cascade structure of N decoders. The structure of each layer of the encoding network is consistent, and the structure of each layer in the decoding network is consistent, and the structure of each layer in the encoding network is similar to that of the decoding network. The original input of the decoder is the information feature of the input information, and the intermediate layer input of the decoder is the hidden layer representation of the information feature.

[0103] For example, as shown in Figure 4, the encoder structure of the transformer can be referred to. The encoder of each layer includes: a multi-head self-attention module (Multi-Head Self-Attention Module), that is, the "self-attention mechanism" in the encoder structure of Figure 4; a feedforward fully connected network, that is, the "feedforward network" (Feed Forward Network, FFN) in Figure 4; each of the above modules (multi-head self-attention module, feedforward fully connected module) is followed by a residual connection and layer normalization (LayerNorm) layer, that is, the "addition & normalization" (Add&Norm) in Figure 4.

[0104] Exemplarily, as shown in Figure 5, each layer of the decoder includes: a mask multi-head self-attention module (Mask Multi-Head Self-Attention Module, which can be regarded as a multi-head self-attention module), that is, the "self-attention mechanism" below the decoder in Figure 5; a cross-encoder and decoder self-attention module (also called a cross self-attention module (Cross Self-Attention Module), which can be regarded as a multi-head self-attention module), that is, the "self-attention mechanism" in the middle of the decoder in Figure 5; and a feedforward fully connected module, that is, the "feedforward network" above the decoder in Figure 5; after each of the above self-attention modules, there is a residual connection and layer normalization layer, that is, the "sum & normalization" in Figure 5.

[0105] Residual connections can be viewed as a structure that allows the output of one model module to serve as the input to a subsequent, non-adjacent module, reducing model complexity and preventing vanishing gradients. Layer normalization layers are used to normalize input information, such as by applying normalization. Both residual connections and layer normalization layers are used to stabilize model training.

[0106] Specifically, the terminal can extract features from the input information to obtain information features. This information feature is the vectorized representation of the input information. The information features are then input into the encoder, which encodes the information features to obtain a hidden layer representation of the information features. Finally, the terminal uses the information features as the raw input to the decoder and the hidden layer representation as the intermediate layer input to the decoder. If the decoder's output information indicates that the instruction information matches the task type, the terminal identifies the instruction as a candidate instruction.

[0107] In a specific embodiment, the encoder processing includes the following steps:

[0108] Step a: Apply the self-attention mechanism. The calculation method of the self-attention mechanism is:

[0109] Where Q is the vector representation of the input information. For example, if the input information is "'Command A', whether this command can complete the sentiment analysis task," Q is its vector representation. In the self-attention mechanism, K = Q and V = Q.

[0110] In step b, following the principle of residual networks, the output of the self-attention mechanism is added to the original input vector to enhance the original information and normalized. The normalized result x1 is Norm(Q + Attention(Q, K, V)), where Norm is the normalization function.

[0111] In step c, the normalized result is output to the feedforward network for further calculation to fully integrate the information. The output of the feedforward network is Feed_forward(x1), where Feed_forward is the calculation unit of the feedforward network.

[0112] In step d, referring to the idea of ​​the residual network, the calculation result of the feedforward network in step c is added to the original input information and normalized, that is, Norm(x1+Feed_forward(x1)). The output of step d is the final output of the encoder.

[0113] In this embodiment, the number of encoder layers is 6, that is, N = 6. The final output of the encoder is the value of the hidden layer parameters e and σ (the hidden layer calculation method between the encoder and decoder). In the present application scheme, σ = e, that is, the hidden layer parameter e is the same as the corresponding perturbation weight parameter σ.

[0114] In a specific embodiment, after the encoder calculation is completed, the encoder output is passed through the hidden layer calculation method between the encoder and decoder to obtain a new hidden layer representation as the input of the decoder intermediate layer. The decoder processing process includes the following steps:

[0115] Step a: Process the autoencoder input. The formula is the same as in step a of the encoder. Apply the self-attention mechanism to the decoder input. Optionally, the decoder can generate output word by word.

[0116] Step b: Sum and normalize. The calculation formula is the same as step b of the encoder. The output of step a and the vector representation of the original input are summed and normalized.

[0117] In step c, the hidden layer representation is fused with the decoder input information. Using the self-attention mechanism (the calculation formula is the same as in step a), the final hidden layer representation obtained by outputting the encoder to the hidden layer is used as the Q and K values ​​of the self-attention mechanism, and the output of the previous step (step b) is used as the value of V.

[0118] Step d, summing and normalizing. The calculation formula is the same as step b. The vector representation obtained by fusing the hidden layer representation with the decoder input information (step c) is summed and normalized with the vector representation before fusion (step b).

[0119] In step e, the final information fusion result is subjected to deep computation using the same formula as in step c of the encoder. The final fused information (the output of step e) is passed through a softmax classifier to predict the character probabilities (i.e., normalized) and predict the next generated character. The softmax classifier formula is as follows, where w is the model parameter (trained by the model), C is the vocabulary size, and p(y|x) is the probability that the softmax classification prediction output is y, given the output x of the feedforward network.

[0120] For example, let's take the case where the input is "Can the instruction <instruction a> complete the sentiment analysis task? Please answer 'yes' or 'no'." The instruction to be determined is "Please determine the sentiment polarity (positive / neutral / negative) of the sentence <sentence>." The final encoder input is: "Can the instruction <instruction a> complete the sentiment analysis task? Please answer 'yes' or 'no'." The large model candidate generation result (e.g., "yes") is generated using the beam search parameter beam_number = 1, as shown below:

[0121] The encoder encodes the original input according to the above steps to obtain a hidden layer representation, which is then fed into the decoder's self-attention mechanism. The decoder takes the start symbol ([CLS]) as its initial input and outputs the result with the highest probability, which is the character "yes". The decoder then concatenates the input and output characters from the previous step ("[CLS] is") and outputs the result with the highest probability, which is the terminator "[EOS]", indicating the end of generation. Generation ends when the decoder outputs the terminator. Finally, post-processing is performed to remove the start symbol [CLS] and the terminator [EOS], resulting in the final result "yes".

[0122] The above is an example process of the instruction information "Please judge the sentiment polarity (positive / neutral / negative) of <sentence>" obtaining the prediction result "yes" after passing through the large model.

[0123] In the above embodiment, a large model including an encoder and a decoder is adopted, and the hidden layer representation output by the encoder is used as the intermediate layer input of the decoder, which can ensure the full integration of information and is conducive to improving the accuracy of the screening results.

[0124] In one embodiment, determining a task instruction that meets the task requirements from each candidate instruction includes: obtaining annotation information for the candidate instruction; and determining the candidate instruction to which the annotation information belongs as the task instruction of the target task when the matching degree represented by the annotation information meets the matching condition.

[0125] Among them, the annotation information is used to characterize the matching degree between the candidate instruction and the task requirement. The specific form of the annotation information may include at least one of text, symbols or numbers. The matching degree meets the matching conditions, which may mean that the matching degree is greater than or equal to the matching degree threshold. Optionally, the annotation information may include "yes" and "no", wherein "yes" represents that the matching degree between the candidate instruction and the task requirement meets the matching conditions, and "no" represents that the matching degree between the candidate instruction and the task requirement does not meet the matching conditions. Optionally, the annotation information may be a number in the value range of [0,1], and the larger the number, the higher the matching degree.

[0126] Specifically, the terminal can obtain annotation information for the candidate instruction, and when the matching degree represented by the annotation information meets the matching conditions, determine the candidate instruction to which the annotation information belongs as the task instruction of the target task; when the matching degree represented by the annotation information does not meet the matching conditions, discard the candidate instruction to which the annotation information belongs.

[0127] For example, as shown in FIG6 , a specific method for obtaining annotation information can be manual annotation. For example, if the task information is "Sentiment analysis task, the sentiment polarity of <specified text> needs to be analyzed (positive / neutral / negative)", then the task type is "Sentiment analysis task" and the task requirement is "The sentiment polarity of <specified text> needs to be analyzed (positive / neutral / negative)". In this case, after collecting the instruction information, the terminal can determine the query information that matches the task type, "Can the following instructions perform the sentiment analysis task?", and combine the query information and instruction information to determine the input information of the large model. In the initial screening stage of the large model, if the output of the large model is "yes", the instruction information is determined as a candidate instruction; otherwise, the instruction information is discarded. The secondary confirmation stage then begins. Specifically, business personnel can manually annotate the candidate instructions retained in the initial screening stage based on the task requirements to determine whether the candidate instructions meet the task requirements (i.e., the task requirements). Candidate instructions that meet the task requirements are determined as task instructions for the target task, and candidate instructions that do not meet the task requirements are discarded. Finally, the task instructions for the target task are stored.

[0128] In the above embodiment, candidate instructions are screened a second time based on the annotation information to obtain task instructions. Thanks to the relatively high accuracy of the annotation information, the accuracy of the task instructions obtained by the secondary screening can be ensured.

[0129] In one embodiment, the task instruction construction method also includes: determining labeled instructions carrying labeling information from each candidate instruction that matches the task type; when the number of labeled instructions meets the quantity condition, training the initial model based on each labeled instruction to obtain a classification model that matches the task requirements.

[0130] Among them, the classification model is used to classify candidate instructions that match the task type and do not carry annotation information, and determine the task instructions that meet the task requirements. Specifically, if manual annotation is used, a large amount of manpower is required. In order to enable the process to be implemented automatically, the process can be automated by building a classification model. Based on this, the terminal can first screen the task instructions based on the annotation method. As time goes by, more and more annotation information is obtained. When the number of annotation information obtained meets the quantity conditions, the terminal can train the initial model based on each labeled instruction carrying the annotation information to obtain a classification model that matches the task requirements. Among them, the number of annotation information obtained is equal to the number of labeled instructions.

[0131] In other words, during the batch construction of task instructions, as shown in Figure 6, a portion of the instruction information can be filtered through annotation, simultaneously obtaining training samples for the classification model. When the number of training samples is sufficient, as shown in Figure 7, the initial model can be trained using the training samples to obtain a classification model that matches the task requirements. Subsequently, as shown in Figure 8, the classification model can be filtered and replaced with annotations to complete the screening from candidate instructions to task instructions.

[0132] In the above embodiment, when the amount of acquired annotation information meets the quantity condition, the initial model is trained based on each candidate instruction carrying annotation information to obtain a classification model that matches the task requirements, which is used to classify candidate instructions that match the task type and do not carry annotation information. This can realize fully automatic task instruction construction, which is conducive to further improving work efficiency.

[0133] In a specific embodiment, the terminal may use a classification model to determine the probability that a candidate instruction meets the task requirement; and determine a candidate instruction with a probability greater than or equal to a probability threshold as a task instruction that meets the task requirement.

[0134] In a specific embodiment, the initial model is trained based on each candidate instruction carrying labeled information to obtain a classification model that matches the task requirements, including: constructing a training set containing positive samples and negative samples; using the training set to train the initial model to obtain a classification model that matches the task requirements.

[0135] Positive samples include labeled instructions whose matching degree meets the matching conditions, while negative samples include labeled instructions whose matching degree does not meet the matching conditions. Specifically, the classification model can be a binary classification model. Thus, the terminal can use candidate instructions whose matching degree meets the matching conditions as positive samples and candidate instructions whose matching degree does not meet the matching conditions as negative samples, construct a training set containing positive and negative samples, and then use the training set to train the initial model to obtain a classification model that matches the task requirements. Furthermore, the terminal can use few-shot learning to train the classification model. In traditional machine learning and deep learning, model performance is generally proportional to the number of training samples. This means that a large amount of labeled data is usually required to train the model. However, in the real world, obtaining large amounts of labeled data is not always feasible, as labeling data can require significant human, material, and time resources. Few-shot learning attempts to address this issue, enabling the model to effectively learn even with only a small number of training samples.

[0136] In the above embodiment, a binary classification model is used to screen candidate instructions to obtain task instructions, which can simplify the process of constructing a sample set and help further improve work efficiency.

[0137] In one possible implementation, a binary classification model is used to determine the probability that a candidate instruction meets the task requirements, including: extracting features from the candidate instruction to obtain instruction features of the candidate instruction; using the instruction features as input to the binary classification model, and determining the output of the binary classification model as the probability that the candidate instruction meets the task requirements.

[0138] Among them, the corresponding formula for the two-class model is: h θ (x) = g(θ T x)

[0139] Among them, x is the vector representation of the corresponding candidate instruction, θ T is the parameter of the binary classification model to be trained, g(z) is the normalization function, and the output is normalized to (0,1), which is the probability that the candidate instruction meets the task requirements.

[0140] In one embodiment, the task instruction construction method also includes: performing a performance test on the classification model; if the performance test result of the classification model does not match the expected performance, returning to the step of obtaining labeling information for the candidate instructions, and using the obtained labeling information to optimize the classification model until the performance test result of the classification model matches the expected performance; if the performance test result of the classification model matches the expected performance, using the classification model to classify the candidate instructions that do not carry labeling information to determine the task instructions that meet the task requirements.

[0141] Specific methods for performance testing classification models include accuracy testing and robustness analysis. Robustness can be understood as the model's tolerance for data variations. A model is considered robust if minor data deviations or perturbations within the model have only a minor impact on the model output and still produce correct results. Expected performance corresponds to the performance test results and can be characterized by an accuracy threshold or a robustness threshold. For example, if the performance test results include accuracy, the expected performance can include an accuracy greater than or equal to the accuracy threshold.

[0142] After the classification model is trained, the terminal can perform a performance test on the classification model and determine whether to use the classification model instead of the labeling based on the performance test results to complete the screening of candidate instructions. Specifically, if the performance test results of the classification model do not match the expected performance, continue to use the construction process shown in Figure 6, return to the step of obtaining the labeling information for the candidate instructions, and use the obtained labeling information to optimize the classification model until the performance test results of the classification model match the expected performance. If the performance test results of the classification model match the expected performance, use the construction process shown in Figure 8 to use the classification model to classify the candidate instructions that match the task type and do not carry labeling information, and determine the task instructions that meet the task requirements.

[0143] In a specific embodiment, the classification model is optimized using the acquired annotation information, including: taking candidate instructions with a matching degree greater than or equal to a set matching degree as positive samples, and taking candidate instructions with a matching degree less than or equal to a predetermined matching degree as negative samples, and using a training set containing positive samples and negative samples to perform incremental training on the classification model to obtain an updated classification model.

[0144] In practical applications, the training set can also be optimized based on the performance test results of the classification model. As previously mentioned, the degree of match meeting the matching condition can mean that the degree of match is greater than or equal to the matching threshold. Therefore, if there is sufficient training data but the resulting classification model performance is poor, the matching threshold can be appropriately increased to improve the training effect. In other words, the matching degree is set to be greater than the matching threshold, and the predetermined matching degree is less than the matching threshold.

[0145] In the above embodiment, after the classification model is trained, the classification model is also subjected to performance testing, and is put online only when it meets the expected performance, thereby ensuring the accuracy of the task instructions determined using the classification model.

[0146] In one embodiment, as shown in FIG9 , a method for constructing a task instruction is provided. The method may be executed by a computer device, which may be a terminal or a server as shown in FIG1 . Taking the computer device as an example, in this embodiment, the method includes the following steps:

[0147] Step S901, obtaining task information of a target task and an instruction data set including multiple instruction information;

[0148] Step S902: Perform semantic analysis on the task information to determine the task type and task requirements of the target task;

[0149] Step S903, determining query information that is suitable for the task type;

[0150] Step S904, determining the insertion position of the instruction information in the query information;

[0151] Step S905: for each instruction information, insert the instruction information into the query information according to the insertion position to obtain input information matching the instruction information;

[0152] Step S906: extracting features from the input information to obtain information features of the input information;

[0153] Step S907: input the information feature into the encoder so that the encoder encodes the information feature to obtain a hidden layer representation of the information feature;

[0154] Step S908: Using the information features as the original input of the decoder and the hidden layer representation as the intermediate layer input of the decoder, if the output information of the decoder indicates that the instruction information matches the task type, the instruction information is determined as a candidate instruction;

[0155] Step S909, obtaining annotation information for the candidate instruction;

[0156] The annotation information is used to characterize the matching degree between the candidate instructions and the task requirements; the annotated instructions carrying the annotation information are at least a part of each candidate instruction;

[0157] Step S910: If the matching degree represented by the annotation information satisfies the matching condition, the candidate instruction to which the annotation information belongs is determined as the task instruction of the target task;

[0158] Step S911: When the number of labeled instructions meets the quantity condition, construct a training set including positive samples and negative samples;

[0159] Among them, the positive samples include the labeled instructions whose matching degree meets the matching conditions; the negative samples include the labeled instructions whose matching degree does not meet the matching conditions;

[0160] Step S912: Use the training set to train the initial model to obtain a classification model that matches the task requirements;

[0161] Step S913, performing performance testing on the classification model;

[0162] Step S914: If the performance test result of the classification model does not match the expected performance, return to the step of obtaining annotation information for the candidate instruction, and use the obtained annotation information to optimize the classification model until the performance test result of the classification model matches the expected performance;

[0163] Step S915: If the performance test result of the classification model matches the expected performance, the classification model is used to classify the candidate instructions that do not carry the annotation information to determine the task instructions that meet the task requirements;

[0164] Step S916 , based on the task requirements of the target task, determining a target instruction set that matches the target task from multiple candidate instruction sets, and adding the task instructions to the target instruction set;

[0165] Among them, the target instruction set is used to provide diversified instruction descriptions for the target task to guide the large model to perform the target task.

[0166] During the above-mentioned task instruction construction process, the large model is used to initially screen instructions to obtain candidate instructions that match the task type, and then a secondary screening is performed based on the task requirements to obtain task instructions. On the one hand, it can ensure the matching degree between the task instructions and the target task while realizing the automatic generation of task instructions, which is conducive to improving the work efficiency in the task instruction construction process; on the other hand, a screening is first performed based on the coarser-grained task type to obtain candidate instructions, and then a secondary screening is performed based on the finer-grained task requirements to obtain task instructions, thereby reducing the workload of fine-grained screening and also improving the work efficiency in the task instruction construction process. Therefore, the above-mentioned task instruction construction method can improve the work efficiency in the task instruction construction process, construct a large number of task instructions, and provide a foundation for the implementation of the large model.

[0167] In one embodiment, as shown in FIG10 , the present application further provides a task processing method. The method may be executed by a computer device, which may be the terminal or server shown in FIG1 . In this embodiment, the method is described by taking the terminal in FIG1 as an example, and includes the following steps:

[0168] Step S1002: Obtaining the task requirements of the target task and the information to be processed for the target task;

[0169] Step S1004: based on the task requirements, reading the task instructions that match the target task from the instruction set;

[0170] Step S1006: input the information to be processed and the task instruction into the large model, so that the large model determines the processing result of the information to be processed according to the task requirements under the guidance of the task instruction.

[0171] Among them, the task instruction is constructed based on the above-mentioned task instruction construction method. The information to be processed of the target task refers to the information that needs to be processed in the process of executing the target task. This information may include, for example, at least one type of information such as text, audio or image. Exemplarily, when the task information of the target task is "emotional analysis task, it is necessary to analyze the emotional polarity (positive / neutral / negative) of <specified text>", the information to be processed is the specified text. If the task information of the target task is "image recognition task, it is necessary to analyze whether <specified image> contains a person image", the information to be processed is the specified image. The instruction set stores task instructions constructed for multiple target tasks.

[0172] Specifically, the terminal can obtain the task requirements of the target task and the information to be processed for the target task. Then, based on the task requirements, it reads the task instructions that match the target task from the instruction set and inputs the information to be processed and the task instructions into the big model. Under the guidance of the task instructions, the big model determines the processing result of the information to be processed according to the task requirements.

[0173] In a specific embodiment, the instruction set may include multiple target instruction sets. The terminal may construct at least one task instruction for each target task and store these task instructions in the target instruction set corresponding to the task requirements. Thus, during the application process, the terminal may determine the task requirements based on the task information, further determine the target instruction set for the target task, and then read the task instructions for the target task from the target instruction set.

[0174] The above-mentioned task processing method, during the construction process of the task instructions used, uses the large model to initially screen instructions to obtain candidate instructions that match the task type, and then further performs a secondary screening based on the task requirements to obtain task instructions. On the one hand, it can ensure the matching degree between the task instructions and the target tasks while realizing the automatic generation of task instructions, which is beneficial to improving the work efficiency in the task instruction construction process; on the other hand, it first performs a screening based on the coarser-grained task type to obtain candidate instructions, and then performs a secondary screening based on the finer-grained task requirements to obtain task instructions, thereby reducing the workload of fine-grained screening, and can also improve the work efficiency in the task instruction construction process, and can also ensure the effectiveness of the large model in executing tasks.

[0175] In a specific embodiment, as shown in Figure 11, the implementation process of the large model includes two stages: the task instruction construction stage, and the task processing stage based on the task instructions. In the first stage, task instructions corresponding to multiple target tasks can be constructed, and one target task can construct multiple task instructions, thereby obtaining an instruction set applied to the large model. The instruction set of the first stage can provide task instructions to the large model of the second stage. These task instructions can realize diversified instruction expressions and guide the large model to execute the target tasks corresponding to the task instructions.

[0176] Among them, the instruction set construction process may include the steps of candidate instruction mining, candidate instruction classification, task instruction effect testing and task instruction storage. The candidate instruction mining process may correspond to Figures 6 and 7, where a small number of candidate instructions carrying annotation information are obtained through manual labeling, and a binary classification model that matches the task requirements is obtained through training. The candidate instruction classification process may correspond to Figure 8. When the model performance of the binary classification model reaches the expected performance, the binary classification model is used instead of manual labeling to determine whether the candidate instructions meet the task requirements, and the candidate instructions that meet the task requirements are determined as task instructions. Furthermore, after obtaining the task instructions, the large model can be used to test the effect of the task instructions, and the task instructions with higher task execution effects are retained. Finally, the retained high-quality task instructions are stored in the instruction set for subsequent task execution.

[0177] It should be understood that, although the various steps in the flowcharts involved in the various embodiments described above are displayed in sequence according to the instructions of the arrows, these steps are not necessarily executed in sequence in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order restriction on the execution of these steps, and these steps can be executed in other orders. Moreover, at least a portion of the steps in the flowcharts involved in the various embodiments described above can include multiple steps or multiple stages, and these steps or stages are not necessarily executed and completed at the same time, but can be executed at different times, and the execution order of these steps or stages is not necessarily to be carried out in sequence, but can be executed in turn or alternately with other steps or at least a portion of steps or stages in other steps.

[0178] Based on the same inventive concept, the present application also provides a task instruction construction device for implementing the task instruction construction method described above. The solution provided by this device is similar to the solution described in the method described above. Therefore, the specific limitations of one or more of the following task instruction construction device embodiments can be found in the above-mentioned limitations of the task instruction construction method and will not be repeated here.

[0179] In one embodiment, as shown in FIG12 , a task instruction construction apparatus is provided, comprising: a task information acquisition module 1201 , a requirement determination module 1202 , a candidate instruction screening module 1203 , and a task instruction determination module 1204 , wherein:

[0180] The task information acquisition module 1201 is used to obtain the task information of the target task and the instruction data set including multiple instruction information;

[0181] The requirement determination module 1202 is used to perform semantic analysis on the task information to determine the task type and task requirements of the target task;

[0182] The candidate instruction screening module 1203 is used to use query information adapted to the task type to guide the large model to screen candidate instructions matching the task type from the instruction dataset; and

[0183] The task instruction determination module 1204 is used to determine the task instruction that meets the task requirements from various candidate instructions; the task instruction is used to guide the large model to perform the target task.

[0184] In one embodiment, the candidate instruction screening module 1203 includes: a query information determination unit, used to determine the query information that is adapted to the task type; an input information determination unit, used to determine, for each instruction information, the input information that matches the instruction information in combination with the instruction information and the query information; a candidate instruction screening unit, used to input the input information into the big model, and determine the instruction information as a candidate instruction when the output information of the big model indicates that the instruction information matches the task type.

[0185] In one embodiment, the input information determining unit is specifically configured to: determine an insertion position of the instruction information in the query information; and insert the instruction information into the query information according to the insertion position to obtain input information matching the instruction information.

[0186] In one embodiment, the large model includes an encoder and a decoder. In this embodiment, the candidate instruction screening unit is specifically configured to: extract features from input information to obtain information features of the input information; input the information features into the encoder so that the encoder encodes the information features to obtain a hidden layer representation of the information features; use the information features as the original input of the decoder, and use the hidden layer representation as the intermediate layer input of the decoder; and determine the instruction information as a candidate instruction if the decoder output information indicates that the instruction information matches the task type.

[0187] In one embodiment, the task instruction determination module 1204 includes: a label information acquisition unit configured to acquire label information for a candidate instruction; and a task instruction determination unit configured to determine the candidate instruction to which the label information belongs as the task instruction for the target task if the matching degree represented by the label information satisfies a matching condition. The label information is used to represent the matching degree between the candidate instruction and the task requirement.

[0188] In one embodiment, the task instruction construction device also includes a training module, which is used to: determine the labeled instructions carrying labeling information from each candidate instruction matching the task type; when the number of labeled instructions meets the quantity condition, train the initial model based on each labeled instruction to obtain a classification model matching the task requirements, and the classification model is used to classify candidate instructions that do not carry labeling information and determine task instructions that meet the task requirements.

[0189] In one embodiment, the training module is specifically used to: use each labeled instruction whose matching degree meets the matching conditions as a positive sample, and each labeled instruction whose matching degree does not meet the matching conditions as a negative sample, to construct a training set containing positive samples and negative samples; use the training set to train the initial model to obtain a classification model that matches the task requirements.

[0190] In one embodiment, the task instruction construction device also includes a performance testing module, which is used to: perform performance testing on the classification model; if the performance test result of the classification model does not match the expected performance, return to the step of obtaining labeling information for the candidate instructions, and use the obtained labeling information to optimize the classification model until the performance test result of the classification model matches the expected performance; if the performance test result of the classification model matches the expected performance, use the classification model to classify the candidate instructions that match the task type and do not carry labeling information to determine the task instructions that meet the task requirements.

[0191] In one embodiment, the demand determination module 1202 is specifically used to: obtain multiple candidate task types; perform semantic analysis on the task information to determine the task semantics of the task information; determine the semantic similarity between each candidate task type and the task semantics; and determine the candidate task type with the highest semantic similarity as the task type of the target task.

[0192] In one embodiment, the task instruction construction device further includes a storage module for: determining a target instruction set matching the target task from a plurality of candidate instruction sets based on the task requirements of the target task; and adding the task instruction to the target instruction set.

[0193] Based on the same inventive concept, embodiments of the present application also provide a task processing device for implementing the aforementioned task processing method. The implementation solution provided by this device is similar to the implementation solution described in the aforementioned method. Therefore, the specific limitations in one or more of the following task processing device embodiments can be found in the above-mentioned limitations on the task processing method and will not be further elaborated here.

[0194] In one embodiment, as shown in FIG13 , a task processing device is provided, comprising: a to-be-processed information acquisition module 1301 , a task instruction reading module 1302 , and a task processing module 1303 , wherein:

[0195] The to-be-processed information acquisition module 1301 is used to acquire the task requirements of the target task and the to-be-processed information for the target task;

[0196] The task instruction reading module 1302 is used to read the task instruction that matches the target task from the instruction set based on the task requirements; the task instruction is constructed by the task instruction construction device; and

[0197] The task processing module 1303 is used to input the information to be processed and the task instructions into the large model, so that the large model can determine the processing result of the information to be processed according to the task requirements under the guidance of the task instructions.

[0198] Each module in the task instruction construction device and task processing device can be implemented in whole or in part through software, hardware, or a combination thereof. Each module can be embedded in or independent of a processor in a computer device in the form of hardware, or can be stored in a memory in the computer device in the form of software, so that the processor can call and execute the corresponding operations of each module.

[0199] In one embodiment, a computer device is provided, which may be a server, and its internal structure diagram may be shown in Figure 14. The computer device includes one or more processors, memory, input / output (I / O) interfaces, and a communication interface. The processor, memory, and I / O interface are connected via a system bus, and the communication interface is connected to the system bus via the I / O interface. The processor of the computer device is used to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system, computer-readable instructions, and a database. The internal memory provides an environment for the operation of the operating system and computer-readable instructions in the non-volatile storage medium. The database of the computer device is used to store instruction information. The I / O interface of the computer device is used to exchange information between the processor and external devices. The communication interface of the computer device is used to communicate with external terminals via a network connection. When the computer-readable instructions are executed by one or more processors, a task instruction construction method or a task processing method is implemented.

[0200] In one embodiment, a computer device is provided, which may be a terminal. A diagram of its internal structure may be shown in FIG15 . The computer device includes one or more processors, memory, an input / output interface, a communication interface, a display unit, and an input device. The processor, memory, and input / output interface are connected via a system bus, and the communication interface, display unit, and input device are connected to the system bus via the input / output interface. The processor of the computer device is configured to provide computing and control capabilities. The memory of the computer device includes a non-volatile storage medium and an internal memory. The non-volatile storage medium stores an operating system and computer-readable instructions. The internal memory provides an environment for the operation of the operating system and computer-readable instructions in the non-volatile storage medium. The input / output interface of the computer device is configured to exchange information between the processor and an external device. The communication interface of the computer device is configured to communicate with an external terminal via wired or wireless communication, where the wireless communication may be achieved via Wi-Fi, a mobile cellular network, NFC (near-field communication), or other technologies. When executed by one or more processors, the computer-readable instructions implement a task instruction construction method or a task processing method. The display unit of the computer device is used to form a visually visible image, and can be a display screen, a projection device or a virtual reality imaging device. The display screen can be a liquid crystal display screen or an electronic ink display screen. The input device of the computer device can be a touch layer covering the display screen, or a button, trackball or touchpad set on the computer device casing, or an external keyboard, touchpad or mouse, etc.

[0201] Those skilled in the art will understand that the structure shown in Figures 14 or 15 is merely a block diagram of a partial structure related to the solution of the present application, and does not constitute a limitation on the computer device to which the solution of the present application is applied. The specific computer device may include more or fewer components than shown in the figure, or combine certain components, or have a different component arrangement.

[0202] In one embodiment, a computer device is provided, including a memory and one or more processors, wherein the memory stores computer-readable instructions, and the one or more processors implement the steps of the above-mentioned method embodiments when executing the computer-readable instructions.

[0203] In one embodiment, a computer-readable storage medium is provided, on which computer-readable instructions are stored. When the computer-readable instructions are executed by one or more processors, the steps in the above-mentioned method embodiments are implemented.

[0204] In one embodiment, a computer program product is provided, comprising computer-readable instructions, which implement the steps of the above-mentioned method embodiments when executed by one or more processors.

[0205] It should be noted that the user information (including but not limited to user device information, user personal information, etc.) and data (including but not limited to data used for analysis, storage, and display, etc.) involved in this application are all information and data authorized by the user or fully authorized by all parties, and the collection, use, and processing of relevant data must comply with the relevant laws, regulations, and standards of the relevant regions and areas. In addition, the subject can choose not to authorize the subject information and related data, or can refuse or conveniently refuse to push information, etc.

[0206] In this application, when collecting and processing relevant data during the instance application, the requirements of relevant local laws and regulations should be strictly followed to obtain the informed consent or separate consent of the personal information subject, and subsequent data use and processing should be carried out within the scope of authorization of laws and regulations and the personal information subject.

[0207] Those skilled in the art will appreciate that all or part of the processes in the above-mentioned embodiment methods can be implemented by instructing the relevant hardware through computer-readable instructions. The computer-readable instructions can be stored in a non-volatile computer-readable storage medium. When the computer-readable instructions are executed, they can include the processes of the embodiments of the above-mentioned methods. Among them, any reference to memory, database or other media used in the embodiments provided in this application may include at least one of non-volatile and volatile memory. Non-volatile memory may include read-only memory (ROM), magnetic tape, floppy disk, flash memory, optical memory, high-density embedded non-volatile memory, resistive random access memory (ReRAM), magnetic random access memory (MRAM), ferroelectric random access memory (FRAM), phase change memory (PCM), graphene memory, etc. Volatile memory may include random access memory (RAM) or external cache memory, etc. By way of illustration and not limitation, RAM can be in various forms, such as static random access memory (SRAM) or dynamic random access memory (DRAM). The database involved in the various embodiments provided herein may include at least one of a relational database and a non-relational database. Non-relational databases may include, but are not limited to, distributed databases based on blockchains. The processor involved in the various embodiments provided herein may be, but are not limited to, a general-purpose processor, a central processing unit, a graphics processing unit, a digital signal processor, a programmable logic unit, a data processing logic unit based on quantum computing, and the like.

[0208] The technical features of the above embodiments can be combined arbitrarily. To make the description concise, not all possible combinations of the technical features in the above embodiments are described. However, as long as there is no contradiction in the combination of these technical features, they should be considered to be within the scope of this specification.

[0209] The above-described embodiments merely represent several implementation methods of the present application. While the descriptions are relatively specific and detailed, they should not be construed as limiting the scope of the present application. It should be noted that a person of ordinary skill in the art may make various modifications and improvements without departing from the spirit of the present application, and these modifications and improvements fall within the scope of protection of the present application. Therefore, the scope of protection of the present application shall be determined by the appended claims.

Claims

1. A method for constructing a task instruction, executed by a computer device, comprising: Obtaining task information of a target task and an instruction data set containing multiple instruction information; Performing semantic analysis on the task information to determine the task type and task requirements of the target task; Using query information adapted to the task type, guiding the large model to filter out candidate instructions matching the task type from the instruction dataset; and From each of the candidate instructions, a task instruction that meets the task requirements is determined, wherein the task instruction is used to guide the large model to perform the target task.

2. The method according to claim 1, wherein the step of using query information adapted to the task type to guide the large model to filter out candidate instructions matching the task type from the instruction dataset comprises: Determining query information suitable for the task type; For each instruction information, combining the instruction information and the query information, determining input information that matches the instruction information; and The input information is input into a large model, and when the output information of the large model indicates that the instruction information matches the task type, the instruction information is determined as a candidate instruction.

3. The method according to claim 2, wherein combining the instruction information and the query information to determine input information that matches the instruction information comprises: In the query information, determining an insertion position of the instruction information; and The instruction information is inserted into the query information according to the insertion position to obtain input information matching the instruction information.

4. The method according to claim 2, wherein the large model comprises an encoder and a decoder, and wherein inputting the input information into the large model and determining the instruction information as a candidate instruction when the output information of the large model indicates that the instruction information matches the task type comprises: Performing feature extraction on the input information to obtain information features of the input information; Inputting the information feature into the encoder so that the encoder performs encoding processing on the information feature to obtain a hidden layer representation of the information feature; and When the output information of the decoder represents that the instruction information matches the task type, the instruction information is determined as a candidate instruction, wherein the original input of the decoder is the information feature and the intermediate layer input of the decoder is the hidden layer representation.

5. The method according to claim 1, wherein determining a task instruction that meets the task requirement from the candidate instructions comprises: Acquiring annotation information for the candidate instruction, wherein the annotation information is used to characterize the matching degree between the candidate instruction and the task requirement; and In a case where the matching degree represented by the annotation information satisfies a matching condition, the candidate instruction to which the annotation information belongs is determined as the task instruction of the target task.

6. The method according to claim 5, further comprising: Determining, from the candidate instructions matching the task type, an annotated instruction carrying annotation information; and When the number of the labeled instructions meets the quantity condition, the initial model is trained based on each of the labeled instructions to obtain a classification model that matches the task requirements, wherein the classification model is used to classify candidate instructions that do not carry labeling information and determine task instructions that meet the task requirements.

7. The method according to claim 6, wherein the training of the initial model based on each of the labeled instructions to obtain a classification model that matches the task requirements comprises: Constructing a training set including positive samples and negative samples, wherein the positive samples include the labeled instructions whose matching degree meets the matching condition, and the negative samples include the labeled instructions whose matching degree does not meet the matching condition; and The initial model is trained using the training set to obtain a classification model that matches the task requirements.

8. The method according to claim 6, further comprising: Performing performance testing on the classification model; If the performance test result of the classification model does not match the expected performance, returning to the step of obtaining the annotation information for the candidate instruction, and optimizing the classification model using the obtained annotation information until the performance test result of the classification model matches the expected performance; and If the performance test result of the classification model matches the expected performance, the classification model is used to classify the candidate instructions that do not carry labeling information to determine the task instructions that meet the task requirements.

9. The method according to any one of claims 1 to 8, wherein the performing semantic analysis on the task information to determine the task type of the target task comprises: Get multiple candidate task types; Performing semantic analysis on the task information to determine the task semantics of the task information; Determining the semantic similarity between each candidate task type and the task semantics; and The candidate task type with the highest semantic similarity is determined as the task type of the target task.

10. The method according to any one of claims 1 to 8, further comprising: Determining a target instruction set matching the target task from a plurality of candidate instruction sets based on the task requirements of the target task; and The task instruction is added to the target instruction set.

11. A task processing method, executed by a computer device, comprising: Obtaining task requirements of a target task and pending information for the target task; Based on the task requirement, reading a task instruction matching the target task from an instruction set, wherein the task instruction is constructed based on the method according to any one of claims 1 to 10; The information to be processed and the task instruction are input into the big model, so that the big model determines the processing result of the information to be processed according to the task requirements under the guidance of the task instruction.

12. A task instruction construction device, comprising: A task information acquisition module is used to obtain task information of a target task and an instruction data set containing multiple instruction information; A requirement determination module is used to perform semantic analysis on the task information to determine the task type and task requirements of the target task; a candidate instruction screening module, configured to use query information adapted to the task type to guide the large model to screen candidate instructions matching the task type from the instruction dataset; and A task instruction determination module is used to determine a task instruction that meets the task requirements from each candidate instruction, wherein the task instruction is used to guide the large model to perform the target task.

13. The apparatus according to claim 12, wherein the candidate instruction screening module comprises: an inquiry information determining unit, configured to determine inquiry information suitable for the task type; an input information determining unit, configured to determine, for each instruction information, input information matching the instruction information by combining the instruction information and the query information; and The candidate instruction screening unit is configured to input the input information into a large model, and determine the instruction information as a candidate instruction when the output information of the large model indicates that the instruction information matches the task type.

14. The apparatus according to claim 13, wherein the input information determining unit is specifically configured to: In the query information, determining an insertion position of the instruction information; and The instruction information is inserted into the query information according to the insertion position to obtain input information matching the instruction information.

15. The apparatus according to claim 13, wherein the large model comprises an encoder and a decoder, and the candidate instruction screening unit is specifically configured to: Performing feature extraction on the input information to obtain information features of the input information; Inputting the information feature into the encoder so that the encoder performs encoding processing on the information feature to obtain a hidden layer representation of the information feature; and When the output information of the decoder represents that the instruction information matches the task type, the instruction information is determined as a candidate instruction, wherein the original input of the decoder is the information feature and the intermediate layer input of the decoder is the hidden layer representation.

16. The apparatus according to claim 12, wherein the task instruction determination module comprises: a labeling information acquiring unit, configured to acquire labeling information for the candidate instruction, wherein the labeling information is used to characterize a degree of matching between the candidate instruction and the task requirement; and The task instruction determining unit is configured to determine the candidate instruction to which the annotation information belongs as the task instruction of the target task if the matching degree represented by the annotation information satisfies a matching condition.

17. The apparatus according to claim 16, further comprising a training module for: Determining, from the candidate instructions matching the task type, an annotated instruction carrying annotation information; and When the number of the labeled instructions meets the quantity condition, the initial model is trained based on each of the labeled instructions to obtain a classification model that matches the task requirements, wherein: The classification model is used to classify candidate instructions that do not carry labeling information and determine task instructions that meet the task requirements.

18. The apparatus according to claim 17, wherein the training module is specifically configured to: Construct a training set containing positive samples and negative samples, where The positive samples include the labeled instructions whose matching degree meets the matching condition, and the negative samples include the labeled instructions whose matching degree does not meet the matching condition; and The initial model is trained using the training set to obtain a classification model that matches the task requirements.

19. The apparatus according to claim 17, further comprising a performance testing module, configured to: Performing performance testing on the classification model; If the performance test result of the classification model does not match the expected performance, returning to the step of obtaining annotation information for the candidate instruction, and using the obtained annotation information to optimize the classification model until the performance test result of the classification model matches the expected performance; and If the performance test result of the classification model matches the expected performance, the classification model is used to classify the candidate instructions that do not carry labeling information to determine the task instructions that meet the task requirements.

20. The apparatus according to any one of claims 12 to 19, wherein the demand determination module is specifically configured to: Get multiple candidate task types; Performing semantic analysis on the task information to determine the task semantics of the task information; Determining the semantic similarity between each candidate task type and the task semantics; and The candidate task type with the highest semantic similarity is determined as the task type of the target task.

21. The device according to any one of claims 12 to 19, further comprising a storage module configured to: Determining a target instruction set that matches the target task from a plurality of candidate instruction sets based on the task requirements of the target task; and The task instruction is added to the target instruction set.

22. A task processing device, comprising: A module for obtaining information to be processed, used to obtain the task requirements of a target task and the information to be processed for the target task; a task instruction reading module, configured to read a task instruction matching the target task from an instruction set based on the task requirement, wherein the task instruction is constructed by the apparatus according to claim 12; and The task processing module is used to input the information to be processed and the task instruction into the large model, so that the large model can determine the processing result of the information to be processed according to the task requirements under the guidance of the task instruction.

23. A computer device comprising a memory and one or more processors, wherein the memory stores computer-readable instructions, and the one or more processors implement the steps of the method according to any one of claims 1 to 11 when executing the computer-readable instructions.

24. A computer-readable storage medium having computer-readable instructions stored thereon, wherein the computer-readable instructions, when executed by one or more processors, implement the steps of the method according to any one of claims 1 to 11.

25. A computer program product comprising computer readable instructions, which when executed by one or more processors implement the steps of the method of any one of claims 1 to 11.

Images