Function calling method and device, electronic equipment and storage medium

Abstract

The embodiment of the invention discloses a function calling method and device, electronic equipment and a storage medium. The method comprises the steps that a function library is constructed; obtaining semantic information of a user query text; according to the semantic information and the function mark of each function, obtaining a corresponding target function from a function library; generating a corresponding parameter sequence based on the semantic information and the target function; executing the objective function based on the parameter sequence; according to the method, the function mark is distributed to each function in the function library, the function selection task is converted into a single-mark classification problem, and the corresponding target function is efficiently predicted by utilizing the semantic information of the user query text, so that the complexity of generating the function name character by character traditionally is simplified, and the function retrieval efficiency is improved; meanwhile, the parameter sequence is gradually generated based on the semantic information of the user query text and the target function, the logic consistency and accuracy of the parameters are ensured, and therefore the efficiency and accuracy of function calling are improved.

Description

Technical Field

[0001] The present application relates to the field of artificial intelligence technology; specifically, to a function calling method, device, electronic device and storage medium. Background Art

[0002] With the rapid development of artificial intelligence, the research and application of large language models (LLM) have entered a new stage. Currently, large language models (such as the GPT series, Gemini series, and Llama series) are usually run on high-performance cloud servers, relying on a large amount of computing resources and storage capacity. These models use the high computing power and high bandwidth provided by cloud services to complete complex tasks such as natural language understanding, generation, and code assistance through API calls.

[0003] During the model inference process, it is necessary to retrieve the relevant function name from the function library through function calls, so that the function description corresponding to the function name is combined with the user input and processed to produce a logical output; however, in the function call task, the best function name is inferred character by character, but the function name is usually composed of multiple tags, resulting in low function retrieval efficiency.

[0004] It can be seen that the function calling method in the related art has the problem of low retrieval efficiency. Summary of the invention

[0005] To solve the above technical problems, the embodiments of the present application provide a function calling method, device, electronic device and storage medium, which solve the problem of low retrieval efficiency of the function calling method in the related art.

[0006] According to one aspect of an embodiment of the present application, a function calling method includes: building a function library and assigning a unique function tag to each function in the function library; obtaining semantic information of a user query text; obtaining a corresponding target function from the function library based on the semantic information and the function tag of each function; generating a corresponding parameter sequence based on the semantic information and the target function; and executing the target function based on the parameter sequence.

[0007] Optionally, according to the semantic information and the function tag of each function, a corresponding target function is obtained from a function library, including: according to the semantic information, obtaining a matching score between the user query text and each function tag; according to the matching score between the user query text and each function tag, calculating a prediction probability of each function tag; and determining the target function according to the prediction probability of each function tag.

[0008] Optionally, based on the semantic information, a matching score between the user query text and each function tag is obtained, including: performing vector conversion on the semantic information to obtain a text vector representation; performing vector conversion on the function characteristics corresponding to each function tag to obtain a function vector representation; fusing the text vector representation with each function vector representation to obtain each fused vector; performing similarity calculation on each fused vector to obtain a matching score between the user query text and each function tag.

[0009] Optionally, according to the matching score between the user query text and each function tag, the calculation formula for calculating the prediction probability of each function tag is:

[0010]

[0011] Among them, P(fi|Q) represents the predicted probability of the i-th function tag, Q represents the user query text, s(Q,fi) represents the matching score between the user query text and the i-th function tag, N represents the total number of function tags, i,j=[1,2,…,N], and exp represents the exponential function.

[0012] Optionally, determining the objective function according to the predicted probability of each functional marker includes: obtaining the probability distribution of each functional marker according to the predicted probability of all functional markers; obtaining the target functional marker with the largest probability value based on the probability distribution of each functional marker; and determining the objective function according to the target functional marker.

[0013] Optionally, based on the semantic information and the objective function, a formula for generating a corresponding parameter sequence is:

[0014]

[0015] Among them, A represents the parameter sequence, a t represents the tth parameter marker, fm represents the function marker of the objective function, a ＜t represents the first t-1 parameter markers in the parameter sequence, and T represents the number of parameter markers in the parameter sequence.

[0016] Optionally, the method further includes: obtaining a function classification loss according to a cross entropy loss; the calculation formula is:

[0017] According to the negative log-likelihood loss of sequence generation, the sequence generation loss is obtained; its calculation formula is:

[0018]

[0019] According to the function classification loss and the sequence generation loss, the total loss is obtained, and the specific formula is: L=αLclass+βLgen; wherein α and β are weight parameters.

[0020] According to one aspect of an embodiment of the present application, a function calling device is provided, the device comprising: a function library construction module, used to construct a function library and assign a unique function tag to each function in the function library; a semantic information acquisition module, used to obtain semantic information of a user query text; a target function acquisition module, used to obtain a corresponding target function from the function library according to the semantic information and the function tag of each function; a parameter sequence generation module, used to generate a corresponding parameter sequence based on the semantic information and the target function; and a function execution module, used to execute the target function based on the parameter sequence.

[0021] According to one aspect of an embodiment of the present application, a computer-readable medium is provided, on which a computer program is stored. When the computer program is executed by a processor, the function calling method in the above technical solution is implemented.

[0022] According to one aspect of an embodiment of the present application, an electronic device is provided, comprising: a processor; and a memory for storing executable instructions of the processor; wherein the processor is configured to execute the executable instructions so that the electronic device implements a function calling method as in the above technical solution.

[0023] According to one aspect of an embodiment of the present application, a computer program product is provided, including a computer program, wherein when the computer program is executed by a processor, the function calling method in the above technical solution is implemented.

[0024] The technical solution provided by this application includes at least the following beneficial effects:

[0025] This application converts the function selection task into a single-label classification problem by assigning a functional tag to each function in the function library, and uses the semantic information of the user query text to efficiently predict the corresponding target function, thereby simplifying the complexity of traditional character-by-character function name generation and improving function retrieval efficiency; at the same time, based on the semantic information of the user query text and the target function, a parameter sequence is gradually generated to ensure the logical consistency and accuracy of the parameters, thereby improving the efficiency and accuracy of function calls. BRIEF DESCRIPTION OF THE DRAWINGS

[0026] The drawings herein are incorporated into the specification and constitute a part of the specification, showing embodiments consistent with the present application, and together with the specification, are used to explain the principles of the present application. Obviously, the drawings described below are only some embodiments of the present application, and for those of ordinary skill in the art, other drawings can be obtained based on these drawings without creative work. In the drawings:

[0027] Figure 1 The figure is a flow chart of a function calling method provided in an embodiment of the present application;

[0028] Figure 2 Shown Figure 1 An exemplary flow chart of step S30 in FIG.

[0029] Figure 3 Shown Figure 2 An exemplary flow chart of step S310 in FIG.

[0030] Figure 4 The figure is a schematic diagram of the structure of a function calling device provided in an embodiment of the present application;

[0031] Figure 5 A schematic diagram of the structure of a computer system suitable for implementing an electronic device of an embodiment of the present application is shown. DETAILED DESCRIPTION

[0032] Here, exemplary embodiments will be described in detail, examples of which are shown in the accompanying drawings. When the following description refers to the drawings, unless otherwise indicated, the same numbers in different drawings represent the same or similar elements. The implementations described in the following exemplary embodiments do not represent all implementations consistent with the present application. Instead, they are only examples of devices and methods consistent with some aspects of the present application as detailed in the attached claims.

[0033] The block diagrams shown in the accompanying drawings are merely functional entities and do not necessarily correspond to physically independent entities. That is, these functional entities may be implemented in software form, or in one or more hardware modules or integrated circuits, or in different networks and / or processor devices and / or microcontroller devices.

[0034] The flowcharts shown in the accompanying drawings are only exemplary and do not necessarily include all the contents and operations / steps, nor must they be executed in the order described. For example, some operations / steps can be decomposed, and some operations / steps can be combined or partially combined, so the actual execution order may change according to actual conditions.

[0035] It should also be noted that the "multiple" mentioned in this application refers to two or more than two. "And / or" describes the association relationship of the associated objects, indicating that there can be three relationships. For example, A and / or B can mean: A exists alone, A and B exist at the same time, and B exists alone. The character " / " generally indicates that the previous and next associated objects are in an "or" relationship.

[0036] With the rapid development of artificial intelligence, the research and application of large language models (LLM) have entered a new stage; existing large language models, such as the GPT series, Gemini series, and Llama series, are usually run on high-performance cloud servers and rely on a large amount of computing resources and storage capacity; these models use the high computing power and high bandwidth provided by cloud services to complete complex tasks such as natural language understanding, generation, and code assistance through API calls.

[0037] In terms of function calls, many existing technologies use methods based on Retrieval-Augmented Generation (RAG); specifically, by retrieving relevant function descriptions from the function library during model reasoning, these descriptions are combined with user input and processed to generate logical output. For example, RAG methods usually use context enhancement technology to mark function information with additional context tokens to improve the accuracy of calls.

[0038] In addition, in order to reduce the inference cost of the model, some research is devoted to developing models with smaller parameter amounts (such as Gemma-2B, StableCode-3B) and improving their performance through fine-tuning (such as full model training, LoRA fine-tuning). However, small models still lag behind larger models in terms of function call accuracy and latency during the inference phase. Although Llama cpp and MLC LLM frameworks have significantly improved the efficiency of running 7B and above models on edge devices, these frameworks still have limitations in memory utilization and battery consumption, especially on smaller parameter models.

[0039] It can be seen that there are still obvious problems in the following aspects of the relevant calculations:

[0040] (1) High computing and storage requirements: Existing large models such as GPT-4 rely on cloud deployment, and the reasoning process consumes a lot of computing resources and bandwidth, which is costly. For example, one hour of interaction may cost tens of dollars.

[0041] (2) Privacy and security issues: The use of cloud models requires uploading user data to the server, which may lead to the risk of sensitive information leakage.

[0042] (3) Insufficient performance of small models: Small models based on edge computing are inferior to large models in terms of inference accuracy, function call efficiency, and latency. For example, the performance of Gemma-2B in function calls is far behind that of GPT-4.

[0043] (4) Energy consumption issue: When running small models on edge devices such as smartphones, the high energy consumption of function calls limits the practical use of the model due to the limited battery life of the device.

[0044] (5) Limited context length: The RAG method requires a large number of context tokens when retrieving and processing context descriptions, which increases latency and storage costs.

[0045] In order to solve the above problems, the present application provides a function calling method, which specifically includes the following embodiments:

[0046] Figure 1 FIG. 1 is a flow chart of a function calling method provided in an embodiment of the present application; Figure 1 As shown, the method specifically comprises the following steps:

[0047] Step S10: construct a function library, and assign a unique function tag to each function in the function library.

[0048] It should be noted that in the traditional function call model, the task of generating function names character by character is usually adopted. Specifically, the model needs to predict each character of the function name one by one until the complete function name is generated. This method is common in natural language generation tasks, such as text generation), and its basic process is:

[0049] (1) Input: User query.

[0050] (2) Prediction process: The model generates a function name character by character based on the user query and context information. Each step generates one character until the complete function name is generated.

[0051] (3) Output: the complete function name.

[0052] For example, suppose you need to generate a function name to calculate the sum of two numbers. A possible function name is calculate_sum. The traditional character-by-character generation method starts with the letter c and generates a, l, c, u, l, a, t, e, _, s, u, m one by one. The disadvantages of this method include: (1) Low efficiency: Each time a character is generated, the model needs to make a prediction until the entire name is generated; (2) Error accumulation: During the step-by-step generation process, the prediction error of each character may affect the generation of subsequent characters, resulting in an inaccurate final name; (3) Lengthy: Character-by-character generation increases the number of calculation steps and consumes more computing resources and time.

[0053] In order to overcome the above problems, this application proposes a function selection method based on unique function labels, which transforms the function selection task from label-by-label generation to single-label classification. In the constructed function library (for example, containing N functions), a unique function label is assigned to each function, such as<type_0> to<type_N-1> These tags are symbolic representations of functions and are directly bound to the semantics of the function. This design simplifies the function selection task from multi-tag generation to a single-tag classification task of selecting one tag from N tags, greatly improving the prediction efficiency and accuracy. New function tags<type_0> to<type_N-1> and special end tags<type_end> Introduced into the tagger. In the architecture of the pre-trained language model, the language header is extended to support additional N function tags, thereby enabling efficient localization of function names.

[0054] Step S20: Acquire semantic information of the user query text.

[0055] It should be noted that the query text input by the user usually contains a specific request or intention. Extracting the contextual semantic information of the user query text means identifying the user's actual needs from these texts, such as calculating the sum of two numbers.

[0056] In this embodiment, the semantic information includes the specific operation that the user expects the system to perform, such as "calculation", "query", "display", etc. By understanding this information, the system can clearly understand which function the user wants to use to process the request.

[0057] The user query text may contain multiple key information elements, such as operation type, objects involved, input parameters, etc. The process of extracting semantic information is actually to identify these key information and extract them as the basis for subsequent operations. For example: in the query "calculate the sum of two numbers", the system needs to recognize that "calculate" is the operation type and the two numbers (such as 3 and 5) are the parameters that need to be processed.

[0058] Step S30: Acquire a corresponding target function from a function library according to the semantic information and the function tag of each function.

[0059] In this embodiment, the goal of function selection is to select the target function that best suits the user's query from a predefined function library; each function in the function library represents a certain operation or task that the system can perform, such as "calculate sum", "get file content", "draw graphics", etc.; the system's task is to select the most matching function based on the content of the user's query; for example: if the user's query is "calculate the sum of two numbers", the system needs to select an "addition" related function from the function library, such as calculate_sum. The function selection here is based on the user's query intent, that is, language information, and the query is understood through the language model and mapped to the correct function.

[0060] Step S40: Generate a corresponding parameter sequence based on the semantic information and the objective function.

[0061] In this embodiment, parameter generation refers to generating the required parameters for the selected objective function. Each objective function usually requires specific input parameters to execute. For example, for the function of "calculating the sum of two numbers", two parameters (such as 3 and 5) may be required as input; for the function of "reading file contents", a file path may be required as a parameter.

[0062] Therefore, parameters refer to the input data or information required for the target function to execute. These data are usually provided by the user query or derived by the system based on the query. For example, suppose the user query is: "Calculate the sum of two numbers", the parameters that the system needs to generate are these two numbers, which may be param1=3 and param2=5, and pass them as input to the target function calculate_sum(param1,param2).

[0063] Specifically, the process of generating parameters includes: (1) identifying the parameter types mentioned in the user query, such as numerical values, file paths, text content, etc.); (2) filling in the correct parameters for each target function. These parameters are usually related to the key information in the query, such as numbers, names, paths, etc.; (3) If the query is more complex, parameter generation may also need to determine multiple parameters based on contextual semantic information, or dynamically generate parameters, such as obtaining data from a database, performing calculations, etc.

[0064] For example: the user query is "calculate the sum of 3 and 5", the system needs to generate param1 = 3, param2 = 5; and then pass it to the target function calculate_sum (param1, param2).

[0065] Step S50: Execute the objective function based on the parameter sequence.

[0066] In this embodiment, this step is the function call execution phase, and its main task is to combine the target function and parameter sequence generated in the previous phase to complete the actual function call, thereby obtaining the final output result; specifically, this step is equivalent to using a typical function call method in a programming language to pass the generated parameters to the target function, execute the function's logic, and output the result required by the user.

[0067] It should be noted that the specific process of calling and executing includes:

[0068] (1) Prepare the target function: The target function to be called has been determined in the function selection stage, such as calculate_sum.

[0069] (2) Passing parameters: The parameter generation stage has generated the parameters required by the objective function, such as two numbers param1=3 and param2=5.

[0070] (3) Call execution: pass the parameters in the parameter sequence according to the requirements of the objective function, for example, call calculate_sum(3,5).

[0071] (4) Execute function logic: The system runs the code logic of the target function. For example, calculate_sum will perform the addition operation 3+5.

[0072] (5) Output result: After the function is executed, the final calculation result, such as the return value 8, will be returned and fed back to the user.

[0073] It should also be noted that: function selection is to select the most suitable target function from the function library to ensure that the system can execute the user's intention; parameter generation is to derive and generate the parameters required for the target function based on the user query to ensure that the function can receive and correctly process the input.

[0074] The main function of function tagging is to symbolize the function name. By assigning a unique tag to each function, such as<type_0> ,<type_1> ,...,<type_N-1> , we are able to simplify the function selection task. Function tags are not the specific functional implementation of a function, but rather symbolic representations that are closely related to the semantics and functionality of the function. These tags essentially represent different function categories or types.

[0075] Function notation combines the semantics and functionality of a function with a simplified notation (e.g.<type_0> ) to bind. The model "understands" the category of functions through these tags and selects the most appropriate function tag based on the input query. For example, suppose there is a function y(X1,X2,X3) that calculates the average of the input values ​​X1,X2,X3; here, the function of y can be represented by the function tag, such as<type_1> , and the function name itself is simplified to this token. The function name is symbolized, and the specific implementation of the function (such as calculating the average) is determined by the contextual understanding of the model and the functional definition of the function itself.

[0076] In this process, parameter sequence (such as X1, X2, X3) and function tag are two independent concepts. Specifically, parameter sequence (X1, X2, X3) is the specific data or value that needs to be passed in when calling a function, which is used for the calculation or operation of the function; function tag (such as<type_1> ) is a symbol that represents a function and is used to simplify the task of function selection; it does not contain parameter data itself, but rather represents a specific function or operation type. Suppose the function y(X1,X2,X3) is given the function label<type_1> , then in the actual execution process, X1, X2, X3 are the parameter sequences that need to be passed in. Function Flags<type_1> It just tells the model which function to execute, but does not contain the parameters themselves.

[0077] For example: Assume there is the following function:

[0078] Function 1: average(X1,X2,X3) calculates the average value, the function is marked as<type_0> .

[0079] Function 2: sum(X1,X2,X3) calculates the sum, and the function is marked as<type_1> .

[0080] Based on the user query text, the model will select the most appropriate feature tag. If the query is "calculate the average of three numbers", then the model will select<type_0> , and generate the corresponding parameter sequence (such as 3,5,7) to call the average function; that is:

[0081] User query: "Calculate the average of three numbers";

[0082] Generated feature flags:<type_0> (representing the average function);

[0083] Generated parameter sequence: 3,5,7;

[0084] Final execution: average(3,5,7).

[0085] The technical solution provided in this embodiment has at least the following beneficial effects:

[0086] This application converts the function selection task into a single-label classification problem by assigning a functional tag to each function in the function library, and uses the semantic information of the user query text to efficiently predict the corresponding target function, thereby simplifying the complexity of traditional character-by-character function name generation and improving function retrieval efficiency; at the same time, based on the semantic information of the user query text and the target function, a parameter sequence is gradually generated to ensure the logical consistency and accuracy of the parameters, thereby improving the efficiency and accuracy of function calls.

[0087] In one embodiment of the present application, Figure 2 As shown, according to the semantic information, obtaining the corresponding target function from the function library specifically includes the following steps:

[0088] Step S310: Obtain a matching score between the user query text and each function tag according to the semantic information.

[0089] In one embodiment, if Figure 3 As shown, obtaining the matching score between the user query text and each function tag according to the semantic information specifically includes the following steps:

[0090] Step S3101: convert the semantic information into a vector to obtain a text vector representation.

[0091] Step S3102: perform vector conversion on the function characteristics corresponding to each function label to obtain a function vector representation.

[0092] Step S3103: fuse the text vector representation with each function vector representation respectively to obtain each fused vector.

[0093] Step S3104: perform similarity calculation on each fusion vector to obtain a matching score between the user query text and each function tag.

[0094] It should be noted that, in this embodiment, obtaining the matching score between the user query text and each function tag is mainly achieved through the following steps:

[0095] (1) Vector encoding: The semantic information of the user query text and the functional characteristics corresponding to each function tag are converted into vector representations. The user query text can be encoded into a vector through a language model (such as a pre-trained Transformer model), which can capture the semantic information in the query; similarly, each function tag will also be converted into a vector, representing the functional characteristics corresponding to the tag; optionally, the function tag does not exist in isolation. In order to ensure the validity of the tag, the training data set usually contains function descriptions that describe the specific functions corresponding to the tag; through these descriptions, the model learns to convert symbols into<type_0> Associated with actual functional functions (such as summation, average calculation, etc.); ultimately, the model can<type_0> The vector representation of is associated with a specific function.

[0096] (2) Vector fusion: In practical applications, user queries usually contain contextual information, and function tags also have corresponding semantics. In order to improve matching accuracy, the model will fuse the vector representation of the user query with the vector representation of the function tag, combining the contextual semantics of the query and the functional description of the function tag so that the model can better understand the relationship between them. Specifically, the vector representation of the user query and the vector representation of the function tag are fused by concatenation or weighted averaging. The purpose of fusion is to merge the two representations into a unified vector so that the model can comprehensively consider the relationship between the query and the function tag. Common fusion methods include:

[0097] ① Concatenation: The text vector representation and the function vector representation are directly concatenated into a longer vector, which is then further processed by a neural network to calculate the relationship between them.

[0098] ②Weighted Average: Perform weighted average on the text vector representation and the function vector representation and merge them into a new vector. The weight coefficient can be learned through training or directly set to a fixed value.

[0099] Both of the above fusion methods can combine the information of the two vectors, so that the model can consider the semantics of the query and the semantics of the function tag at the same time; specifically, by fusing the query vector and the function tag vector, the model can simultaneously utilize the contextual information of the query and the semantic characteristics of the function tag. The fused vector can comprehensively represent the relationship between the query and the tag, so that the model can more accurately judge the degree of match between them; for example, if the query is "calculate the sum of two numbers" and the function tag is<type_0> stands for “sum function”, and the fused vector will contain both the semantic information of the query (such as “calculation” and “sum”) and the semantic information of the functional label (such as “sum”); therefore, in this way, the model can better understand the relationship between the query and the functional label.

[0100] Similarity calculation: After encoding and fusion, the model calculates the degree of match between the text vector representation and the function vector representation; the model obtains a matching score by calculating the similarity between the two (for example, through the dot product between vectors, cosine similarity, etc.). The higher the score, the higher the degree of semantic match between the query and the function tag.

[0101] Step S320: Calculate the prediction probability of each function tag according to the matching score between the user query text and each function tag.

[0102] In this embodiment, the predicted probability of each functional marker is calculated by a conditional probability formula, as shown in formula (1):

[0103]

[0104] Among them, P(fi|Q) represents the predicted probability of the i-th function tag, Q represents the user query text, s(Q,fi) represents the matching score between the user query text and the i-th function tag, N represents the total number of function tags, i,j=[1,2,…,N], and exp represents the exponential function.

[0105] It should be noted that the matching score s(Q,fi) represents the degree of matching between the user query text and the function tag, which is usually obtained by calculating the similarity between the text vector and the function vector. When calculating the probability, the score is usually weighted by an exponential function, such as exp(s(Q,fi)), to enhance the probability of tags with higher scores; therefore, using the exponential function in the process of calculating the probability can make the tags with high scores correspond to higher selection probabilities.

[0106] In addition, s(Q,fi) is only a raw matching score and has not been standardized; therefore, it is usually necessary to amplify the score through an exponential function to ensure that a higher matching score corresponds to a higher probability and to avoid incorrect selection of markers with too low scores.

[0107] Step S330: Determine the objective function according to the predicted probability of each functional label.

[0108] In this embodiment, determining the objective function according to the predicted probability of each functional marker specifically includes: obtaining the probability distribution of each functional marker according to the predicted probability of all functional markers; obtaining the target functional marker with the largest probability value based on the probability distribution of each functional marker; and determining the objective function according to the target functional marker.

[0109] It should be noted that this embodiment normalizes the predicted probabilities of all functional markers by the softmax (normalized exponential function) method to obtain the probability distribution corresponding to each functional marker; optionally, the predicted probabilities of the functional markers are normalized to ensure that the output of the model conforms to the basic rule of probability, that is, the sum of the probabilities of all functional markers is 1, so that the prediction results of the model have a clear probabilistic meaning. The normalization process can help the model make more reasonable decisions, especially when determining the optimal functional marker among multiple possible choices.

[0110] Therefore, the significance of normalizing the predicted probabilities of all functional markers in this embodiment is:

[0111] (1) Ensure that the sum of probabilities is 1: The probability value should be a number between 0 and 1, and the sum of the probabilities of all possible markers must be equal to 1; through normalization, the model can output a standardized probability distribution, ensuring that the probability value of each functional marker is meaningful and the sum of all probabilities is 1.

[0112] (2) Fair comparison: After normalization, the probability values ​​of all functional markers can be compared fairly, preventing some markers from being mistakenly ignored or over-weighted because of their large or small values. This is crucial for the model to select the optimal functional marker.

[0113] (3) Improving the output stability of the model: Without normalization, the model may output unstandardized values, which may cause the probability values ​​of certain labels to be very large, affecting the final decision-making process. Through normalization, this problem can be eliminated and the stability and reliability of the model output can be improved.

[0114] It can be seen that normalization is the process of adjusting the output of the model to a standardized probability distribution, which is usually used for multi-classification tasks to ensure that the probability value of each prediction result is between 0 and 1, and the sum of all predicted probabilities is 1. In this application, the main purpose of normalization is to convert the original prediction value (usually a non-standardized score) calculated by the model for each functional marker into an output with a clear probability meaning.

[0115] Furthermore, the specific steps of normalization include: (1) Raw score calculation: First, the model predicts each functional marker and obtains a raw score. These scores represent the model's "confidence" in each functional marker, but these scores themselves are not probabilities and cannot be directly used for decision-making; (2) Apply normalization: In order to convert these raw scores into standardized probabilities, a normalization method (such as Softmax) is used to convert the score of each functional marker into a probability. This process ensures that the probability value of each marker is between 0 and 1, and the sum of the probabilities of all functional markers is 1; (3) Probability output: After normalization, the model outputs the probability distribution of each functional marker. Based on these probabilities, the model can select the marker with the highest probability as the final prediction result.

[0116] Therefore, through normalization, the model is able to effectively compare the predicted probabilities of different functional markers, thereby making more accurate choices and improving the overall performance and stability of the system.

[0117] It should be noted that this embodiment uses the argmax function to select the optimal function label from the normalized probability distribution; argmax is a common mathematical operation used to return the index or element with the maximum value. In the function call task, this operation helps the model select the most likely one from multiple candidate function labels.

[0118] The specific operation process is as follows: first, find which function tag has the largest probability value according to the argmax function, and return the index or label of the corresponding function tag; second, select the optimal function tag according to the index or label obtained by argmax; finally, determine the objective function based on the function tag. For example, if there are 3 function tags<nexa_0> ,<nexa_1> ,and<nexa_2> , and their probabilities are 0.2, 0.5, and 0.3 respectively, then through the argmax operation, the model will choose<nexa_1> As the optimal marker, its probability value 0.5 is the largest.

[0119] The effects of this embodiment include: (1) Simplifying decision-making: The argmax operation makes the decision-making process simple and clear by selecting the function label with the maximum probability, avoiding complex multiple-choice problems. (2) Improving efficiency: By directly selecting the optimal label, it avoids processing or comparing multiple labels one by one, thereby improving the efficiency of prediction. (3) Improving accuracy: Since argmax always selects the label with the maximum probability, it ensures the accuracy of function selection, that is, selecting the function that best meets the user's query intent.

[0120] Therefore, through the argmax operation, the model can accurately select the optimal one from multiple candidate function labels, ensuring the efficiency and accuracy of the entire function calling process.

[0121] In one embodiment of the present application, based on the semantic information and the objective function, a corresponding parameter sequence is generated as shown in formula (2):

[0122]

[0123] Among them, A represents the parameter sequence, a t represents the tth parameter marker, fm represents the function marker of the objective function, a ＜t represents the first t-1 parameter markers in the parameter sequence, and T represents the number of parameter markers in the parameter sequence.

[0124] It should be noted that in this embodiment, parameter generation is designed as an autoregressive sequence generation task, and reasonable parameter configuration is predicted based on the objective function; when generating the parameter sequence, the parameters are generated step by step, and each new parameter generated depends on the previous one or several previous parameters. Specifically, a t Indicates that the tth parameter generated depends on the previous t-1 parameter labels, i.e. a1, a2, ..., a t-1 ; The autoregressive model generates the current parameter label a at each step t , and use it as input to predict the next token, i.e., a t+1 . This process is carried out step by step. At each step, the model generates a new parameter and uses this parameter to predict the next parameter. In addition, in order to ensure that the generated parameter sequence is highly matched with the semantics of the target function, the semantic information Q of the user input text and the functional marker fm of the target function are provided to the model as input. The purpose of this approach is to provide rich contextual information so that when the model generates each parameter, it not only depends on the previous parameter, but also can generate more appropriate parameter values ​​based on the context of the entire query and function to ensure that the parameter is consistent with the semantics of the target function.

[0125] In one embodiment of the present application, the two processes of function selection and parameter generation are uniformly modeled through the following joint probability formula, as shown in formula (3):

[0126] P(A,fm|Q)=P(fi|Q)·P(A|Q,fm) (3)

[0127] It should be noted that this joint modeling method realizes end-to-end unified processing from user query text to function call: first, select the target function label f ​​through P(fi|Q); then generate the parameter sequence A under the constraint of the target function through P(A|Q,fm); the specific points are:

[0128] (1) Simplify the processing flow: The function selection and parameter generation tasks are combined into one whole and processed by the same model, which simplifies the processing flow and avoids the collaboration and coordination problems among multiple models.

[0129] (2) Improved accuracy and consistency: Joint modeling ensures that function selection and parameter generation share the same contextual information, reduces errors caused by inconsistent information, and improves the accuracy and consistency of the overall call.

[0130] (3) Enhanced context information fusion: By simultaneously considering the context of user queries, selected functions, and generated parameters, joint modeling can generate function calls more accurately, which is particularly suitable for complex calling scenarios such as nested calls and parallel calls.

[0131] (4) Support for complex function call scenarios: Joint modeling can handle complex scenarios such as parallel function calls and nested function calls. In these scenarios, separate processing methods may cause difficulties, while unified modeling provides greater flexibility.

[0132] (5) Reduce error accumulation and improve reasoning efficiency: Through unified modeling, the accumulation of errors between different models is reduced, and through optimization strategies such as termination marking, the reasoning efficiency is improved and unnecessary calculation steps are reduced.

[0133] (6) Improve system scalability and flexibility: Joint modeling supports more flexible and scalable system design, which can quickly adapt to new function types or more complex function call requirements, thereby enhancing the system's adaptability and scalability.

[0134] With these advantages, unified modeling with joint probability formula provides a more efficient, accurate and flexible solution for complex function call tasks.

[0135] In another embodiment of the present application, a high-quality data set is the basis for model training in this embodiment. Aiming at the special needs of function calls, an optimized data set covering a variety of scenarios and task types is constructed; the data set sampling range of this embodiment is wide, covering but not limited to the following scenarios: 1. Digital calculation (such as calculate_sum); 2. Data visualization (such as plot_graph); 3. File operation (such as read_file); wherein the data sample in each scenario includes a complete mapping of user query text, objective function and generation parameters, ensuring the diversity and representativeness of the training data.

[0136] In this embodiment, in order to allow the model to fully understand the semantics of each function tag, the function description is integrated into the model as part of the training data to enhance its ability to grasp the meaning of the tag. By designing a prompt template (PromptTemplate), the model can adapt to different calling styles (single call, parallel call, nested call). Specifically, this application designs a set of prompt templates that adapt to different calling scenarios, including: single function call, parallel function call, nested function call. The input, output, and examples of the prompt template are shown in Table 1:

[0137] Table 1. Prompt template

[0138]

[0139]

[0140] Through the above design and optimization, the function labeling method of the present application shows significant efficiency and accuracy advantages in function call tasks, providing reliable support for the development of intelligent systems.

[0141] In addition, in order to enhance the adaptability of the model to natural language queries, the data set combines real user input and simulated generated data. For example: the diversity of user queries is expanded through the template method to cover possible expression variants. This embodiment also requires strict screening of noise data and ambiguous data to ensure sample quality; at the same time, data enhancement methods (such as synonym replacement and sentence transformation) are used to increase the coverage of training data. For long-tail functions in function calls (functions with low calling frequency), a small sample learning method is introduced to ensure that the model can still make accurate predictions when data is insufficient.

[0142] In order to achieve efficient model training, this embodiment adopts an optimization strategy to perform comprehensive optimization from data preprocessing to model tuning, specifically including:

[0143] (1) Multi-task learning: The model adopts a multi-task learning framework, taking function selection and parameter generation as two subtasks, and sharing parameters by sharing the embedding layer and part of the encoding layer, thereby enhancing the generalization ability of the model. Specifically, parameter sharing in the multi-task learning framework is usually achieved in the following ways:

[0144] ① Shared embedding layer: The embedding layer maps the input (such as query, function label, etc.) to the vector space. In multi-task learning, the embedding layers of query and function label can be shared, so that the model can jointly learn how to represent the input data of different tasks. For example, both query and function label can be converted into vector representation through the same embedding layer, and then used for function selection and parameter generation tasks respectively.

[0145] ② Shared encoding layer: The encoding layer is responsible for processing high-level semantic information of the data. In multi-task learning, the encoding layer can be shared so that different tasks (such as function selection, parameter generation, and semantic understanding) can work in the same semantic space and use the same feature representation. The shared encoding layer helps capture the deep relationship between the query and the target function and improves the synergy between tasks.

[0146] ③ Shared decoding layer: In some model architectures, the decoding layer is responsible for generating the final output of the task based on the generated hidden state. In multi-task learning, the decoding layer can be shared so that multiple tasks can be processed through the same output generation mechanism. For example, the decoding layer generates the output results of different tasks based on the same intermediate representation, which can reduce redundant calculations and improve efficiency.

[0147] ④ Specialized task layers (task-specific layers): Although the embedding, encoding, and decoding layers are shared, each task can also have its own specific task layer. These task layers are specific to a task and are designed to fine-tune shared features. For example, function selection and parameter generation can use their own task layers to make predictions on the shared encoded representation.

[0148] ⑤Joint training and loss function: In multi-task learning, there is usually a joint loss function, which is the weighted sum of the losses of multiple subtasks. During training, the gradients of all tasks act on both the shared part and the task-specific part of the model. In this way, the model is able to share parameters while optimizing multiple tasks at the same time, thereby improving overall performance.

[0149] ⑥Weight sharing and gradient updating: During the training process, the shared parts of the model (such as the embedding layer and the encoding layer) are updated according to the gradient of each task. Through weight sharing and gradient propagation, the model can jointly adjust parameters in multiple tasks, thereby enhancing the connection and collaboration between various subtasks.

[0150] (2) Loss function design: The loss function consists of two parts:

[0151] Classification loss: Label prediction for function selection tasks, using cross entropy loss:

[0152]

[0153] Generation loss: For parameter generation tasks, the negative log-likelihood loss of sequence generation is used:

[0154]

[0155] The total loss is the weighted sum of the two: L = αLclass + βLgen; where α and β are weight parameters, which are dynamically adjusted according to task requirements.

[0156] (4) Step-by-step training strategy: A phased optimization strategy is adopted during the training process: ① Pre-training phase: general language modeling training based on a large-scale corpus. ② Fine-tuning phase: fine-tune the model using the constructed dataset to adapt to the function call task.

[0157] (5) Reasoning optimization: In the reasoning stage, beam search or top-k sampling technology is used to improve the accuracy of parameter generation. At the same time, the reasoning efficiency is optimized by reducing the number of generation steps and dynamic stopping strategy.

[0158] The technical solution provided by this application includes at least the following beneficial effects:

[0159] 1. Unified task modeling: This application uniformly models function call tasks as conditional probability prediction problems, and simultaneously implements end-to-end processing of function selection and parameter generation through a causal language model; specifically, function selection is designed as a classification task, in which each function is uniquely represented by a function label, and the optimal function label is predicted based on the user query; at the same time, parameter generation is designed as an autoregressive sequence generation task, which uses user queries and the context of the target function to generate a parameter sequence that meets the semantic requirements.

[0160] 2. Function label design and classification optimization: Each objective function is assigned a unique function label, e.g.<type_0> to<type_N-1> , simplifies the function selection task, transforming it from a multi-label generation problem to a single-label classification problem; the softmax method is used to normalize the prediction probability of the functional label, and the argmax method is used to select the optimal label, which greatly reduces the prediction complexity and ambiguity.

[0161] 3. Autoregressive parameter generation and dynamic termination mechanism: Parameter generation gradually generates the parameter sequence of the objective function through the autoregressive method, and combines the context information to ensure the rationality of the parameter configuration; introduce a special termination marker<type_end> Implement dynamic stopping, optimize generation efficiency, and avoid invalid calculations.

[0162] 4. Joint modeling and optimization: Function selection and parameter generation are uniformly processed through joint probabilistic modeling to complete the entire process from user query to function call; a multi-task learning framework is proposed to design a shared model structure and weighted loss function for function selection and parameter generation to improve the model's generalization ability and adaptability.

[0163] 5. High-quality data sets and optimization strategies: Build optimized data sets covering multiple scenarios and multiple tasks, combine data enhancement and small sample learning strategies to improve the model's adaptability to long-tail scenarios and natural language queries. Improve training efficiency and reasoning performance through step-by-step training strategies (pre-training and fine-tuning) and reasoning optimization (such as beam search and dynamic stopping).

[0164] Through the above-mentioned technical solution, this application significantly improves the efficiency and accuracy of function calls, solves the error accumulation problem caused by multi-model separation in traditional methods, and provides a unified and reliable technical solution for function call scenarios of intelligent systems.

[0165] Figure 4 FIG. 1 is a schematic diagram of a structure of a function calling device provided in an embodiment of the present application; Figure 4 As shown, the function calling device includes:

[0166] A function library construction module 410 is used to construct a function library and assign a unique function tag to each function in the function library;

[0167] Semantic information acquisition module 420, used to acquire semantic information of user query text;

[0168] The target function acquisition module 430 is used to acquire the corresponding target function from the function library according to the semantic information and the function tag of each function;

[0169] A parameter sequence generating module 440, configured to generate a corresponding parameter sequence based on the semantic information and the objective function;

[0170] The function execution module 450 is used to execute the target function based on the parameter sequence.

[0171] In one embodiment, the objective function acquisition module 430 further includes:

[0172] A matching score obtaining unit, used to obtain a matching score between the user query text and each function tag according to the semantic information;

[0173] A prediction probability calculation unit, used to calculate the prediction probability of each function tag according to the matching score between the user query text and each function tag;

[0174] The objective function determination unit is used to determine the objective function according to the predicted probability of each functional marker.

[0175] In one embodiment, the matching score acquisition unit is also used to perform vector conversion on the semantic information to obtain a text vector representation; perform vector conversion on the function characteristics corresponding to each function tag to obtain a function vector representation; fuse the text vector representation with each function vector representation to obtain each fused vector; perform similarity calculation on each fused vector to obtain a matching score between the user query text and each function tag.

[0176] In one embodiment, the calculation formula for calculating the predicted probability of each functional marker is:

[0177]

[0178] Among them, P(fi|Q) represents the predicted probability of the i-th function tag, Q represents the user query text, s(Q,fi) represents the matching score between the user query text and the i-th function tag, N represents the total number of function tags, i,j=[1,2,…,N], and exp represents the exponential function.

[0179] In one embodiment, the objective function determination unit is further used to obtain the probability distribution of each function label according to the predicted probability of all function labels; based on the probability distribution of each function label, obtain the target function label with the largest probability value; and determine the objective function according to the target function label.

[0180] In one embodiment, the formula for generating the corresponding parameter sequence is:

[0181]

[0182] Among them, A represents the parameter sequence, a t represents the tth parameter marker, fm represents the function marker of the objective function, a ＜t represents the first t-1 parameter markers in the parameter sequence, and T represents the number of parameter markers in the parameter sequence.

[0183] In one embodiment, the apparatus further comprises:

[0184] The classification loss calculation module is used to obtain the function classification loss based on the cross entropy loss; its calculation formula is:

[0185]

[0186] The production loss calculation module is used to obtain the sequence generation loss based on the negative log-likelihood loss generated by the sequence; its calculation formula is:

[0187]

[0188] The total loss calculation module is used to obtain the total loss according to the function classification loss and the sequence generation loss. The specific formula is: L=αLclass+βLgen; wherein α and β are weight parameters.

[0189] Figure 5 A schematic diagram of the structure of a computer system suitable for implementing an electronic device of an embodiment of the present application is shown.

[0190] It should be noted that Figure 5 The computer system 1000 of the electronic device shown is only an example and should not bring any limitation to the functions and scope of use of the embodiments of the present application.

[0191] like Figure 5 As shown, the computer system 1000 includes a central processing unit (CPU) 1001, which can perform various appropriate actions and processes according to the program stored in the read-only memory (ROM) 1002 or the program loaded from the storage part 1008 to the random access memory (RAM) 1003, such as executing the method described in the above embodiment. In the RAM 1003, various programs and data required for system operation are also stored. The CPU 1001, the ROM 1002 and the RAM 1003 are connected to each other through the bus 1004. The input / output (I / O) interface 1005 is also connected to the bus 1004.

[0192] The following components are connected to the I / O interface 1005: an input section 1006 including a keyboard, a mouse, etc.; an output section 1007 including a cathode ray tube (CRT), a liquid crystal display (LCD), etc., and a speaker, etc.; a storage section 1008 including a hard disk, etc.; and a communication section 1009 including a network interface card such as a LAN (Local Area Network) card, a modem, etc. The communication section 1009 performs communication processing via a network such as the Internet. A drive 1010 is also connected to the I / O interface 1005 as needed. A removable medium 1011, such as a magnetic disk, an optical disk, a magneto-optical disk, a semiconductor memory, etc., is installed on the drive 1010 as needed so that a computer program read therefrom is installed into the storage section 1008 as needed.

[0193] In particular, according to an embodiment of the present application, the process described above with reference to the flowchart can be implemented as a computer software program. For example, an embodiment of the present application includes a computer program product, which includes a computer program carried on a computer-readable medium, and the computer program includes a computer program for executing the method shown in the flowchart. In such an embodiment, the computer program can be downloaded and installed from a network through a communication section 1009, and / or installed from a removable medium 1011. When the computer program is executed by a central processing unit (CPU) 1001, various functions defined in the system of the present application are executed.

[0194] It should be noted that the computer-readable medium shown in the embodiment of the present application can be a computer-readable signal medium or a computer-readable storage medium or any combination of the above two. The computer-readable storage medium can be, for example, an electrical, magnetic, optical, electromagnetic, infrared, or semiconductor system, device or device, or any combination of the above. More specific examples of computer-readable storage media can include, but are not limited to: an electrical connection with one or more wires, a portable computer disk, a hard disk, a random access memory (RAM), a read-only memory (ROM), an erasable programmable read-only memory (EPROM), a flash memory, an optical fiber, a portable compact disk read-only memory (CD-ROM), an optical storage device, a magnetic storage device, or any suitable combination of the above. In the present application, a computer-readable storage medium can be any tangible medium containing or storing a program, which can be used by an instruction execution system, device or device or used in combination with it. In the present application, a computer-readable signal medium can include a data signal propagated in a baseband or as a part of a carrier wave, wherein a computer-readable computer program is carried. Such propagated data signals may take a variety of forms, including but not limited to electromagnetic signals, optical signals, or any suitable combination of the above. Computer-readable signal media may also be any computer-readable medium other than computer-readable storage media, which may send, propagate, or transmit programs for use by or in conjunction with an instruction execution system, apparatus, or device. The computer program contained on the computer-readable medium may be transmitted using any appropriate medium, including but not limited to: wireless, wired, etc., or any suitable combination of the above.

[0195] The flowchart and block diagram in the accompanying drawings illustrate the possible architecture, functions and operations of the system, method and computer program product according to various embodiments of the present application. Wherein, each box in the flowchart or block diagram can represent a module, a program segment, or a part of the code, and the above-mentioned module, program segment, or a part of the code contains one or more executable instructions for realizing the specified logical function. It should also be noted that in some alternative implementations, the functions marked in the box can also occur in a different order from the order marked in the accompanying drawings. For example, two boxes represented in succession can actually be executed substantially in parallel, and they can sometimes be executed in the opposite order, depending on the functions involved. It should also be noted that each box in the block diagram or flowchart, and the combination of boxes in the block diagram or flowchart can be implemented with a dedicated hardware-based system that performs a specified function or operation, or can be implemented with a combination of dedicated hardware and computer instructions.

[0196] The units involved in the embodiments described in this application may be implemented by software or hardware, and the units described may also be set in a processor. The names of these units do not, in some cases, constitute limitations on the units themselves.

[0197] The above content is only a preferred exemplary embodiment of the present application and is not intended to limit the implementation scheme of the present application. A person skilled in the art can easily make corresponding changes or modifications based on the main concept and spirit of the present application. Therefore, the scope of protection of the present application shall be based on the scope of protection required by the claims.

Claims

1. A function calling method, characterized in that: The method comprises: Build a function library and assign a unique function tag to each function in the function library; Obtaining semantic information of user query text; According to the semantic information and the function tag of each function, a corresponding target function is obtained from a function library; Based on the semantic information and the objective function, generating a corresponding parameter sequence; The objective function is performed based on the parameter sequence.

2. The method according to claim 1, characterized in that According to the semantic information and the functional tag of each function, the corresponding target function is obtained from the function library, including: According to the semantic information, obtaining a matching score between the user query text and each function tag; Calculate the prediction probability of each function tag based on the matching score between the user query text and each function tag; The objective function is determined according to the predicted probability of each functional marker.

3. The method according to claim 2, characterized in that Obtaining a matching score between the user query text and each function tag according to the semantic information includes: Convert the semantic information into a vector to obtain a text vector representation; Perform vector conversion on the function characteristics corresponding to each function label to obtain the function vector representation; The text vector representation is respectively fused with each function vector representation to obtain each fused vector; The similarity is calculated for each fusion vector to obtain the matching score between the user query text and each function tag.

4. The method according to claim 2, characterized in that: According to the matching score between the user query text and each function tag, the calculation formula for calculating the prediction probability of each function tag is: Among them, P(fi|Q) represents the predicted probability of the i-th function tag, Q represents the user query text, s(Q,fi) represents the matching score between the user query text and the i-th function tag, N represents the total number of function tags, i,j=[1,2,…,N], and exp represents the exponential function.

5. The method according to claim 2, characterized in that: Determining the objective function according to the predicted probability of each functional marker includes: According to the predicted probabilities of all functional markers, the probability distribution of each functional marker is obtained; Based on the probability distribution of each function marker, obtaining a target function marker with a maximum probability value; The objective function is determined according to the objective function label.

6. The method according to any one of claims 1 to 5, characterized in that: Based on the semantic information and the objective function, the formula for generating the corresponding parameter sequence is: Among them, A represents the parameter sequence, a t represents the tth parameter marker, fm represents the function marker of the objective function, a ＜t represents the first t-1 parameter markers in the parameter sequence, and T represents the number of parameter markers in the parameter sequence.

7. The method according to claim 1, characterized in that The method further comprises: According to the cross entropy loss, the function classification loss is obtained; its calculation formula is: According to the negative log-likelihood loss of sequence generation, the sequence generation loss is obtained; its calculation formula is: According to the function classification loss and the sequence generation loss, the total loss is obtained, and the specific formula is: L=αLclass+βLgen; wherein α and β are weight parameters.

8. A function calling device, characterized in that: The device comprises: A function library building module is used to build a function library and assign a unique function tag to each function in the function library; A semantic information acquisition module is used to acquire the semantic information of the user's query text; An objective function acquisition module, used to acquire a corresponding objective function from a function library according to the semantic information and a function tag of each function; A parameter sequence generation module, used to generate a corresponding parameter sequence based on the semantic information and the objective function; A function execution module is used to execute the target function based on the parameter sequence.

9. An electronic device, characterized in that: include: processor; as well as A memory for storing executable instructions of the processor; wherein the processor is configured to execute the executable instructions to enable the electronic device to implement the prompt injection defense method as described in any one of claims 1 to 7.

10. An electronic device, characterized in that: include: processor; as well as A memory for storing executable instructions of the processor; wherein the processor is configured to execute the executable instructions to enable the electronic device to implement the function calling method as described in any one of claims 1 to 7.

Images