Interface calling method and device, computer device and storage medium

Abstract

The embodiment of the application belongs to the field of data processing, and relates to an interface calling method and device, computer equipment and a storage medium. The method comprises the following steps: performing natural language processing on user request text information to obtain request semantic representation and key entity information; performing semantic matching on the request semantic representation and the key entity information according to an interface knowledge graph to obtain a target program interface document; performing structural analysis and information extraction on the target program interface document to obtain document key information; generating code based on a code generation model according to the document key information and the request semantic representation to obtain target calling code; testing the target calling code to obtain a code test result; adjusting the code generation model according to the code test result to generate adjusted target code, which is applied to the target program interface for interface calling. The application can accurately and effectively call an application program interface according to user input request text.

Description

Technical Field

[0001] The present application relates to the field of data processing technology, specifically to the field of digital medicine, and more particularly to an interface calling method, apparatus, computer equipment, and storage medium. Background Art

[0002] In the fields of fintech and digital healthcare, with the rapid development of artificial intelligence and big data technologies, the need to generate API call information based on natural language requests is becoming increasingly urgent. This is not limited to the automated operation of financial trading systems, such as robo-advisory and risk management, but also involves digital healthcare scenarios such as medical diagnosis assistance and medical record management. However, achieving this presents significant technical challenges.

[0003] Users may submit complex and varied requests in natural language, such as "Query this month's credit card spending total" or "Get Zhang San's latest physical examination report." Accurately matching these requests to corresponding API documents is a primary challenge, as API documents are often numerous and come in a variety of formats, ranging from RESTful to SOAP. Furthermore, even if a match is successful, accurately generating the API call information is a significant challenge. Problems such as missing parameters, incorrect call order, and data type mismatches frequently occur, resulting in API call results that differ significantly from expectations. Summary of the Invention

[0004] The purpose of the embodiments of the present application is to propose an interface calling method, apparatus, computer equipment and storage medium to solve the problem of being unable to perform accurate and effective application program interface calls based on input request text.

[0005] In order to solve the above technical problems, the embodiment of the present application provides an interface calling method, which adopts the following technical solution:

[0006] Obtaining user request text information, performing natural language processing on the user request text information, and obtaining request semantic representation and key entity information;

[0007] Perform semantic matching on the request semantic representation and the key entity information according to a pre-built interface knowledge graph to obtain a target program interface document;

[0008] Performing structured parsing and information extraction on the target program interface document to obtain key information of the document;

[0009] Generate code based on the document key information and the request semantic representation based on a pre-trained code generation model to obtain the target call code;

[0010] Performing static analysis and dynamic testing on the target calling code to obtain code test results;

[0011] The code generation model is adjusted according to the code test result to obtain a valid code generation model, and an adjusted target code is generated according to the valid code generation model, and the adjusted target code is applied to the target program interface for interface calling.

[0012] Furthermore, the step of performing natural language processing on the user request text information to obtain the request semantic representation and key entity information specifically includes:

[0013] Perform word segmentation processing on the user request text information based on a preset word segmentation algorithm to obtain request keywords;

[0014] Performing part-of-speech tagging on the request keyword based on a pre-built part-of-speech tagging model to obtain a tagged keyword;

[0015] Performing dependency analysis on the annotated keywords to obtain keyword dependency relationships;

[0016] Constructing a semantic representation graph according to the request keywords and the keyword dependencies, and using the semantic representation graph as the request semantic representation;

[0017] Key entity recognition is performed on the semantic representation graph to obtain the key entity information.

[0018] Furthermore, the step of performing semantic matching on the request semantic representation and the key entity information based on the pre-built interface knowledge graph to obtain the target program interface document specifically includes:

[0019] Extracting a semantic vector representation of a corresponding node from the interface knowledge graph according to the key entity information;

[0020] Calculating the similarity between the semantic vector representation and the request semantic representation to obtain a similarity score;

[0021] Sort the nodes in the interface knowledge graph according to the similarity scores to obtain the most relevant target node;

[0022] The target program interface document is extracted from a preset document database according to the most relevant target node.

[0023] Furthermore, the step of performing structured parsing and information extraction on the target program interface document to obtain key information of the document specifically includes:

[0024] Preprocessing the target program interface document to obtain a valid program interface document;

[0025] Performing semantic analysis on the valid program interface document to obtain key sentences and key paragraphs of the document;

[0026] The key sentences and key paragraphs of the document are structurally represented to obtain the key information of the document.

[0027] Furthermore, the step of generating code based on the pre-trained code generation model according to the document key information and the request semantic representation to obtain the target call code specifically includes:

[0028] Matching is performed in a predefined rule base according to the request semantic representation to obtain parameter type matching rules, mandatory parameter checking rules, and return value processing rules;

[0029] Extracting a parameter list from the document key information, and performing type checking and conversion processing on the parameter list according to the parameter type matching rule to obtain a valid parameter list;

[0030] Check the valid parameter list according to the mandatory parameter checking rule to obtain valid parameter information;

[0031] Identifying the target code type corresponding to the request semantic representation, and inputting the target code type and the valid parameter information into the code generation model to obtain an initial call code;

[0032] Add return value processing logic to the initial calling code according to the return value processing rule to obtain the target calling code.

[0033] Furthermore, the step of performing static analysis and dynamic testing on the target calling code to obtain code test results specifically includes:

[0034] Determine whether the syntax of the target calling code is correct according to a static analysis method;

[0035] If the syntax of the target calling code is correct, a preset test case set is obtained, and the test case set is executed to dynamically run the target calling code to obtain the code test result.

[0036] Furthermore, the step of adjusting the code generation model according to the code test result to obtain a valid code generation model specifically includes:

[0037] Obtaining a preset standard test result, and determining whether the code test result meets the standard test result;

[0038] If the code test result meets the standard test result, the code generation model corresponding to the code test result is used as the valid code generation model;

[0039] If the code test result does not meet the standard test result, the difference item between the code test result and the standard test result is obtained, and correction information is extracted from a preset difference correction table according to the difference item, the code generation model is adjusted based on the correction information, and the adjusted code test result is re-obtained. The steps of obtaining the difference item to adjusting the code generation model are repeated until the adjusted code test result meets the standard test result, thereby obtaining the valid code generation model.

[0040] In order to solve the above technical problems, the embodiment of the present application further provides an interface calling device, which adopts the following technical solution:

[0041] An information processing module is used to obtain user request text information, perform natural language processing on the user request text information, and obtain request semantic representation and key entity information;

[0042] A semantic matching module is used to perform semantic matching on the request semantic representation and the key entity information based on a pre-built interface knowledge graph to obtain a target program interface document;

[0043] An information extraction module is used to perform structured analysis and information extraction on the target program interface document to obtain key information of the document;

[0044] A code generation module is used to generate code based on the document key information and the request semantic representation based on a pre-trained code generation model to obtain a target call code;

[0045] A code testing module is used to perform static analysis and dynamic testing on the target calling code to obtain code testing results;

[0046] A code adjustment module is used to adjust the code generation model according to the code test results to obtain a valid code generation model, generate an adjustment target code according to the valid code generation model, and apply the adjustment target code to the target program interface for interface call.

[0047] In order to solve the above technical problems, the embodiment of the present application further provides a computer device, which adopts the following technical solution:

[0048] A computer device includes a memory and a processor, wherein the memory stores computer-readable instructions, and the processor implements the steps of any one of the above interface calling methods when executing the computer-readable instructions.

[0049] In order to solve the above technical problems, the embodiment of the present application further provides a computer-readable storage medium, which adopts the following technical solution:

[0050] A computer-readable storage medium stores computer-readable instructions, which, when executed by a processor, implement the steps of the interface calling method as described in any one of the above items.

[0051] Compared with the prior art, the embodiment of the present application has the following main beneficial effects: the embodiment obtains user request text information, performs natural language processing on the user request text information, obtains request semantic representation and key entity information; performs semantic matching on the request semantic representation and the key entity information according to the pre-built interface knowledge graph, obtains the target program interface document; performs structured parsing and information extraction on the target program interface document to obtain document key information; performs code generation based on the document key information and the request semantic representation based on the pre-trained code generation model to obtain target call code; performs static analysis and dynamic testing on the target call code to obtain code test results; adjusts the code generation model according to the code test results to obtain an effective code generation model, generates an adjusted target code according to the effective code generation model, and applies the adjusted target code to the target program interface for interface call. Thus, accurate and effective application program interface calls are effectively realized according to the request text input by the user, so as to improve the accuracy and effectiveness of interface calls. BRIEF DESCRIPTION OF THE DRAWINGS

[0052] In order to more clearly illustrate the solutions in this application, a brief introduction will be given below to the drawings required for use in the description of the embodiments of this application. Obviously, the drawings described below are some embodiments of this application. For ordinary technicians in this field, other drawings can be obtained based on these drawings without any creative work.

[0053] Figure 1 is an exemplary system architecture diagram to which the present application may be applied;

[0054] Figure 2 A flowchart of an embodiment of an interface calling method according to the present application;

[0055] Figure 3 yes Figure 2 A flowchart of a specific implementation of step S10;

[0056] Figure 4 yes Figure 2 A flowchart of a specific implementation of step S20;

[0057] Figure 5 yes Figure 2 A flowchart of a specific implementation of step S30;

[0058] Figure 6yes Figure 2 A flowchart of a specific implementation of step S40;

[0059] Figure 7 yes Figure 2 A flowchart of a specific implementation of step S50;

[0060] Figure 8 yes Figure 2 A flowchart of a specific implementation of step S60;

[0061] Figure 9 This is a structural diagram of an embodiment of an interface calling device according to the present application;

[0062] Figure 10 It is a structural diagram of an embodiment of a computer device according to the present application. DETAILED DESCRIPTION

[0063] Unless otherwise defined, all technical and scientific terms used herein have the same meanings as commonly understood by those skilled in the art to which this application belongs. The terms used in the specification of the application are for the purpose of describing specific embodiments only and are not intended to limit this application. The terms "including" and "having" and any variations thereof in the specification and claims of this application and the above-mentioned drawings are intended to cover non-exclusive inclusions. The terms "first", "second", etc. in the specification and claims of this application or the above-mentioned drawings are used to distinguish different objects, not to describe a specific order.

[0064] References to "embodiments" herein mean that a particular feature, structure, or characteristic described in connection with the embodiments may be included in at least one embodiment of the present application. The appearance of this phrase in various places in the specification does not necessarily refer to the same embodiment, nor does it refer to unrelated or alternative embodiments that are mutually exclusive of other embodiments. It is understood, both explicitly and implicitly, by those skilled in the art that the embodiments described herein may be combined with other embodiments.

[0065] In order to enable those skilled in the art to better understand the solution of the present application, the technical solution in the embodiments of the present application will be clearly and completely described below in conjunction with the accompanying drawings.

[0066] like Figure 1 As shown, system architecture 100 may include a terminal device 101, a network 102, and a server 103. Terminal device 101 may be a laptop computer 1011, a tablet computer 1012, or a mobile phone 1013. Network 102 is a medium for providing a communication link between terminal device 101 and server 103. Network 102 may include various connection types, such as wired or wireless communication links or fiber optic cables.

[0067] The user can use the terminal device 101 to interact with the server 103 via the network 102 to receive or send messages, etc. Various communication client applications can be installed on the terminal device 101, such as web browser applications, shopping applications, search applications, instant messaging tools, email clients, social platform software, etc.

[0068] The terminal device 101 can be various electronic devices with a display screen and supporting web browsing. In addition to the laptop computer 1011, tablet computer 1012 or mobile phone 1013, the terminal device 101 can also be an e-book reader, an MP3 player (Moving Picture Experts Group Audio Layer III), an MP4 (Moving Picture Experts Group Audio Layer IV) player, a laptop computer and a desktop computer, etc.

[0069] The server 103 may be a server that provides various services, such as a background server that provides support for web pages displayed on the terminal device 101 .

[0070] It should be noted that the interface calling method provided in the embodiment of the present application is generally executed by a server / terminal device, and accordingly, the interface calling device is generally set in the server / terminal device.

[0071] It should be understood that Figure 1 The number of terminal devices, networks and servers in the embodiment is merely illustrative. Any number of terminal devices, networks and servers may be provided as required.

[0072] Continue to refer Figure 2 , shows a flow chart of an embodiment of the interface calling method according to the present application. The interface calling method includes the following steps:

[0073] Step S10: obtaining user request text information, performing natural language processing on the user request text information, and obtaining request semantic representation and key entity information;

[0074] In this embodiment, the user request text information is the request text submitted by the user in the form of natural language, for example, the query text paragraph entered by the user in the search engine. The natural language processing of the user request text information includes word segmentation, part-of-speech tagging, dependency analysis, and semantic representation graph construction. After the above-mentioned natural language processing is performed on the user request text information, a request semantic representation that displays the semantic information and structure of the user request and key entity information reflecting the corresponding important entities in the user request text information are obtained.

[0075] Step S20: semantically matching the request semantic representation with the key entity information based on the pre-built interface knowledge graph to obtain a target program interface document;

[0076] In this embodiment, the interface knowledge graph includes structured information such as the name, function description, parameter description, and return value type of the application program interface (API). Its nodes represent entities such as API, parameters, and return value type, while edges represent the relationship between these entities (such as which parameters the API contains, what the parameter types are, etc.). Semantic matching is achieved by identifying the similarity between the semantic vector representation corresponding to the node in the interface knowledge graph and the request semantic representation. The most relevant target node obtained after semantic matching of the target program interface document is matched and extracted in the preset document database.

[0077] Step S30, performing structured parsing and information extraction on the target program interface document to obtain key document information;

[0078] In this embodiment, information extraction refers to semantic parsing of the target API document, while structured parsing refers to the structured representation of the information obtained after semantic parsing. Information extraction includes sentence segmentation, keyword extraction, semantic role labeling, and key sentence and paragraph identification, while structured representation includes key information extraction, data cleaning, and structured storage. By performing the above steps of structured parsing and information extraction, key document information can be effectively obtained.

[0079] Step S40, performing code generation based on the pre-trained code generation model according to the document key information and the request semantic representation to obtain the target call code;

[0080] In this embodiment, the pre-trained code generation model can adopt a sequence-to-sequence (Seq2Seq) model, such as the Transformer's GPT model. By passing the extracted document key information and request semantic representation as input to the pre-trained code generation model, the model first encodes the input information and then gradually decodes and generates code, thus implementing a sequence-to-sequence process to obtain the target call code.

[0081] Step S50, performing static analysis and dynamic testing on the target calling code to obtain code test results;

[0082] In this embodiment, static analysis is a method for identifying potential problems by examining the syntax, structure, data flow, control flow, and other information of the code without executing it. Static analysis can be implemented using static analysis tools. Dynamic testing verifies the functionality, performance, and stability of the code by executing it. It uses pre-designed test cases to execute the target calling code, thereby collecting code test results.

[0083] Step S60 , adjusting the code generation model according to the code test result to obtain a valid code generation model, generating an adjusted target code according to the valid code generation model, and applying the adjusted target code to a target program interface for interface calling.

[0084] In this embodiment, the code generation model is adjusted based on the differences between the code test results and the standard test results. When the adjustment is completed, the document key information and request semantic representation are input into the adjusted valid code generation model to obtain the adjusted target code, and then the adjusted target code is applied to the target program interface of the system to realize the interface call function.

[0085] In this embodiment, the above method can be applied to a medical service system, in which a target program interface in the system is called by inputting a request text. Specifically, in this embodiment, the medical service system can be one or more of a medical insurance system and a disease insurance system. The interface knowledge graph is a graph information containing the application program interface (API) of the medical system. The interface knowledge graph and the code generation model are stored in the medical insurance system and the disease insurance system and obtained from the database of the above system. The adjusted target code is generated by the above system through processing of the method of this embodiment and applied to the target program interface of the above system for calling.

[0086] This embodiment obtains user request text information, performs natural language processing on the user request text information, obtains request semantic representation and key entity information; performs semantic matching on the request semantic representation and the key entity information based on a pre-built interface knowledge graph to obtain a target program interface document; performs structured parsing and information extraction on the target program interface document to obtain document key information; generates code based on the document key information and the request semantic representation based on a pre-trained code generation model to obtain target call code; performs static analysis and dynamic testing on the target call code to obtain code test results; adjusts the code generation model based on the code test results to obtain an effective code generation model, generates an adjusted target code based on the effective code generation model, and applies the adjusted target code to the target program interface for interface calling. This effectively implements accurate and effective application program interface calling based on the request text input by the user, thereby improving the accuracy and effectiveness of interface calling.

[0087] refer to Figure 3 In some optional implementations of this embodiment, step S10 includes the following steps:

[0088] Step S101, performing word segmentation processing on the user request text information based on a preset word segmentation algorithm to obtain request keywords;

[0089] In this embodiment, the preset word segmentation algorithm can adopt a dictionary-based word segmentation algorithm, such as the maximum matching method, by pre-building a dictionary containing common words, and then scanning the text of the user's request text information from left to right, each time trying to match the longest word starting from the current position and not exceeding the preset maximum length. If the match is successful, the word is used as part of the word segmentation result, and the matching continues from the next character; if the match fails, the matching length is gradually reduced until a matching word is found or the minimum matching length (usually 1 character) is reached. When the above matching steps are completed, the request keyword is obtained.

[0090] Step S102: performing part-of-speech tagging on the request keyword based on a pre-built part-of-speech tagging model to obtain a tagged keyword;

[0091] In the embodiment, the pre-constructed part-of-speech tagging model can adopt a Hidden Markov Model (HMM), and a labeled corpus (i.e., a text with known words and their corresponding parts of speech) is used to train the HMM model. The steps of part-of-speech tagging based on the HMM model include defining a state set: in the HMM model, each state corresponds to a part of speech. Therefore, a state set containing all possible parts of speech needs to be defined. Defining an observation set: the observation set contains all possible words. Initializing model parameters: using the trained HMM model parameters. Calculating the optimal path: for a given sequence of request keywords, the most likely sequence of part-of-speech tagging (i.e., the optimal path) is calculated using dynamic programming methods such as the Viterbi algorithm. In this process, the probability of each state (part of speech) at each position needs to be calculated, and the path with the highest probability is selected as the final part-of-speech tagging result. Generating labeled keywords: combining the calculated part-of-speech tagging sequence with the sequence of request keywords to generate a list of labeled keywords, each of which contains an original word and a corresponding part-of-speech tag.

[0092] In step S103, dependency relationship analysis is performed on the labeled keywords to obtain keyword dependency relationships.

[0093] In the embodiment, dependency relationship analysis is a task of identifying the dependency relationships between words in a sentence. The dependency relationship analysis can adopt a rule-based analysis method. The steps of dependency relationship analysis on the labeled keywords specifically include traversing the list of labeled keywords and attempting to match each word with a rule in the rule set. When a word successfully matches a rule, the dependency relationship between the word and its dependent word is constructed according to the definition of the rule. The dependency relationship includes determining the type of dependency relationship (such as subject-predicate relationship, verb-object relationship, etc.) and the dependency direction (such as which word depends on which word). The dependency relationship analysis on the labeled keywords is performed through the above dependency relationship analysis steps to obtain keyword dependency relationships.

[0094] In step S104, a semantic representation graph is constructed according to the request keywords and the keyword dependency relationships, and the semantic representation graph is taken as the request semantic representation.

[0095] In the embodiment, the request keywords are taken as nodes of the semantic representation graph, the keyword dependency relationships are taken as edges of the semantic representation graph, and a graph structure representation representing the semantic structure of the user request is constructed, which is the semantic representation graph.

[0096] In step S105, key entity recognition is performed on the semantic representation graph to obtain the key entity information.

[0097] In this embodiment, a key entity recognition algorithm is used to identify nodes (i.e., request keywords) in the semantic representation graph to obtain words or phrases with specific meaning and importance, which are key entity information. The key entity recognition algorithm can adopt a rule-based approach to match each node in the semantic representation graph by building a rule library with lexical rules, syntactic rules, contextual rules, etc. to identify key entity information.

[0098] This embodiment performs word segmentation processing on the user request text information based on a preset word segmentation algorithm to obtain request keywords; performs part-of-speech tagging on the request keywords based on a pre-built part-of-speech tagging model to obtain tagged keywords; performs dependency analysis on the tagged keywords to obtain keyword dependencies; constructs a semantic representation graph based on the request keywords and the keyword dependencies, and uses the semantic representation graph as the request semantic representation; and performs key entity recognition on the semantic representation graph to obtain key entity information. This effectively extracts the request semantic representation and key entity information based on the keyword parts-of-speech and dependency relationships in the user request text information, facilitating subsequent semantic matching processing.

[0099] refer to Figure 4 In some optional implementations of this embodiment, step S20 includes the following steps:

[0100] Step S201: extracting a semantic vector representation of a corresponding node from the interface knowledge graph according to the key entity information;

[0101] In this embodiment, the extraction of semantic vector representation includes knowledge graph node positioning and semantic vector extraction, wherein knowledge graph node positioning includes node search: in the interface knowledge graph, key entity information is used as a query condition to search for nodes that match it, which can be achieved by matching the labels, attributes or relationships of the nodes in the graph. Node confirmation: from the search results, the node that best matches the key entity information is confirmed based on contextual information or additional verification steps. Semantic vector extraction includes vector representation selection: on the confirmed node, its semantic vector representation is selected or calculated, and the semantic vector representation of the node can be obtained by using a pre-trained word vector model (such as Word2Vec, BERT, etc.) or graph embedding technology (such as TransE, DeepWalk, etc.).

[0102] Step S202, calculating the similarity between the semantic vector representation and the request semantic representation to obtain a similarity score;

[0103] In this embodiment, the cosine similarity is calculated for the semantic vector representation and the request semantic representation to obtain the corresponding similarity score. Cosine similarity is a commonly used measurement method that evaluates the similarity between two vectors by calculating the cosine value of the angle between them in a multidimensional space. Before calculating the cosine similarity, the vectors usually need to be normalized to ensure that they have the same scale when calculating. The normalization formula is: V ^ =V / ∥V∥, where ∥V∥ is the modulus (length) of the vector. The formula for calculating cosine similarity is: cos(θ)=V ^ sem·V ^ req / ∥V ^ sem∥∥V ^ req∥. However, since the vector has been normalized, the modulus is 1, and the formula can be simplified to: cos(θ)=V ^ sem·V ^ req. The dot product (·) here represents the sum of the products of the corresponding elements of the two vectors. The cosine similarity obtained after the above calculation ranges from [-1, 1], where values ​​closer to 1 indicate that the two vectors are more semantically similar; values ​​closer to -1 indicate that the two vectors are more semantically opposite; and values ​​close to 0 indicate that the two vectors are relatively independent or unrelated semantically.

[0104] Step S203, sorting the nodes in the interface knowledge graph according to the similarity scores to obtain the most relevant target node;

[0105] In this embodiment, the nodes are sorted from high to low according to the calculated similarity scores corresponding to the nodes to obtain a similarity score sorting table, and then the first similarity score with the highest score is selected from the similarity score sorting table, and the node corresponding to the first similarity score is determined as the most relevant target node.

[0106] Step S204: extracting the target program interface document from a preset document database according to the most relevant target node.

[0107] In this embodiment, the preset document database is a preset database storing detailed documents of various program interfaces. According to the information of the most relevant target node, a traversal query is performed in the preset document database as a query condition to extract the corresponding target program interface document.

[0108] This embodiment extracts the semantic vector representation of the corresponding node from the interface knowledge graph based on the key entity information; calculates the similarity between the semantic vector representation and the request semantic representation to obtain a similarity score; sorts the nodes in the interface knowledge graph based on the similarity score to obtain the most relevant target node; and extracts the target program interface document from a preset document database based on the most relevant target node. This effectively obtains the target program structure document, facilitating subsequent structured parsing and information extraction steps.

[0109] refer to Figure 5 In some optional implementations of this embodiment, step S30 includes the following steps:

[0110] Step S301, pre-processing the target program interface document to obtain a valid program interface document;

[0111] In this embodiment, the preprocessing of the target program interface document includes denoising: removing irrelevant content from the document; formatting: unifying the document's layout and format to ensure clarity and consistency; and stop word removal: removing common words that contribute little to the document's key information, such as "的" (de) and "是".

[0112] Step S302: semantically analyze the valid program interface document to obtain key sentences and key paragraphs of the document;

[0113] In this embodiment, semantic analysis includes: text sentence segmentation, keyword extraction, semantic role labeling, key sentence and paragraph identification, etc., among which sentence segmentation is: dividing the document into independent sentences to facilitate subsequent analysis. Keyword extraction is: using natural language processing technology to extract keywords in the document. These keywords are usually closely related to the functions, parameters, return values, etc. of the interface. Semantic role labeling is: analyzing the semantic relationships in the sentences, identifying key components such as the subject, predicate, object, and the logical relationships between them. Key sentence and paragraph identification is: based on the results of keyword and semantic role labeling, identifying sentences and paragraphs containing key information. Through the above semantic analysis steps, the key sentences and key paragraphs of the document are effectively obtained.

[0114] Step S303: Structure the key sentences and key paragraphs of the document to obtain the key information of the document.

[0115] In this embodiment, structured representation includes key information extraction, data cleaning, structured storage, etc. Information extraction is to extract key information such as the interface name, function description, parameter list, return value type, etc. from key sentences and paragraphs. Data cleaning is to verify and clean the extracted information to ensure data accuracy and consistency. Structured storage is to store the cleaned information in a structured manner, such as JSON, XML, etc., for subsequent use. By performing the structured representation processing including the above steps on the key sentences and key paragraphs of the document, the key information of the document can be effectively obtained.

[0116] This embodiment obtains a valid program interface document by preprocessing the target program interface document; performs semantic analysis on the valid program interface document to obtain document key sentences and document key paragraphs; and performs structured representation on the document key sentences and document key paragraphs, thereby effectively obtaining document key information that structurally represents the key sentences and key paragraphs included in the target program structure document, to facilitate subsequent code generation processing.

[0117] Continue to refer Figure 6 In some optional implementations of this embodiment, step S40 includes the following steps:

[0118] Step S401: Matching is performed in a predefined rule base according to the request semantic representation to obtain parameter type matching rules, mandatory parameter checking rules, and return value processing rules;

[0119] In this embodiment, the request semantic representation is used as a query condition to perform a traversal match in a predefined rule base to obtain parameter type matching rules, mandatory parameter checking rules, and return value processing rules. Parameter type matching rules: These rules determine the data type that each parameter in the request should conform to. Mandatory parameter checking rules: These rules list the parameters that must be included in the request. Return value processing rules: These rules describe how to handle the return value of the called function or API.

[0120] Step S402: extracting a parameter list from the document key information, and performing type checking and conversion processing on the parameter list according to the parameter type matching rule to obtain a valid parameter list;

[0121] In the embodiment, the content of the document key information is read, and information related to the parameters (including parameter name, type, description, default value, etc.) is identified from the read information through a regular expression, and the identified parameter information is sorted into a parameter list. The parameter list is a data structure (such as an array, a dictionary, or an object), and each element in the data structure represents a parameter. The parameter type matching rule is a parameter type matching mapping table, and type checking of each parameter in the parameter list can be implemented by verifying whether the actual data type of the parameter matches the expected data type. Parameters with type mismatch are converted through the parameter type matching mapping table, and the type conversion includes converting a string into an integer, a floating-point number, a date, etc.

[0122] In step S403, the valid parameter list is checked according to the mandatory parameter checking rule, and valid parameter information is obtained.

[0123] In the embodiment, the step of checking the valid parameter list includes the following steps: traversing the parameter list: traversing each parameter in the valid parameter list, and checking whether it is a mandatory parameter. Matching the mandatory parameter: for each mandatory parameter, checking whether it exists in the valid parameter list. If the parameter exists, further checking whether its value meets the limit conditions (such as data type, value range, etc.) defined in the rule. Recording the missing or non-compliant parameter: if it is found that a certain mandatory parameter does not exist in the valid parameter list, or its value does not meet the rule requirements, recording this error. Filtering the valid parameter: according to the result of the mandatory parameter checking, filtering out the missing or non-compliant parameter from the valid parameter list, and taking the remaining parameters as the valid parameter information.

[0124] In step S404, the target code type corresponding to the request semantic representation is identified, and the target code type and the valid parameter information are input into the code generation model, and initial calling code is obtained.

[0125] In this embodiment, semantic analysis is performed on the request semantic representation to understand the intent of the request, and then a matching target code type is searched in a predefined code type mapping table or rule library based on the understood intent, wherein the target code type includes a programming language (such as Python, Java, JavaScript, etc.), a framework (such as Django, Spring, etc.), or a calling method of a specific API. By constructing an input data structure containing the target code type and valid parameter information, and inputting the input data structure into the code generation model to obtain the initial calling code output by the model, the code generation model can use a pre-trained sequence-to-sequence (Seq2Seq) model. The sequence-to-sequence model is a model commonly used in natural language processing tasks. It can convert a sequence (such as text) into another sequence (such as code). The sequence-to-sequence model can be specifically trained using a Transformer-based model (such as GPT).

[0126] Step S405: Add return value processing logic to the initial calling code according to the return value processing rule to obtain the target calling code.

[0127] In this embodiment, the initial call code is expanded according to the return value processing rules to add appropriate return value processing logic, where the return value processing logic includes error handling, result parsing, data conversion, etc. After the above return value processing logic is added to the initial call code, the final target call code is obtained.

[0128] This embodiment obtains parameter type matching rules, mandatory parameter checking rules, and return value processing rules by matching in a predefined rule library according to the request semantic representation; extracts a parameter list from the document key information, and performs type checking and conversion processing on the parameter list according to the parameter type matching rules to obtain a valid parameter list; checks the valid parameter list according to the mandatory parameter checking rules to obtain valid parameter information; identifies the target code type corresponding to the request semantic representation, and inputs the target code type and the valid parameter information into the code generation model to obtain an initial call code; adds return value processing logic to the initial call code according to the return value processing rules, thereby effectively obtaining the target call code generated based on the document key information and the request semantic representation, so as to improve the accuracy and effectiveness of the target call code and facilitate subsequent static analysis and dynamic test processing.

[0129] Continue to refer Figure 7 In some optional implementations of this embodiment, step S50 includes the following steps:

[0130] Step S501, judging whether the syntax of the target calling code is correct according to a static analysis method;

[0131] In this embodiment, static analysis is a method for discovering potential errors by checking the source code of the code without executing the code. The static analysis step can be performed by a static analysis tool. The static analysis performed by the static analysis tool includes word segmentation: dividing the code string into a series of tokens, which are usually keywords, identifiers, literals, operators and delimiters in the code. Constructing a syntax tree: Based on the results of lexical analysis, using grammar rules (usually defined in grammar files such as BNF, EBNF, etc.) to construct a syntax tree (AST, abstract syntax tree) of the code. Verifying the syntax tree: checking whether the syntax tree conforms to the grammatical rules of the target programming language. By traversing the syntax tree, it can be verified whether the type of each node, the number and type of subnodes, etc. are as expected. Verifying tags: checking whether each tag is legal, that is, whether they are valid components of the target programming language. This effectively realizes the judgment of whether the target call code is correct.

[0132] Step S502: If the syntax of the target calling code is correct, a preset test case set is obtained, and the test case set is executed to dynamically run the target calling code to obtain the code test result;

[0133] In this embodiment, the test case set is a set of preset test cases, which should cover the main functions and boundary cases of the code. By configuring the necessary test environment, including dependent libraries, database connections, file systems, etc., each test case in the test case set is executed using a test framework or tool. Each test case should contain input data and expected output. When executing each test case, the actual output and any exception or error information are recorded. The actual output is compared with the expected output to determine whether the test case passes. Based on the execution results of all test cases, the code test results are obtained. After obtaining the code test results, a code test result report can be generated based on the code test results. The test result report may include information such as the pass status of the test case, the reason for failure (if any), and code coverage.

[0134] Step S503: If the syntax of the target call code is incorrect, the target call code is input into a pre-trained syntax correction model for correction processing to obtain a corrected target substitute code, and whether the syntax of the corrected target call code is correct is re-judged until the syntax of the corrected target call code is correct.

[0135] In this embodiment, the grammar correction model can adopt a conditional random field (CRF), by annotating the grammatical errors of the collected sample codes (marking the location and type of the grammatical errors), and then training and optimizing the CRF model based on the annotated sample codes to obtain a pre-trained grammar correction model.

[0136] This embodiment determines whether the syntax of the target call code is correct based on a static analysis method. If the syntax of the target call code is correct, a preset test case set is obtained and executed to dynamically run the target call code to obtain the code test result. If the syntax of the target call code is incorrect, the target call code is input into a pre-trained syntax correction model for correction processing to obtain a corrected target substitute code, and the syntax of the corrected target call code is re-judged until the syntax of the corrected target call code is correct. This achieves effective analysis and testing of the target call code to obtain corresponding code test results, facilitating subsequent adjustment of the code generation model.

[0137] Continue to refer Figure 8 In some optional implementations of this embodiment, step S60 includes the following steps:

[0138] S601, obtaining a preset standard test result, and determining whether the code test result meets the standard test result;

[0139] In this embodiment, the standard test result is preset test result information. The various parameters in the standard test result correspond to the parameters of the code test result. The standard test result may include expected output: the output that the code should produce under specific input; performance indicators: such as execution time, memory usage, resource consumption, etc.; behavioral characteristics: such as whether the code throws specific exceptions, whether it handles all boundary conditions, etc.

[0140] S602, if the code test result meets the standard test result, taking the code generation model corresponding to the code test result as the valid code generation model;

[0141] In this embodiment, a code generation model whose code test results conform to standard test results is used as a valid code generation model to obtain a model that can effectively output qualified target calling code.

[0142] S603: If the code test result does not conform to the standard test result, the difference item between the code test result and the standard test result is obtained, and correction information is extracted from a preset difference correction table according to the difference item, and the code generation model is adjusted based on the correction information, and the adjusted code test result is re-obtained. The steps of obtaining the difference item to adjusting the code generation model are continuously repeated until the adjusted code test result conforms to the standard test result, thereby obtaining the valid code generation model.

[0143] In this embodiment, the code test results and the standard test results are compared one by one for each parameter to identify the difference items. Then, based on the identified difference items, correction information is extracted from a preset difference correction table, where the difference correction table can be a preset database or knowledge base containing common errors and their correction solutions. After obtaining the correction information containing the correction solution, the corresponding parameters and structure of the model are adjusted according to the correction information to obtain an adjusted code generation model. Then, based on the adjusted code generation model, continuous iteration is performed so that the adjusted code generation model can eventually output the target call code that meets the standard test results.

[0144] This embodiment obtains a preset standard test result to determine whether the code test result meets the standard test result; if the code test result meets the standard test result, the code generation model corresponding to the code test result is used as the effective code generation model; if the code test result does not meet the standard test result, the difference between the code test result and the standard test result is obtained, and correction information is extracted from a preset difference correction table based on the difference, and the code generation model is adjusted based on the correction information, and the adjusted code test result is obtained again. The steps of obtaining the difference and adjusting the code generation model are repeated continuously until the adjusted code test result meets the standard test result, thereby obtaining the effective code generation model. This effectively achieves accurate adjustment of the code generation model based on the difference between the code test result and the standard test result, thereby improving the adjustment efficiency of the code generation model and obtaining an effective code generation model that can output target call code that meets the standard test result.

[0145] Those skilled in the art will appreciate that all or part of the processes in the above-described method embodiments can be implemented by instructing related hardware via computer-readable instructions. The computer-readable instructions can be stored in a computer-readable storage medium, and when the program is executed, it can include the processes in the above-described method embodiments. The aforementioned storage medium can be a non-volatile storage medium such as a magnetic disk, an optical disk, a read-only memory (ROM), or a random access memory (RAM).

[0146] It should be understood that although the steps in the flowcharts of the accompanying drawings are shown in sequence as indicated by the arrows, these steps are not necessarily executed in the order indicated by the arrows. Unless otherwise specified herein, there is no strict order restriction on the execution of these steps, and they can be executed in other orders. Moreover, at least some of the steps in the flowcharts of the accompanying drawings may include multiple sub-steps or multiple stages, and these sub-steps or stages are not necessarily executed at the same time, but can be executed at different times, and their execution order is not necessarily sequential, but can be executed in turn or alternately with other steps or at least a portion of the sub-steps or stages of other steps.

[0147] Further references Figure 9 , as a response to the above Figure 1 In order to realize the method shown in the figure, the present application provides an embodiment of an interface calling device. Figure 1 Corresponding to the method embodiment shown, the device can be specifically applied to various electronic devices.

[0148] like Figure 9 As shown, the interface calling device 700 of this embodiment includes: an information processing module 701, a semantic matching module 702, an information extraction module 703, a code generation module 704, a code testing module 705, and a code adjustment module 706. Among them:

[0149] The information processing module 701 is used to obtain user request text information, perform natural language processing on the user request text information, and obtain request semantic representation and key entity information;

[0150] Semantic matching module 702, used to perform semantic matching on the request semantic representation and the key entity information based on the pre-built interface knowledge graph to obtain the target program interface document;

[0151] The information extraction module 703 is used to perform structured analysis and information extraction on the target program interface document to obtain key information of the document;

[0152] A code generation module 704 is configured to generate code based on the document key information and the request semantic representation based on a pre-trained code generation model to obtain a target call code;

[0153] A code testing module 705 is used to perform static analysis and dynamic testing on the target calling code to obtain code testing results;

[0154] The code adjustment module 706 is used to adjust the code generation model according to the code test result to obtain a valid code generation model, generate an adjusted target code according to the valid code generation model, and apply the adjusted target code to the target program interface for interface call.

[0155] By adopting the above-mentioned interface calling device, this embodiment can obtain user request text information, perform natural language processing on the user request text information, obtain request semantic representation and key entity information; perform semantic matching on the request semantic representation and the key entity information based on the pre-built interface knowledge graph to obtain the target program interface document; perform structured parsing and information extraction on the target program interface document to obtain document key information; perform code generation based on the document key information and the request semantic representation based on the pre-trained code generation model to obtain target call code; perform static analysis and dynamic testing on the target call code to obtain code test results; adjust the code generation model based on the code test results to obtain an effective code generation model, and generate adjusted target code based on the effective code generation model, and apply the adjusted target code to the target program interface for interface calling. In this way, accurate and effective application program interface calling is effectively achieved according to the request text input by the user, thereby improving the accuracy and effectiveness of interface calling.

[0156] To solve the above technical problems, the present application also provides a computer device. Figure 10 , Figure 10 This is a basic structural block diagram of the computer device in this embodiment.

[0157] The computer device 8 includes a memory 81, a processor 82, and a network interface 83 that are interconnected through a system bus. It should be noted that the figure only shows a computer device 8 with components 81-83, but it should be understood that it is not required to implement all the components shown, and more or fewer components can be implemented instead. Among them, those skilled in the art can understand that the computer device here is a device that can automatically perform numerical calculations and / or information processing according to pre-set or stored instructions, and its hardware includes but is not limited to microprocessors, application specific integrated circuits (ASICs), field-programmable gate arrays (FPGAs), digital signal processors (DSPs), embedded devices, etc.

[0158] The computer device may be a desktop computer, notebook computer, PDA, cloud server, etc. The computer device may interact with the user via a keyboard, mouse, remote control, touchpad, or voice control device.

[0159] The memory 81 includes at least one type of readable storage medium, including flash memory, hard disk, multimedia card, card-type memory (e.g., SD or DX memory), random access memory (RAM), static random access memory (SRAM), read-only memory (ROM), electrically erasable programmable read-only memory (EEPROM), programmable read-only memory (PROM), magnetic storage, magnetic disk, optical disk, etc. In some embodiments, the memory 81 can be an internal storage unit of the computer device 8, such as the hard disk or memory of the computer device 8. In other embodiments, the memory 81 can also be an external storage device of the computer device 8, such as a plug-in hard disk equipped on the computer device 8, a smart memory card (SMC), a secure digital (SD) card, a flash memory card, etc. Of course, the memory 81 can also include both the internal storage unit of the computer device 8 and its external storage device. In this embodiment, the memory 81 is generally used to store the operating system and various application software installed on the computer device 8, such as computer-readable instructions for interface call methods. In addition, the memory 81 can also be used to temporarily store various types of data that have been output or are to be output.

[0160] The processor 82 may, in some embodiments, be a central processing unit (CPU), a controller, a microcontroller, a microprocessor, or other data processing chip. The processor 82 is generally used to control the overall operation of the computer device 8. In the present embodiment, the processor 82 is configured to run computer-readable instructions stored in the memory 81 or to process data, such as computer-readable instructions for running the interface calling method.

[0161] The network interface 83 may include a wireless network interface or a wired network interface, and is generally used to establish a communication connection between the computer device 8 and other electronic devices.

[0162] The present embodiment can obtain user request text information, perform natural language processing on the user request text information to obtain request semantic representation and key entity information, perform semantic matching on the request semantic representation and the key entity information according to a pre-constructed interface knowledge graph to obtain a target program interface document, perform structured analysis and information extraction on the target program interface document to obtain document key information, perform code generation based on a pre-trained code generation model according to the document key information and the request semantic representation to obtain target calling code, perform static analysis and dynamic testing on the target calling code to obtain code test results, adjust the code generation model according to the code test results to obtain an effective code generation model, and generate adjusted target code based on the effective code generation model and apply the adjusted target code to a target program interface for interface calling. Thus, accurate and effective application program interface calling can be realized according to user input request text to improve the accuracy and effectiveness of interface calling.

[0163] The present application also provides another embodiment, i.e., a computer readable storage medium storing computer readable instructions executable by at least one processor to cause the at least one processor to perform the steps of the interface calling method as described above.

[0164] By adopting the above-mentioned computer-readable storage medium, this embodiment can obtain user request text information, perform natural language processing on the user request text information, obtain request semantic representation and key entity information; perform semantic matching on the request semantic representation and the key entity information according to the pre-built interface knowledge graph to obtain the target program interface document; perform structured parsing and information extraction on the target program interface document to obtain document key information; perform code generation based on the document key information and the request semantic representation based on the pre-trained code generation model to obtain target call code; perform static analysis and dynamic testing on the target call code to obtain code test results; adjust the code generation model according to the code test results to obtain an effective code generation model, and generate an adjusted target code according to the effective code generation model, and apply the adjusted target code to the target program interface for interface call. In this way, accurate and effective application program interface calls can be effectively implemented according to the request text input by the user, thereby improving the accuracy and effectiveness of interface calls.

[0165] Through the description of the above implementation methods, those skilled in the art can clearly understand that the above-mentioned embodiment methods can be implemented by means of software plus the necessary general hardware platform, and of course can also be implemented by hardware, but in many cases the former is a better implementation method. Based on this understanding, the technical solution of the present application, or the part that contributes to the prior art, can be embodied in the form of a software product, which is stored in a storage medium (such as ROM / RAM, magnetic disk, optical disk), and includes a number of instructions for enabling a terminal device (which can be a mobile phone, computer, server, air conditioner, or network device, etc.) to execute the methods described in each embodiment of the present application.

[0166] Obviously, the embodiments described above are only some of the embodiments of the present application, rather than all of the embodiments. The preferred embodiments of the present application are given in the accompanying drawings, but they do not limit the patent scope of the present application. The present application can be implemented in many different forms. On the contrary, the purpose of providing these embodiments is to make the understanding of the disclosure of the present application more thorough and comprehensive. Although the present application has been described in detail with reference to the aforementioned embodiments, for those skilled in the art, it is still possible to modify the technical solutions described in the aforementioned specific embodiments, or to make equivalent replacements for some of the technical features therein. Any equivalent structure made using the contents of the present application specification and the accompanying drawings, directly or indirectly used in other related technical fields, is also within the scope of patent protection of the present application.

[0167] The non-Company software tools or components appearing in the embodiments of this application are merely examples and do not represent actual use.

Claims

1. An interface calling method, characterized in that: The steps include: Obtaining user request text information, performing natural language processing on the user request text information, and obtaining request semantic representation and key entity information; The request semantic representation and the key entity information are semantically matched according to a pre-built interface knowledge graph to obtain a target program interface document, specifically extracting a semantic vector representation of a corresponding node from the interface knowledge graph according to the key entity information; calculating the similarity between the semantic vector representation and the request semantic representation to obtain a similarity score; sorting the nodes in the interface knowledge graph according to the similarity score to obtain the most relevant target node; and extracting the target program interface document from a preset document database according to the most relevant target node; Performing structured parsing and information extraction on the target program interface document to obtain key information of the document; Based on the pre-trained code generation model, code is generated according to the document key information and the request semantic representation to obtain the target call code. Specifically, according to the request semantic representation, a matching is performed in a predefined rule library to obtain parameter type matching rules, required parameter checking rules, and return value processing rules; a parameter list is extracted from the document key information, and the parameter list is type checked and converted according to the parameter type matching rules to obtain a valid parameter list; the valid parameter list is checked according to the required parameter checking rules to obtain valid parameter information; Identifying the target code type corresponding to the request semantic representation, and inputting the target code type and the valid parameter information into the code generation model to obtain an initial call code; Adding return value processing logic to the initial calling code according to the return value processing rule to obtain the target calling code; Performing static analysis and dynamic testing on the target calling code to obtain code test results, specifically determining whether the syntax of the target calling code is correct based on the static analysis method; if the syntax of the target calling code is correct, obtaining a preset test case set, and executing the test case set to dynamically run the target calling code to obtain the code test results; The code generation model is adjusted according to the code test result to obtain a valid code generation model, and an adjusted target code is generated according to the valid code generation model, and the adjusted target code is applied to the target program interface for interface calling.

2. The interface calling method according to claim 1, characterized in that: The step of performing natural language processing on the user request text information to obtain the request semantic representation and key entity information specifically includes: Perform word segmentation processing on the user request text information based on a preset word segmentation algorithm to obtain request keywords; Performing part-of-speech tagging on the request keyword based on a pre-built part-of-speech tagging model to obtain a tagged keyword; Performing dependency analysis on the annotated keywords to obtain keyword dependency relationships; Constructing a semantic representation graph according to the request keywords and the keyword dependencies, and using the semantic representation graph as the request semantic representation; Key entity recognition is performed on the semantic representation graph to obtain the key entity information.

3. The interface calling method according to claim 1, characterized in that: The step of performing structured parsing and information extraction on the target program interface document to obtain key information of the document specifically includes: Preprocessing the target program interface document to obtain a valid program interface document; Performing semantic analysis on the valid program interface document to obtain key sentences and key paragraphs of the document; The key sentences and key paragraphs of the document are structurally represented to obtain the key information of the document.

4. The interface calling method according to claim 1, characterized in that: The step of adjusting the code generation model according to the code test result to obtain a valid code generation model specifically includes: Obtaining a preset standard test result, and determining whether the code test result meets the standard test result; If the code test result meets the standard test result, the code generation model corresponding to the code test result is used as the valid code generation model; If the code test result does not meet the standard test result, the difference item between the code test result and the standard test result is obtained, and correction information is extracted from a preset difference correction table according to the difference item, the code generation model is adjusted based on the correction information, and the adjusted code test result is re-obtained. The steps of obtaining the difference item to adjusting the code generation model are repeated until the adjusted code test result meets the standard test result, thereby obtaining the valid code generation model.

5. An interface calling device, characterized in that: include: An information processing module is used to obtain user request text information, perform natural language processing on the user request text information, and obtain request semantic representation and key entity information; A semantic matching module is used to perform semantic matching on the request semantic representation and the key entity information based on a pre-built interface knowledge graph to obtain a target program interface document, specifically extracting a semantic vector representation of a corresponding node from the interface knowledge graph based on the key entity information; calculating the similarity between the semantic vector representation and the request semantic representation to obtain a similarity score; sorting the nodes in the interface knowledge graph based on the similarity score to obtain the most relevant target node; and extracting the target program interface document from a preset document database based on the most relevant target node; An information extraction module is used to perform structured analysis and information extraction on the target program interface document to obtain key information of the document; A code generation module is configured to generate code based on the document key information and the request semantic representation based on a pre-trained code generation model to obtain target call code, specifically matching the request semantic representation in a predefined rule library to obtain parameter type matching rules, mandatory parameter checking rules, and return value processing rules; extract a parameter list from the document key information, and perform type checking and conversion processing on the parameter list according to the parameter type matching rules to obtain a valid parameter list; and check the valid parameter list according to the mandatory parameter checking rules to obtain valid parameter information; Identifying the target code type corresponding to the request semantic representation, and inputting the target code type and the valid parameter information into the code generation model to obtain an initial call code; Adding return value processing logic to the initial calling code according to the return value processing rule to obtain the target calling code; a code testing module configured to perform static analysis and dynamic testing on the target calling code to obtain code test results, specifically determining whether the syntax of the target calling code is correct based on a static analysis method; if the syntax of the target calling code is correct, obtaining a preset test case set, executing the test case set to dynamically run the target calling code, and obtaining the code test results; A code adjustment module is used to adjust the code generation model according to the code test results to obtain a valid code generation model, generate an adjustment target code according to the valid code generation model, and apply the adjustment target code to the target program interface for interface call.

6. A computer device, characterized in that: The method comprises a memory and a processor, wherein the memory stores computer-readable instructions, and the processor implements the steps of the interface calling method according to any one of claims 1 to 4 when executing the computer-readable instructions.

7. A computer-readable storage medium, characterized in that The computer-readable storage medium stores computer-readable instructions, which, when executed by a processor, implement the steps of the interface calling method according to any one of claims 1 to 4.

Images