Information processing apparatus, information processing method, and information processing program

Abstract

To provide an information processing apparatus, an information processing method, and an information processing program capable of reducing the load for preparing an implementation document.SOLUTION: An information processing apparatus includes an acquisition unit and a generation unit. The acquisition unit acquires a target code which is a code for which an implementation document is to be prepared, the target code being included in a software development kit. The generation unit inputs input information including the target code acquired by the acquisition unit, to a language model configured to generate and output information according to input information, and causes the language model to generate an implementation document including information on the target code.SELECTED DRAWING: Figure 6

Description

[Technical field]

[0001] The present invention relates to an information processing device, an information processing method, and an information processing program. [Background technology]

[0002] Conventionally, there is known an SDK (Software Development Kit) that includes codes and the like required for developing a software application. Software development engineers can efficiently develop software applications by using such an SDK. [Prior art documents] [Patent documents]

[0003] [Patent Document 1] JP 2011-150430 A Summary of the Invention [Problem to be solved by the invention]

[0004] When developing an SDK, in addition to the SDK itself, implementation documentation may be prepared that describes the procedures and methods for implementing the code included in the SDK into a software application.

[0005] When a new SDK is developed, new implementation documentation must be created. In addition, when new code is added to the SDK or existing code is modified, implementation documentation must be added or modified accordingly. However, implementation documentation is created manually by SDK development engineers, which creates a heavy burden for the process.

[0006] The present application has been made in consideration of the above, and has an object to provide an information processing device, an information processing method, and an information processing program that can reduce the burden of creating implementation documentation. [Means for solving the problem]

[0007] The information processing device according to the present application includes an acquisition unit and a generation unit. The acquisition unit acquires target code, which is code included in a software development kit and is a code that is a target of an implementation document. The generation unit inputs input information including the target code acquired by the acquisition unit to a language model that generates and outputs information according to the input information, and causes the language model to generate an implementation document including information regarding the target code. Effect of the Invention

[0008] According to one aspect of the embodiment, an effect is achieved in that the burden of creating implementation documentation can be reduced. [Brief description of the drawings]

[0009] [Figure 1] FIG. 1 is a diagram for explaining information processing according to the embodiment. [Diagram 2] FIG. 2 is a diagram illustrating an example of an SDK document creation support function in the information processing device according to the embodiment. [Diagram 3] FIG. 3 is a diagram illustrating an example of an API document creation support function in the information processing device according to the embodiment. [Figure 4] FIG. 4 is a diagram illustrating an example of a reply function in the information processing device according to the embodiment. [Diagram 5] FIG. 5 is a diagram illustrating an example of the configuration of an information processing system according to the embodiment. [Figure 6] FIG. 6 is a diagram illustrating an example of the configuration of the information processing device according to the embodiment. [Figure 7] FIG. 7 is a diagram illustrating an example of a user information table stored in the user information storage unit of the information processing device according to the embodiment. [Figure 8] FIG. 8 is a diagram illustrating an example of a question information table stored in the question and answer information storage unit of the information processing device according to the embodiment. [Figure 9] FIG. 9 is a diagram illustrating an example of an answer information table stored in the question and answer information storage unit of the information processing device according to the embodiment. [Figure 10] FIG. 10 is a diagram illustrating an example of a generation information table stored in the generation history storage unit of the information processing device according to the embodiment. [Figure 11] FIG. 11 is a diagram illustrating an example of the configuration of the generation unit of the information processing device according to the embodiment. [Figure 12] FIG. 12 is a flowchart illustrating an example of information processing by the processing unit of the information processing device according to the embodiment. [Figure 13] FIG. 13 is a flowchart illustrating an example of a first implementation document generation process by the processing unit of the information processing device according to the embodiment. [Figure 14] FIG. 14 is a flowchart illustrating an example of a second implementation document generation process by the processing unit of the information processing device according to the embodiment. [Figure 15] FIG. 15 is a flowchart illustrating an example of a response information generating process by the processing unit of the information processing device according to the embodiment. [Figure 16] FIG. 16 is a flowchart illustrating an example of a reply process by the processing unit of the information processing device according to the embodiment. [Figure 17] FIG. 17 is a hardware configuration diagram showing an example of a computer that realizes the functions of the information processing device according to the embodiment. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS

[0010] Hereinafter, the information processing device, the information processing method, and the information processing program according to the present application (hereinafter, referred to as "embodiments") will be described in detail with reference to the drawings. Note that the information processing device, the information processing method, and the information processing program according to the present application are not limited to these embodiments. In addition, each embodiment can be appropriately combined as long as the processing contents are not contradictory. In addition, the same parts in each of the following embodiments are given the same reference numerals, and duplicated explanations will be omitted.

[0011] [1. An example of information processing] First, an example of information processing according to the embodiment will be described with reference to Fig. 1. Fig. 1 is a diagram for explaining information processing according to the embodiment.

[0012] 1 is an information processing device that cooperates with a terminal device 2 of each user U to provide various information online to the user U, and is realized by, for example, one or more servers or a cloud system. In the following, for convenience of explanation, the multiple terminal devices 2 will be explained by dividing them into a terminal device 2A, a terminal device 2B, and a terminal device 2C.

[0013] 1, only one each of terminal device 2A, terminal device 2B, and terminal device 2C are shown, but the information processing system includes multiple each of terminal device 2A, terminal device 2B, and terminal device 2C. In the following, a user U who uses terminal device 2A may be described as user UA, a user U who uses terminal device 2B may be described as user UB, and a user U who uses terminal device 2C may be described as user UC.

[0014] The information processing device 1 has various functions, such as a function for creating implementation documents for an SDK (Software Development Kit), a function for creating implementation documents for an API (Application Programming Interface), and a function for answering questions regarding various programs including SDKs, APIs, etc.

[0015] The user UA is, for example, an SDK development engineer, the user UB is, for example, an API development engineer, and the user UC is, for example, a software developer, but is not limited to these examples.

[0016] An SDK is a set of development information targeted at the development of specific software, such as a specific platform, a specific system, or a specific software application, and includes various information necessary for developing software. For example, an SDK includes the SDK itself and various documents.

[0017] The SDK body includes, for example, test code, source code, etc. The source code includes, for example, library code, class code, method code, other function code, etc. used in implementing specific software, but is not limited to these examples. The SDK body may also include tools such as a compiler, a debugger, and an emulator.

[0018] The code of the library is, for example, code that realizes a specific function. The code of the library includes, for example, program components such as classes, methods, other functions, constants, variables, etc., but is not limited to such examples as long as it is code that realizes a specific function.

[0019] The test code is, for example, code for checking whether a method, function, etc. returns an expected result when an SDK user, who is a user of the SDK, implements the code, and is provided, for example, for each library. Note that the test code may be a test application (hereinafter, sometimes referred to as a test app), or may be a part of it.

[0020] The documentation includes, for example, implementation documentation that an SDK user refers to when implementing SDK code into a specific application, etc. The implementation documentation includes, for example, information indicating the function of the SDK code (e.g., library functions, etc.), information indicating the implementation procedure of the SDK code (e.g., library implementation procedures, etc.), sample code, and other information, but is not limited to such examples.

[0021] An API is an interface for exchanging information between software programs, and defines the procedures and data formats for calling and using functions and data of one piece of software from another piece of software. API code includes API source code, API test code, etc. The test code may be a test app or a part of it.

[0022] The information processing device 1 includes a storage unit 11 and a processing unit 12. In the information processing device 1, various SDKs, information on various APIs, various programs, related confuls, information on development materials, and the like are stored in the storage unit 11, and the processing unit 12 executes a function of creating an implementation document for an SDK, a function of creating an implementation document for an API, a response function, and the like based on the information stored in the storage unit 11.

[0023] Related Conful is, for example, team collaboration software that provides various functions such as sharing documents and notes, and managing projects and tasks. Development materials are, for example, materials used during the development of SDKs and various APIs, and include information such as minutes of meetings between SDK developers and minutes of meetings between API developers. Information managed by Related Conful and minutes of meetings include, for example, information showing the background and policy of the development of each code.

[0024] Below, we will explain the SDK implementation document creation function, the API implementation document creation function, and the response function, in that order.

[0025] [1.1. SDK implementation document creation function] A user UA who is an SDK developer can operate the terminal device 2A to access the information processing device 1 and use the SDK document creation support function of the information processing device 1. Fig. 2 is a diagram showing an example of the SDK document creation support function of the information processing device 1 according to the embodiment.

[0026] The SDK documentation creation support function is a function that supports the creation of implementation documents that SDK users can refer to when implementing the SDK main code into a specific application, etc. Implementation documents are documents that SDK users can refer to when implementing the SDK main code into a specific application, etc.

[0027] The implementation document includes, for example, information on each function realized by the target code, sample code, etc. For example, the implementation document is a document that describes an overall overview of the target code, items of each function realized by the target code, contents (explanation), code, etc. in the order of implementation, but is not limited to such an example.

[0028] The processing unit 12 of the information processing device 1 causes the terminal device 2A to display information showing a list of codes (e.g., test codes, libraries, classes, methods, other functions, etc.) included in the SDK stored in the storage unit 11. The processing unit 12 can also cause the terminal device 2A to display information showing a list of codes newly added to the SDK, codes modified in the SDK, etc.

[0029] The user UA selects a target code, which is a code to be the target of the implementation document, from the list of codes displayed on the terminal device 2A (step S1). As a result, target code identification information, which is information identifying the target code selected by the user UA, is transmitted from the terminal device 2A to the information processing device 1.

[0030] The target code is the test code of the SDK, the source code of the SDK, etc. For example, the target code is the code in the test code that calls the SDK function and the code that performs processing before and after the code, source code libraries, classes, methods, other functions, etc., but is not limited to such examples and may be a range of code selected by the user UA.

[0031] The processing unit 12 of the information processing device 1 receives the target code identifying information transmitted from the terminal device 2A, and extracts the target code identified by the target code identifying information from the SDK stored in the storage unit 11 (step S2).

[0032] Next, the processing unit 12 of the information processing device 1 inputs the input information including the target code acquired in step S2 to a language model that generates and outputs information according to the input information, and causes the language model to generate an implementation document including information about the target code (step S3).

[0033] A language model is, for example, a model such as a transformer that is trained to estimate and output the next token from an input token string, and is also called a large language model (LLM).

[0034] The language model is stored in an internal storage unit or an external information processing device, and is created independently by the operator of the information processing device 1. Note that the input information can be trained so that it is not used as a new answer (output), thereby making it possible to keep input information, such as personal information, confidential.

[0035] The processing unit 12, for example, inputs input information into the language model using an API provided by a business that provides use of the language model and acquires information generated by the language model, but the information processing device 1 may be configured to include the language model.

[0036] The processing unit 12 inputs input information including the target code acquired in step S2 and instruction information indicating an instruction to output an implementation document of the target code, to cause the language model to generate an implementation document including information about the target code. The instruction information is an example of information indicating an instruction to output information about the target code.

[0037] The instruction information includes, for example, information that specifies the format of the implementation document. The format of the implementation document includes, for example, information that specifies multiple elements that make up the implementation document, information that indicates the arrangement order of the multiple elements, information that specifies the content of each element, etc. The elements that make up the implementation document include, for example, but are not limited to, the function of the target code, the procedure or method for implementing the target code, and sample code.

[0038] The instruction information includes, for example, information for specifying the format of the implementation document, which includes information for specifying the type of format of the implementation document. The information for specifying the type of format is, for example, information indicating the type of format or information indicating the content of the type of format (for example, a format configuration or a format example). The type of format of the implementation document is, for example, a demo format, a tutorial format, a reference format, a use case format, etc.

[0039] The demo format is a pattern in which an overview of the target code is written at the beginning, and a set of a few lines of explanation and code is repeated in succession. The set of a few lines of explanation and code includes, for example, code that must be implemented in the test code and an explanation of that code.

[0040] The tutorial format is a writing format that allows you to touch on essential functions by reading from the beginning, and it is a format in which multiple codes that must be implemented in the test code are arranged adjacent to each other if they are highly related to each other; for example, the code for an ad request and the code for displaying an ad are arranged adjacent to each other.

[0041] The reference format is a format that comprehensively explains multiple functions of the target code, and includes, for example, multiple codes that must be implemented in the test code, as well as codes whose implementation is optional, and for example, each code is arranged according to its function.

[0042] The use case format is, for example, a format that explains each implementation purpose, and describes the items, explanations, and codes for each purpose, such as obtaining and displaying advertisements, measuring the effectiveness of advertisements, etc. This allows the user UA to carry out the necessary implementation based on the purpose they wish to achieve, and can improve the convenience of the user UA when there are too many functions and search does not work.

[0043] The processing unit 12 generates an implementation document in a language model using as input information, for example, information including the string "Please create an implementation document for the following code in the format specified below" (an example of instruction information), the target code acquired in step S2, and information specifying the format of the implementation document.

[0044] The language model may be generated by performing transfer learning on a pre-trained language model using training information including a code of a predetermined unit and an implementation document including information about the code. Such transfer learning is also called fine tuning, for example. The implementation document in the training information is used as a label, for example.

[0045] The predetermined unit of code is, for example, code of another SDK, code with Javadoc comments, etc. If the predetermined unit of code is code with Javadoc comments, the information about the code is, for example, the Javadoc comments.

[0046] When using a language model that has undergone transfer learning in this way, the processing unit 12 can, for example, cause the language model to generate an implementation document using information including the target code acquired in step S2 as input information without using instruction information. Note that, in this case as well, the input information may include information such as the character string "Please create an implementation document for the following code." (an example of instruction information).

[0047] Furthermore, the processing unit 12 can cause the language model to generate an implementation document of the target code without performing transfer learning of the language model. The processing unit 12 causes the language model to generate an implementation document using, as input information, information including, for example, the target code, another implementation document that is an implementation document of another code different from the target code, and instruction information.

[0048] For example, the processing unit 12 generates an implementation document in a language model using as input information the string "Please create implementation documentation for the following code by referring to the implementation documentation below." (an example of instruction information), the target code acquired in step S2, and information including other implementation documentation.

[0049] The other implementation documents may be, for example, implementation documents of code in other SDKs, implementation documents previously generated by a language model, implementation documents generated by Javadoc, etc., but may also be implementation documents of the code of the target SDK.

[0050] The processing unit 12 can also cause the language model to generate an implementation document using information further including a code corresponding to another implementation document as input information. In this case, the code corresponding to the other implementation document and the other implementation document are used for so-called temporary memory learning in the language model as examples of input and output.

[0051] The processing unit 12 inputs a language model using as input information information including, for example, information on the character string "<input example>", code corresponding to other implementation documents, information on the character string "<output example>", other implementation documents, information on the character string "Please create an implementation document for the following code by referring to the above-mentioned example." (an example of instruction information), and the target code.

[0052] In addition, the processing unit 12 generates an implementation document in a language model using information including commented source code as input information for the target code, but can also generate an implementation document in a language model using information including uncommented code as input information.

[0053] In addition, the processing unit 12 can also cause the language model to generate an implementation document using as input information further including information on materials used during the development of the target code (e.g., materials on related confluencies of the target API and development materials for the target code, etc.).

[0054] The instruction information is not limited to the above-mentioned example, and may be any information that allows the language model to appropriately generate the implementation document. In addition, if the language model is a model that allows prompts to be input separately as system prompts and user prompts (e.g., gpt-3.5 or gpt-4 by OpenAI), the instruction information may be included in the input information as a system prompt. The system prompt is expressed, for example, as {"role":"system", "content":prompt}. Prompt is a system prompt and is expressed as text information.

[0055] In addition, if the language model is a model in which prompts can be input separately as system prompts, user prompts, and assistant prompts (for example, OpenAI's gpt-3.5 or gpt-4), the processing unit 12 can also include information indicating examples of the above-mentioned input and output for the user prompt and assistant prompt in the input information.

[0056] In addition, the processing unit 12 can also, for example, cause the language model to generate a task for generating an implementation document for the target code, and input the results of executing such a task into the language model, thereby causing the language model to generate an implementation document for the target code.

[0057] For example, the processing unit 12 inputs information including the string "Please tell me the information necessary to generate an implementation document for the following code." (an example of instruction information) and the target code as input information into the language model, thereby causing the language model to generate specific information that identifies the information necessary to generate an implementation document for the target code.

[0058] In this case, the processing unit 12 collects information specified by the specific information output from the language model from the storage unit 11 or an external information processing device. The information specified by the specific information is, for example, a code different from the target code, another implementation document that is an implementation document of a code different from the target code, etc. The processing unit 12 can cause the language model to generate an implementation document of the target code using, for example, information including the information specified by the specific information and the target code, etc., as input information.

[0059] In this way, the processing unit 12 inputs, for example, input information including the target code to the language model, and causes the language model to generate an implementation document of the target code. Note that it is sufficient to cause the language model to generate an implementation document of the target code, and the input information input to the language model is not limited to the above-mentioned example.

[0060] Next, the processing unit 12 of the information processing device 1 stores the implementation document generated in step S3 in the storage unit 11 (step S4). In step S4, the processing unit 12 incorporates the implementation document generated in step S3 into the SDK, for example, by associating the implementation document generated in step S3 with the target code and storing it in the storage unit 11. This allows the information processing device 1 to significantly reduce the burden of creating the implementation document on the SDK development engineer.

[0061] The processing unit 12 of the information processing device 1 can also display the implementation document generated in step S3 in an editable manner on the terminal device 2A of the user UA before incorporating the implementation document generated in step S3 into the SDK. The user UA can modify the implementation document generated in step S3 by operating the terminal device 2A, and can then cause the processing unit 12 to execute a process of incorporating the modified implementation document into the SDK.

[0062] Furthermore, in the above-described example, the target code is selected by the user UA, but the target code may be selected by the processing unit 12 of the information processing device 1. For example, the processing unit 12 can select a newly generated code or a modified code as the target code.

[0063] In this way, the information processing device 1 acquires target code, which is code included in the SDK and is the subject of an implementation document, inputs input information including the acquired target code to a language model that generates and outputs information according to the input information, and causes the language model to generate an implementation document including information about the target code. This allows the information processing device 1 to reduce the burden of creating implementation documents for code included in the SDK.

[0064] [1.2. API implementation documentation creation function] A user UB who is an API developer can operate the terminal device 2B to access the information processing device 1 and use the API document creation support function of the information processing device 1. Figure 3 is a diagram showing an example of the API document creation support function of the information processing device 1 according to the embodiment.

[0065] The API documentation creation support function is a function that supports the creation of implementation documents that API users can refer to when implementing API code into specific applications, etc. Implementation documents are documents that API users can refer to when implementing API code into specific applications, etc.

[0066] The implementation document includes, for example, information on each function realized by the target API, sample code, etc. For example, the implementation document is a document that describes the overall overview of the API, the items, contents (explanation), code, etc. of each function realized by the API in the order of implementation, but is not limited to such an example.

[0067] The processing unit 12 of the information processing device 1 causes the terminal device 2B to display information indicating a list of APIs stored in the storage unit 11. The processing unit 12 can also cause the terminal device 2B to display information indicating a list of newly added APIs, modified APIs, and the like.

[0068] The user UB selects an API to be the target of the implementation document from the list of APIs displayed on the terminal device 2B (step S11). As a result, API identification information, which is information identifying the API selected by the user UB, is transmitted from the terminal device 2B to the information processing device 1. In the following, the API identified by the API identification information may be referred to as a target API.

[0069] The processing unit 12 of the information processing device 1 receives the API identification information transmitted from the terminal device 2B, and extracts the code of the target API identified by the API identification information as the target code from among the codes of multiple APIs stored in the memory unit 11 (step S12).

[0070] The code of the API extracted in step S12 is, for example, the test code of the API or the source code of the API. Note that the target code may be code selected by the user UB from the code of the target API.

[0071] Next, the processing unit 12 of the information processing device 1 inputs the input information including the target code acquired in step S12 to a language model that generates and outputs information according to the input information, and causes the language model to generate an implementation document including information about the target code (step S13).

[0072] A language model is, for example, a model such as a transformer that is trained to estimate and output the next token from an input token sequence, and is also called a large-scale language model.

[0073] The language model is stored in an internal storage unit or an external information processing device, and is created independently by the operator of the information processing device 1. Note that the input information can be trained so that it is not used as a new answer (output), thereby making it possible to keep input information, such as personal information, confidential.

[0074] The processing unit 12, for example, inputs input information into the language model using an API provided by a business that provides use of the language model and acquires information generated by the language model, but the information processing device 1 may be configured to include the language model.

[0075] The processing unit 12 inputs input information including the target code acquired in step S12 and instruction information indicating an instruction to output an implementation document of the target code, to cause the language model to generate an implementation document including information about the target code. The instruction information is an example of information indicating an instruction to output information about the target code.

[0076] The instruction information includes, for example, information that specifies the format of the implementation document. The format of the implementation document includes, for example, information that specifies multiple elements that make up the implementation document, information that indicates the arrangement order of the multiple elements, information that specifies the content of each element, etc. The elements that make up the implementation document include, for example, but are not limited to, the function of the target code, the procedure or method for implementing the target code, and sample code.

[0077] The instruction information includes, for example, information for specifying the format of the implementation document, which includes information for specifying the type of format of the implementation document. The information for specifying the type of format is, for example, information indicating the type of format or information indicating the content of the type of format (for example, a format configuration or a format example). The type of format of the implementation document is, for example, a demo format, a tutorial format, a reference format, a use case format, etc.

[0078] The demo format is a pattern in which an overview of the target code is written at the beginning, and a set of a few lines of explanation and code is repeated in succession. The set of a few lines of explanation and code includes, for example, code that must be implemented in the test code and an explanation of that code.

[0079] The tutorial format is a writing format that allows you to touch on essential functions by reading from the beginning, and it is a format in which multiple codes that must be implemented in the test code are arranged adjacent to each other if they are highly related to each other; for example, the code for an ad request and the code for displaying an ad are arranged adjacent to each other.

[0080] The reference format is a format that comprehensively explains multiple functions of the target code, and includes, for example, multiple codes that must be implemented in the test code, as well as codes whose implementation is optional, and for example, each code is arranged according to its function.

[0081] The use case format is, for example, a format for explaining each implementation purpose, and for example, the items, explanations, and codes are described for each purpose. This allows the user UB to perform the necessary implementation based on the purpose he or she wants to achieve, and can improve the convenience of the user UB when there are too many functions and search does not work.

[0082] The processing unit 12 generates an implementation document in a language model using as input information, for example, information including the string "Please create an implementation document for the following code in the format specified below." (an example of instruction information), the target code acquired in step S12, and information specifying the format of the implementation document.

[0083] The language model may be generated by performing transfer learning on a pre-trained language model using training information including the code of another API and an implementation document including information about the code. Such transfer learning is also called fine tuning, for example. The implementation document in the training information is used as a label, for example.

[0084] When using a language model that has undergone transfer learning in this way, the processing unit 12 can, for example, cause the language model to generate an implementation document using information including the target code acquired in step S12 as input information without using instruction information. Note that, in this case as well, the input information may include information such as the character string "Please create an implementation document for the following code." (an example of instruction information).

[0085] Furthermore, the processing unit 12 can cause the language model to generate an implementation document of the target code without performing transfer learning of the language model. The processing unit 12 causes the language model to generate an implementation document using, as input information, information including the target code acquired in step S12, another implementation document that is an implementation document of another API, and instruction information.

[0086] For example, the processing unit 12 generates an implementation document in a language model using as input information the string “Please create the implementation document for the following code by referring to the implementation document below”, the target code acquired in step S12, and information including other implementation documents.

[0087] The other implementation document is, for example, an implementation document of an API other than the target API, such as an implementation document created by an API engineer or an implementation document generated in the past using a language model, but is not limited to such examples.

[0088] The processing unit 12 can also cause the language model to generate an implementation document using information including, in addition to the other implementation document, the code of another API corresponding to the other implementation document as input information. In this case, the other implementation document and the code of the other API corresponding to the other implementation document are used for so-called temporary memory learning in the language model as examples of input and output.

[0089] The processing unit 12 inputs a language model using as input information information including, for example, information on the character string "<input example>", codes of other APIs corresponding to other implementation documents, information on the character string "<output example>", other implementation documents, information on the character string "Please create an implementation document for the following code by referring to the above-mentioned example." (an example of instruction information), and the target code.

[0090] In addition, the processing unit 12 generates an implementation document in a language model using information including commented source code as input information for the target code, but can also generate an implementation document in a language model using information including uncommented code as input information.

[0091] In addition, the processing unit 12 can also generate an implementation document in the language model using as input information further including information on materials used during the development of the target API (for example, materials on related confluence of the target API and development materials for the target API, etc.).

[0092] The instruction information is not limited to the above-mentioned example, and may be any information that allows the language model to appropriately generate the implementation document. In addition, if the language model is a model that allows prompts to be input separately as system prompts and user prompts (e.g., gpt-3.5 or gpt-4 by OpenAI), the instruction information may be included in the input information as a system prompt. The system prompt is expressed, for example, as {"role":"system", "content":prompt}. Prompt is a system prompt and is expressed as text information.

[0093] In addition, if the language model is a model in which prompts can be input separately as system prompts, user prompts, and assistant prompts (for example, OpenAI's gpt-3.5 or gpt-4), the processing unit 12 can also include information indicating examples of the above-mentioned input and output for the user prompt and assistant prompt in the input information.

[0094] In addition, the processing unit 12 can also, for example, cause the language model to generate a task for generating an implementation document for the target code, and input the results of executing such a task into the language model, thereby causing the language model to generate an implementation document for the target code.

[0095] For example, the processing unit 12 inputs information including the string "Please tell me the information necessary to generate an implementation document for the following code." (an example of instruction information) and the target code as input information into the language model, thereby causing the language model to generate specific information that identifies the information necessary to generate an implementation document for the target code.

[0096] In this case, the processing unit 12 collects information specified by the specific information output from the language model from the storage unit 11 or an external information processing device, etc. The information specified by the specific information is, for example, a code different from the target code, another implementation document that is an implementation document of such code, etc. The processing unit 12 can cause the language model to generate an implementation document of the target code using, for example, information including the information specified by the specific information and the target code, etc., as input information.

[0097] In this way, the processing unit 12 inputs, for example, input information including the target code to the language model, and causes the language model to generate an implementation document of the target code. Note that it is sufficient to cause the language model to generate an implementation document of the target code, and the input information input to the language model is not limited to the above-mentioned example.

[0098] Next, the processing unit 12 of the information processing device 1 stores the implementation document generated in step S13 in the storage unit 11 (step S14). This allows the information processing device 1 to significantly reduce the burden on API development engineers in creating the implementation document.

[0099] The processing unit 12 of the information processing device 1 can also display the implementation document generated in step S13 in an editable manner on the terminal device 2B of the user UB before storing the implementation document generated in step S13 in the storage unit 11. The user UB can modify the implementation document generated in step S13 by operating the terminal device 2B, and can then cause the processing unit 12 to execute a process of storing the modified implementation document in the storage unit 11.

[0100] Furthermore, in the above example, the target API is selected by the user UB, but the target API may be selected by the processing unit 12 of the information processing device 1. For example, the processing unit 12 can select an API for which no implementation documentation has been created, an API including newly generated code or modified code, or the like, as the target API.

[0101] In this way, the information processing device 1 acquires the target code, which is the code of the API that is the target of the implementation document, inputs input information including the acquired target code to a language model that generates and outputs information according to the input information, and causes the language model to generate an implementation document including information about the target code. This allows the information processing device 1 to reduce the burden of creating the implementation document for the API.

[0102] [1.3. Answering questions about the program] A user UC who is a software developer can operate a terminal device 2C to access the information processing device 1 and use a reply function in the information processing device 1. Fig. 4 is a diagram showing an example of the reply function in the information processing device 1 according to the embodiment.

[0103] Question information, which is information indicating a question, and answer information, which is information indicating an answer to the question, are linked to each other and stored in the storage unit 11 of the information processing device 1. The question information is vectorized and stored.

[0104] The vectorization of the question information is performed, for example, by embedding using a language model (for example, a transformer-based model). The vectorized question information is represented, for example, by a vector of several hundred dimensions, but is not limited to such an example.

[0105] Embedding using a language model is, for example, embedding using text-embedding-ada provided by OpenAI (registered trademark), BERT (Bidirectional Encoder Representations from Transformers), etc., but is not limited to these examples.

[0106] Note that the vectorization of the question information is not limited to embedding using a language model, and the question information may be vectorized using, for example, Doc2Vec, an average of word embedding, etc. For word embedding, for example, Word2Vec, fastText, etc. are used.

[0107] In the information processing device 1, the storage unit 11 includes a pair of question information and answer information for each question, and at least a part of this information is generated by the processing unit 12 and stored in the storage unit 11. The processing by the processing unit 12 will be specifically described below.

[0108] First, the processing unit 12 of the information processing device 1 extracts a predetermined unit of code from the SDK, API, related confuls, etc. stored in the storage unit 11 (step S20). The predetermined unit of code is, for example, a library unit of code, a class unit of code, a method unit of code, or other function unit of code, but is not limited to such examples.

[0109] Next, the processing unit 12 of the information processing device 1 acquires question information which is information indicating a question about the program (step S21). The question about the program is a question about the code of the predetermined unit acquired in step S1, and is, for example, a question of a content that the operator of the information processing device 1 expects the user UC to ask, or a question of a content that the users UA and UB expect the user UC to ask.

[0110] When the operator of the information processing device 1 operates a terminal device not shown to input information indicating a question about a program that the user UC is expected to ask regarding the code of the predetermined unit extracted in step S20, the information indicating such question is obtained as question information from the terminal device not shown by the processing unit 12.

[0111] In addition, when user UA operates terminal device 2A to input information indicating a question regarding the SDK that user UC is expected to ask regarding the code of the predetermined unit extracted in step S20, the information indicating such question is obtained from terminal device 2A by processing unit 12 as question information.

[0112] In addition, when user UB operates terminal device 2B to input information indicating a question regarding the API that user UC is expected to ask regarding the code of the predetermined unit extracted in step S20, the information indicating such question is obtained from terminal device 2B by processing unit 12 as question information.

[0113] Furthermore, the processing unit 12 can also generate information about a question for the code of the predetermined unit acquired in step S1 in a language model and acquire the information about the question from the language model. The language model is, for example, a model such as a transformer trained to estimate and output the next token from an input token string, but is not limited to such an example.

[0114] The processing unit 12, for example, inputs input information including the code of the predetermined unit extracted in step S20 and instruction information which is information indicating an instruction to output information indicating a question expected for the code, and performs a process of generating information indicating a question related to the code of the predetermined unit in a language model for each code of the predetermined unit.

[0115] For example, the processing unit 12 uses as input information information including the character string "Please tell me some possible questions regarding the following code" (an example of instruction information) and the code of the predetermined unit extracted in step S20, and generates information indicating a question regarding the code of the predetermined unit in the language model.

[0116] The language model may be generated by performing transfer learning on a pre-trained language model using learning information including a combination of past question information and answer information for each question information. The combination of past question information and answer information is a combination of past question information and answer information in an SDK, API, related conflu, etc., different from the information stored in the storage unit 11, but is not limited to such an example.

[0117] For example, when there is a combination of past question information and answer information for a code stored in the memory unit 11, the processing unit 12 can use such a combination as part or all of the learning information.

[0118] When using a language model that has undergone transfer learning in this way, the processing unit 12 can, for example, cause the language model to generate question information using information including the code of the predetermined unit extracted in step S20 as input information without using instruction information. Note that, in this case as well, the above-mentioned instruction information may be included in the input information.

[0119] Next, the processing unit 12 of the information processing device 1 generates answer information, which is information indicating an answer to the question indicated by the question information acquired in step S21, using a language model that generates and outputs information according to the input information (step S22). The language model is, for example, a model such as a transformer that is trained to estimate and output the next token from the input token string, but is not limited to such an example.

[0120] In step S22, the processing unit 12 inputs, for example, information including the question information acquired in step S21 to the language model as input information, and causes the language model to generate answer information or information for obtaining the answer information.

[0121] For example, the processing unit 12 uses information including the character string "Please create an answer to the following question" and the question information acquired in step S21 as input information, and causes the language model to generate answer information.

[0122] In addition, the processing unit 12 can also generate answer information in a language model using as input information information including, for example, a character string "The following questions are asked about the following code. Please create answers to these questions.", the code extracted in step S20, and the question information obtained in step S21.

[0123] Furthermore, the processing unit 12 can generate information for obtaining answer information in a language model using information including, for example, the character string "Please create an answer to the following question" (an example of instruction information) and the question information acquired in step S21 as input information. In this case, the processing unit 12 can also include the code extracted in step S20 in the input information.

[0124] In addition, the processing unit 12 can generate information in a language model for obtaining answer information using as input information information including, for example, the character string "Please tell me the information necessary to answer the following question." (an example of instruction information) and the question information acquired in step S21.

[0125] In this case, the processing unit 12 can also include the code extracted in step S20 in the input information. For example, the processing unit 12 can cause the language model to generate information for obtaining answer information using as input information information including the character string "Please tell me the information necessary to answer the following question for the following code", the code extracted in step S20, and the question information acquired in step S21.

[0126] The information for obtaining the answer information is, for example, search information corresponding to the question indicated by the question information acquired in step S21. The search information includes, for example, information for identifying a search target. The information for identifying a search target is, for example, information for identifying information such as a class or resource related to the code extracted in step S20.

[0127] The class related to the code extracted in step S20 is, for example, a class including a method or function used by the code extracted in step S20, or a class inherited by the class of the code extracted in step S20.

[0128] Moreover, the resource related to the code extracted in step S20 is, for example, information on the resource required to execute the code extracted in step S20. The resource is a configuration file, a database, a hardware resource, etc. The hardware resource is, but is not limited to, a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a RAM (Random Access Memory), a disk capacity, etc.

[0129] When the processing unit 12 causes the language model to generate answer acquisition information, which is information for obtaining answer information, the processing unit 12 acquires the answer acquisition information generated in the language model from the storage unit 11 or an external information processing device. Then, the processing unit 12 inputs information including the acquired answer acquisition information as input information to the language model, and causes the language model to generate answer information.

[0130] For example, when the processing unit 12 causes the language model to generate search information as answer acquisition information, the processing unit 12 searches for related information related to the question indicated by the question information acquired in step S21 based on the search information. The related information is, for example, information on classes, resources, etc. related to the code extracted in step S20.

[0131] Then, the processing unit 12 inputs information including the related information searched as described above and the question information acquired in step S21 to the language model as input information, and causes the language model to generate answer information. In this case, the processing unit 12 can also use information further including the code extracted in step S20 as input information.

[0132] Next, the processing unit 12 of the information processing device 1 associates the question information acquired in step S21 with the answer information generated in step S22 and stores them in the storage unit 11 (step S23).

[0133] The processing unit 12 of the information processing device 1 vectorizes the question information acquired in step S21 and stores the vectorized information in the storage unit 11. As described above, the question information is vectorized by embedding using a language model such as text-embedding-ada or BERT.

[0134] For example, the processing unit 12 inputs the question information acquired in step S21 as input information to a language model via an API or the like, and acquires vectorized information of the question information acquired in step S21 from the language model.

[0135] In addition, the language model that vectorizes the question information may be provided, for example, in the information processing device 1. In this case, the processing unit 12 can vectorize the question information acquired in step S21 using the language model provided in the information processing device 1.

[0136] Note that vectorization of question information is not limited to embedding using a language model, and question information may be vectorized using, for example, Doc2Vec, an average of word embedding, or the like.

[0137] The processing unit 12 of the information processing device 1 repeats the processes of steps S20 to S23 to store information in which question information and answer information are linked to each other in the storage unit 11 for each question. Note that in step S21, information indicating multiple questions for a predetermined unit code can also be acquired, and in this case, the processing unit 12 causes the language model to generate answer information for each of the multiple pieces of question information for each predetermined unit code.

[0138] Next, the processing unit 12 of the information processing device 1 accepts a question about the program from the user UC, and obtains information indicating the accepted question about the program from the user UC (step S24).

[0139] The user UC operates the terminal device 2C to input information indicating a question about the program into the terminal device 2C, and then performs an operation to transmit the input information, whereby the information indicating the question about the program posed by the user UC is transmitted from the terminal device 2C to the information processing device 1.

[0140] The information processing device 1 accepts a question about the program from the user UC by accepting information indicating a question about the program from the user UC. Then, the information processing device 1 acquires the accepted information indicating the question about the program from the user UC.

[0141] The processing unit 12 of the information processing device 1 vectorizes the information indicating the question about the program from the user UC acquired in step S24 (step S25). The vectorization of the information indicating the question about the program from the user UC is performed by the same process as the vectorization of the question information described above. Hereinafter, the vectorized information indicating the question about the program from the user UC may be referred to as input vector information for convenience.

[0142] Next, the processing unit 12 of the information processing device 1 extracts answer information linked to question information corresponding to the information indicating the question about the program from the user UC acquired in step S24 from among the multiple pieces of question information stored in the storage unit 11 (step S26). The question information stored in the storage unit 11 is vectorized as described above, and hereinafter, the vectorized question information may be referred to as question vector information for convenience.

[0143] In step S26, the processing unit 12 extracts question vector information having a high similarity to the input vector information from the storage unit 11, for example, by vector neighborhood search. For example, the processing unit 12 extracts question vector information having the highest similarity to the input vector information from the storage unit 11. The processing unit 12 can also extract m pieces (m is an integer of 2 or more) of question vector information from the storage unit 11 in descending order of similarity to the input vector information.

[0144] Then, the processing unit 12 extracts answer information linked to the acquired question vector information from the storage unit 11. When there are multiple pieces of acquired question vector information, the processing unit 12 extracts answer information linked to each of the multiple pieces of acquired question vector information from the storage unit 11.

[0145] Next, the processing unit 12 of the information processing device 1 provides the answer information extracted in step S26 or answer information based on the answer information to the user UC (step S27). For example, when only one piece of answer information is extracted in step S26, the processing unit 12 provides the answer information extracted in step S26 to the user UC by transmitting the answer information extracted in step S26 to the terminal device 2C.

[0146] In addition, when the processing unit 12 extracts only one answer information in step S26, it can input information including this answer information and information indicating the question regarding the program from the user UC obtained in step S24 into the language model as input information, and cause the language model to generate answer information to the question regarding the program from the user UC.

[0147] For example, the processing unit 12 uses as input information the information (instruction information) of the character string "Please give an appropriate answer to the following question by referring to the answer examples below", information indicating the question about the program from the user UC acquired in step S24, and information including the one piece of answer information extracted in step S26, and generates answer information to the question about the program from the user UC in the language model. The information including the one piece of answer information extracted in step S26 is used as information indicating the answer example.

[0148] In addition, when the processing unit 12 extracts multiple pieces of answer information in step S26, it inputs information including these multiple pieces of answer information and information indicating the question regarding the program from the user UC acquired in step S24 into the language model as input information, and causes the language model to generate answer information to the question regarding the program from the user UC.

[0149] For example, the processing unit 12 uses as input information the information (instruction information) of the character string "Please tell me an appropriate answer to the following question by referring to the answer examples below", information indicating the question about the program from the user UC acquired in step S24, and information including the multiple pieces of answer information extracted in step S26, and generates answer information to the question about the program from the user UC in the language model. The information including the multiple pieces of answer information extracted in step S26 is used as information indicating the answer examples.

[0150] In addition, the processing unit 12 can also use information that further includes related information related to the question indicated in the question information acquired in step S21 as input information to generate answer information to the program-related question from the user UC in the language model.

[0151] In the above example, the processing unit 12 extracts question vector information having a high similarity to the input vector information from the storage unit 11, but the method of extracting question information is not limited to this example. For example, the processing unit 12 can determine the similarity using the Jaccard coefficient or the Dice coefficient instead of vectorization, or can determine the similarity using TF-IDF (Term Frequency Inverse Document Frequency) or the like.

[0152] The processing unit 12 can also determine the similarity by using a language model. For example, the processing unit 12 can input information including two pieces of information to be compared and information indicating an instruction for comparing these two pieces of information (for example, information such as a character string "Please determine the similarity between the following two questions") to the language model as input information, and cause the language model to determine and output the similarity.

[0153] Furthermore, when the processing unit 12 receives a question about the program from the user UC, it can also perform the processes of steps S21 and S22 and provide the answer information generated in step S22 to the user UC.

[0154] In this way, the information processing device 1 acquires question information, which is information indicating a question about a program, and generates answer information, which is information indicating an answer to the question indicated by the question information, by using a language model that generates and outputs information according to input information. This allows the information processing device 1 to support the user UC in appropriately providing the content that the user UC wants to confirm about the program.

[0155] The configuration of an information processing system including an information processing device 1 that performs such processing and a plurality of terminal devices 2 will be described in detail below.

[0156] 2. Configuration of the Information Processing System 5 is a diagram showing an example of a configuration of an information processing system according to an embodiment. As shown in FIG. 5, an information processing system 100 according to an embodiment includes an information processing device 1 and a plurality of terminal devices 2.

[0157] The multiple terminal devices 2 are used by different users U. The terminal devices 2 are, for example, a notebook PC (Personal Computer), a desktop PC, a smartphone, a tablet PC, or a wearable device. The wearable device is, for example, a smart glass or a smart watch, but is not limited to such examples.

[0158] The information processing device 1 and the terminal device 2 are connected to each other so as to be able to communicate with each other by wire or wirelessly via a network N. Note that the information processing system 100 shown in FIG.

[0159] The network N includes, for example, a Wide Area Network (WAN) such as the Internet and mobile communication networks such as Long Term Evolution (LTE), 4th Generation (4G), and 5th Generation (5G: fifth generation mobile communication system).

[0160] The terminal device 2 can connect to the network N via short-range wireless communication such as a mobile communication network, Bluetooth (registered trademark), or a wireless LAN (Local Area Network), and communicate with the information processing device 1.

[0161] 3. Configuration of information processing device 1 6 is a diagram showing an example of the configuration of the information processing device 1 according to the embodiment. As shown in FIG. 6, the information processing device 1 includes a communication unit 10, a storage unit 11, and a processing unit 12.

[0162] [3.1. Communication unit 10] The communication unit 10 is realized by, for example, a communication module or a NIC (Network Interface Card). The communication unit 10 is connected to a network N by wire or wirelessly, and transmits and receives information to and from various other devices. For example, the communication unit 10 transmits and receives information to and from the terminal device 2 via the network N.

[0163] [3.2. Storage section 11] The storage unit 11 is realized by, for example, a semiconductor memory element such as a RAM or a flash memory, or a storage device such as a hard disk or an optical disk. The storage unit 11 stores a user information storage unit 20, a program-related information storage unit 21, a question and answer information storage unit 22, and a generation history storage unit 23.

[0164] [3.2.1. User information storage unit 20] The user information storage unit 20 stores information about a user U. Fig. 7 is a diagram showing an example of a user information table stored in the user information storage unit 20 of the information processing device 1 according to the embodiment. As shown in Fig. 7, the user information table stored in the user information storage unit 20 includes items such as "User ID (Identifier)", "Attribute information", and "History information".

[0165] The "user ID" is identification information that identifies the user U. The "attribute information" is information on the user attributes of the user U corresponding to the "user ID", and includes information on psychographic attributes and information on demographic attributes. The demographic attributes are, for example, gender, age, place of residence, and occupation, while the psychographic attributes are interests such as travel, clothes, cars, and religion, lifestyle, thoughts, and ideological tendencies.

[0166] The "history information" includes a behavior history of the user U associated with the "user ID." The behavior history of the user U includes, for example, a history of questions posed by the user U, a history of answers provided to the user U by the information processing device 1 in response to the questions posed by the user U, and the like.

[0167] [3.2.2. Program-related information storage unit 21] The program-related information storage unit 21 stores various information related to the program. For example, the program-related information storage unit 21 stores various SDKs, various APIs, various programs, related confuls, and development materials.

[0168] An SDK is a set of development information targeted at the development of specific software, such as a specific platform, a specific system, or a specific software application, and includes various information necessary for developing software. For example, an SDK includes the SDK itself and various documents.

[0169] An API is an interface for exchanging information between software programs, and defines the procedures and data formats for calling and using functions and data of a piece of software from other software. API information includes, for example, API source code and API test code. The test code may be a test app or a part of it.

[0170] The information stored in the program-related information storage unit 21 is stored in a manner that allows extraction in a predetermined unit, for example. The predetermined unit is, for example, a library unit, a class unit, a method unit, or another function unit, but is not limited to such examples.

[0171] [3.2.3. Question and answer information storage unit 22] The question and answer information storage unit 22 stores question information and answer information for each piece of question information in a linked manner. The question and answer information storage unit 22 stores a plurality of tables including a question information table and an answer information table.

[0172] Each table is, for example, a database. The question information table is a database that stores vectorized data, for example, but not limited to, a vector database. The answer information table is, for example, but not limited to, a relational database.

[0173] 8 is a diagram showing an example of a question information table stored in the question answer information storage unit 22 of the information processing device 1 according to the embodiment. As shown in Fig. 8, the question information table stored in the question answer information storage unit 22 includes items such as "question ID" and "question information".

[0174] The "question ID" is identification information for identifying a question. The "question information" is information indicating a question corresponding to the "question ID", and the question information is vectorized.

[0175] 9 is a diagram showing an example of an answer information table stored in the question answer information storage unit 22 of the information processing device 1 according to the embodiment. As shown in Fig. 9, the answer information table stored in the question answer information storage unit 22 includes items such as "answer ID", "question ID", and "answer information".

[0176] "Answer ID" is identification information for identifying answer information. "Question ID" is a question ID for identifying question information linked to answer information corresponding to the "Answer ID". "Answer information" is answer information corresponding to the "Answer ID".

[0177] [3.2.4. Generation History Storage Unit 23] The generation history storage unit 23 stores implementation documents previously generated by the processing unit 12. Fig. 10 is a diagram showing an example of a generation information table stored in the generation history storage unit 23 of the information processing device 1 according to the embodiment.

[0178] 10, the generation information table stored in the generation history storage unit 23 includes items such as “generation ID,” “target code,” and “implementation document.” The “generation ID” is identification information for identifying the implementation document generated by the processing unit 12.

[0179] "Target Code" is information that identifies the target code, which is the code that was the subject of the implementation document corresponding to the "Generation ID." "Implementation Document" is the implementation document corresponding to the "Generation ID" or information that identifies that implementation document.

[0180] The implementation document includes, for example, information on each function realized by the target code, sample code, etc. For example, the implementation document is a document that describes an overall overview of the target code, items of each function realized by the target code, contents (explanation), code, etc. in the order of implementation, but is not limited to such an example.

[0181] [3.3. Processing section 12] The processing unit 12 is a controller, and is realized by a processor such as a CPU or MPU (Micro Processing Unit) executing various programs (corresponding to an example of an information processing program) stored in a storage device inside the information processing device 1 using a RAM or the like as a working area.

[0182] Furthermore, the processing unit 12 is a controller, and may be realized by an integrated circuit such as an application specific integrated circuit (ASIC), a field programmable gate array (FPGA), or a general purpose graphic processing unit (GPGPU).

[0183] 6, the processing unit 12 has an acquisition unit 30, a reception unit 31, a generation unit 32, a storage processing unit 33, an extraction unit 34, and a provision unit 35, and realizes or executes the functions and actions of information processing described below. Note that the internal configuration of the processing unit 12 is not limited to the configuration shown in FIG. 6, and may be other configurations as long as they perform the information processing described below.

[0184] [3.3.1. Acquisition part 30] The acquisition unit 30 acquires various pieces of information from an external information processing device, the terminal device 2, etc. via the communication unit 10. For example, the acquisition unit 30 acquires user information from the external information processing device or the terminal device 2, and updates the user information table stored in the user information storage unit 20 based on the acquired user information.

[0185] In addition, the acquisition unit 30 acquires, for example, information on various SDKs, various APIs, various programs, related confuls, and development materials from an external information processing device or the like via the communication unit 10, and stores the acquired information in the program-related information storage unit 21.

[0186] Furthermore, the acquiring unit 30 acquires various information included in the request accepted by the accepting unit 31. For example, when the request accepted by the accepting unit 31 is an implementation document generation request, the acquiring unit 30 acquires information included in the implementation document generation request. The implementation document generation request includes information for identifying the code that is the subject of the implementation document, etc.

[0187] The acquiring unit 30 also acquires various types of information from the storage unit 11. For example, the acquiring unit 30 acquires target code, which is code included in the SDK and is a target of the implementation document, from the program-related information storage unit 21 or the like. The target code includes, for example, source code and test code included in the SDK, but may be either one of these codes.

[0188] The acquiring unit 30 also acquires target code, which is code of an API that is the target of the implementation document, from the program-related information storage unit 21 or the like. The target code includes, for example, source code of the API and test code of the API, but may be either one of these. The target code may be code selected by the user UB from the code of the target API, or the like.

[0189] For example, when the receiving unit 31 receives the target code identifying information, the acquiring unit 30 acquires the code identified by the target code identifying information as the target code from the program-related information storage unit 21 or the like.

[0190] Furthermore, the acquiring unit 30 acquires information indicating a question regarding the program. For example, when a question regarding the program from the user U is accepted by the accepting unit 31, the acquiring unit 30 acquires information indicating the question accepted by the accepting unit 31 as question information. The question regarding the program is a question regarding a code of a predetermined unit, and is, for example, a question that the operator of the information processing device 1 or the user U expects the user U to ask.

[0191] Furthermore, the acquiring unit 30 acquires, as the question information, information generated by the language model and indicating a question regarding a code of a predetermined unit. For example, the acquiring unit 30 acquires, as the question information, information generated by the generating unit 32 and indicating a question regarding a code of a predetermined unit.

[0192] Moreover, the acquiring unit 30 acquires a code of a predetermined unit from the program-related information storage unit 21 or the like. The code of the predetermined unit is, for example, a code of a library unit, a code of a class unit, or a code of a method unit, but is not limited to these examples.

[0193] Moreover, the acquiring unit 30 acquires answer acquiring information generated in the language model from the storage unit 11 or an external information processing device.

[0194] [3.3.2. Reception Unit 31] The reception unit 31 receives various requests and various pieces of information from the terminal device 2 or an external information processing device via the communication unit 10.

[0195] For example, the reception unit 31 receives a code list request transmitted from the terminal device 2. The user U can operate the terminal device 2 to transmit the code list request from the terminal device 2 to the information processing device 1. The code list request is, for example, an SDK code list request or an API list request, but is not limited to these examples.

[0196] Furthermore, the receiving unit 31 receives target code identification information, which is information identifying the target code selected by the user U and is transmitted from the terminal device 2. The target code is the test code of the SDK, the source code of the SDK, etc. For example, the target code is the code in the test code that calls the function of the SDK and the code that performs processing before and after the function, the source code library, classes, methods, other functions, etc., but is not limited to such examples and may be a range of code selected by the user U.

[0197] For example, the reception unit 31 receives a question about a program from the user U. The reception unit 31 receives information indicating the question about the program from the user U and transmitted from the terminal device 2, thereby receiving the question about the program from the user U.

[0198] [3.3.3. Generation unit 32] The generation unit 32 generates various information. For example, the generation unit 32 generates an implementation document corresponding to the code of a language model that generates and outputs information according to input information, an implementation document corresponding to the code of an API, answer information, question information, and the like.

[0199] [3.3.3.1. Generating implementation documentation corresponding to SDK code] The generation unit 32 generates an implementation document including information about the target code, which is code of the SDK, using a language model that generates and outputs information according to input information. The information about the target code includes, but is not limited to, one or more of information indicating the function of the target code and information indicating the implementation procedure of the target code.

[0200] For example, the generation unit 32 inputs input information including the target code acquired by the acquisition unit 30 to a language model that generates and outputs information according to the input information, and causes the language model to generate an implementation document including information about the target code.

[0201] The language model is, for example, a model such as a transformer that is trained to estimate and output the next token from an input token string. The language model is stored in an internal storage unit or an external information processing device, and is created independently by the operator of the information processing device 1. Note that input information, such as personal information, can be kept secret by performing training so that the input information is not used as a new answer (output).

[0202] The generation unit 32, for example, inputs input information into the language model using an API provided by a business that provides use of the language model, and acquires information generated by the language model via the communication unit 10, but the information processing device 1 may be configured to include the language model.

[0203] The generating unit 32 inputs input information including the target code acquired by the acquiring unit 30 and instruction information indicating an instruction for outputting an implementation document of the target code, to cause the language model to generate an implementation document including information related to the target code. The instruction information is an example of information indicating an instruction for outputting information related to the target code.

[0204] The instruction information includes, for example, information that specifies the format of the implementation document. The format of the implementation document includes, for example, information that specifies multiple elements that make up the implementation document, information that indicates the arrangement order of the multiple elements, information that specifies the content of each element, etc. The elements that make up the implementation document include, for example, but are not limited to, the function of the target code, the procedure or method for implementing the target code, and sample code.

[0205] The instruction information includes, for example, information for specifying the format of the implementation document, which includes information for specifying the type of format of the implementation document. The information for specifying the type of format is, for example, information indicating the type of format or information indicating the content of the type of format (for example, a format configuration or a format example). The type of format of the implementation document is, for example, a demo format, a tutorial format, a reference format, a use case format, etc.

[0206] The demo format is a pattern in which an overview of the target code is written at the beginning, and a set of a few lines of explanation and code is repeated in succession. The set of a few lines of explanation and code includes, for example, code that must be implemented in the test code and an explanation of that code.

[0207] The tutorial format is a writing format that allows you to touch on essential functions by reading from the beginning, and it is a format in which multiple codes that must be implemented in the test code are arranged adjacent to each other if they are highly related to each other; for example, the code for an ad request and the code for displaying an ad are arranged adjacent to each other.

[0208] The reference format is a format that comprehensively explains multiple functions of the target code, and includes, for example, multiple codes that must be implemented in the test code, as well as codes whose implementation is optional, and for example, each code is arranged according to its function.

[0209] The use case format is, for example, a format for explaining each implementation purpose, and items, explanations, codes, etc. are described for each purpose, such as obtaining and displaying advertisements, measuring the effectiveness of advertisements, etc. This allows the user U to carry out the necessary implementation based on the purpose he or she wants to achieve, and can improve the convenience of the user U when there are too many functions and search does not work.

[0210] The generation unit 32 uses as input information, for example, information including the string "Please create the implementation document for the following code in the format specified below." (an example of instruction information), the target code acquired by the acquisition unit 30, and information specifying the format of the implementation document, and causes the language model to generate the implementation document.

[0211] The language model may be generated by performing transfer learning on a pre-trained language model using training information including a code different from the target code and an implementation document including information about the code. Such transfer learning is also called fine tuning, for example. The implementation document in the training information is used as a label, for example.

[0212] The code included in the learning information and different from the target code is, for example, a predetermined unit of code. The predetermined unit of code is, for example, code of another SDK, code with Javadoc comments, etc. If the predetermined unit of code is code with Javadoc comments, the information about the code is, for example, the Javadoc comments.

[0213] When using a language model subjected to transfer learning in this manner, the generating unit 32 can, for example, cause the language model to generate an implementation document using information including the target code acquired by the acquiring unit 30 as input information without using instruction information. Note that in this case as well, information such as a character string "Please create an implementation document for the following code" (an example of instruction information) may be included in the input information.

[0214] Furthermore, the generation unit 32 can cause the language model to generate an implementation document of the target code without performing transfer learning of the language model. The generation unit 32 causes the language model to generate an implementation document using, as input information, information further including another implementation document that is an implementation document of another code different from the target code.

[0215] For example, the generation unit 32 causes the language model to generate an implementation document using information including the target code, another implementation document that is an implementation document of another code different from the target code, and instruction information as input information.

[0216] For example, the generation unit 32 uses as input information the string "Please create the implementation document for the following code by referring to the implementation document below" (an example of instruction information), the target code acquired by the acquisition unit 30, and information including other implementation documents, and causes the language model to generate an implementation document.

[0217] The other implementation document may be, for example, an implementation document of code other than the code of the SDK, an implementation document previously generated by a language model, etc. The implementation document of code other than the code of the SDK may be, for example, an implementation document of code of another SDK, an implementation document generated by Javadoc, etc. Note that the other implementation document may be an implementation document of the code of the target SDK.

[0218] The generation unit 32 can also cause the language model to generate an implementation document using information further including a code corresponding to another implementation document as input information. In this case, the code corresponding to the other implementation document and the other implementation document are used for so-called temporary memory learning in the language model as examples of input and output.

[0219] The generation unit 32 inputs a language model using as input information information including, for example, information on the character string "<input example>", code corresponding to other implementation documents, information on the character string "<output example>", other implementation documents, information on the character string "Please create an implementation document for the following code by referring to the above-mentioned example." (an example of instruction information), and the target code.

[0220] In addition, the generation unit 32 generates an implementation document in a language model using information including commented source code as input information for the target code, but can also generate an implementation document in a language model using information including uncommented code as input information.

[0221] In addition, the generation unit 32 can also cause the language model to generate an implementation document using input information that further includes information on materials used during the development of the target code (e.g., materials on related confluencies of the target API and development materials for the target code, etc.).

[0222] The instruction information is not limited to the above-mentioned example, and may be any information that allows the language model to appropriately generate the implementation document. In addition, if the language model is a model that allows prompts to be input separately as system prompts and user prompts (e.g., gpt-3.5 or gpt-4 by OpenAI), the instruction information may be included in the input information as a system prompt. The system prompt is expressed, for example, as {"role":"system", "content":prompt}. Prompt is a system prompt and is expressed as text information.

[0223] In addition, if the language model is a model in which prompts can be input separately as system prompts, user prompts, and assistant prompts (for example, OpenAI's gpt-3.5 or gpt-4), the generation unit 32 can also include information indicating examples of the above-mentioned input and output for the user prompt and assistant prompt in the input information.

[0224] In addition, the generation unit 32 can, for example, cause a language model to generate a task for generating an implementation document for the target code, and input the execution result of such a task into the language model, thereby causing the language model to generate an implementation document for the target code.

[0225] For example, the generation unit 32 inputs information including the string "Please tell me the information necessary to generate an implementation document for the following code." (an example of instruction information) and the target code as input information into the language model, thereby causing the language model to generate specific information that identifies the information necessary to generate an implementation document for the target code.

[0226] In this case, the generation unit 32 collects information specified by the specific information output from the language model from the storage unit 11 or an external information processing device, etc. The information specified by the specific information is, for example, a code different from the target code, another implementation document that is an implementation document of a code different from the target code, etc. The generation unit 32 can cause the language model to generate an implementation document of the target code using, for example, information including the information specified by the specific information and the target code, etc. as input information.

[0227] In this way, the generation unit 32 inputs, for example, input information including the target code to the language model, and causes the language model to generate an implementation document of the target code. Note that it is sufficient to cause the language model to generate an implementation document of the target code, and the input information input to the language model is not limited to the above-mentioned example.

[0228] [3.3.3.2. Generate implementation documentation corresponding to API code] The generation unit 32 generates an implementation document including information about the target code, which is the code of the API, by using a language model that generates and outputs information according to the input information. The information about the target code includes, but is not limited to, one or more of information indicating the function of the target code and information indicating the implementation procedure of the target code.

[0229] For example, the generation unit 32 inputs input information including the target code acquired by the acquisition unit to a language model that generates and outputs information according to the input information, and causes the language model to generate an implementation document including information about the target code.

[0230] The language model is, for example, a model such as a transformer that is trained to estimate and output the next token from an input token string. The language model is stored in an internal storage unit or an external information processing device, and is created independently by the operator of the information processing device 1. Note that input information, such as personal information, can be kept secret by performing training so that the input information is not used as a new answer (output).

[0231] The generation unit 32, for example, inputs input information into the language model using an API provided by a business that provides use of the language model and obtains information generated by the language model, but the information processing device 1 may be configured to include the language model.

[0232] The generating unit 32 inputs input information including the target code acquired by the acquiring unit 30 and instruction information indicating an instruction for outputting an implementation document of the target code, to cause the language model to generate an implementation document including information related to the target code. The instruction information is an example of information indicating an instruction for outputting information related to the target code.

[0233] The instruction information includes, for example, information that specifies the format of the implementation document. The format of the implementation document includes, for example, information that specifies multiple elements that make up the implementation document, information that indicates the arrangement order of the multiple elements, information that specifies the content of each element, etc. The elements that make up the implementation document include, for example, but are not limited to, the function of the target code, the procedure or method for implementing the target code, and sample code.

[0234] The instruction information includes, for example, information for specifying the format of the implementation document, which includes information for specifying the type of format of the implementation document. The information for specifying the type of format is, for example, information indicating the type of format or information indicating the content of the type of format (for example, a format configuration or a format example). The type of format of the implementation document is, for example, a demo format, a tutorial format, a reference format, a use case format, etc.

[0235] The demo format is a pattern in which an overview of the target code is written at the beginning, and a set of a few lines of explanation and code is repeated in succession. The set of a few lines of explanation and code includes, for example, code that must be implemented in the test code and an explanation of that code.

[0236] The tutorial format is a writing format that allows you to touch on essential functions by reading from the beginning, and it is a format in which multiple codes that must be implemented in the test code are arranged adjacent to each other if they are highly related to each other; for example, the code for an ad request and the code for displaying an ad are arranged adjacent to each other.

[0237] The reference format is a format that comprehensively explains multiple functions of the target code, and includes, for example, multiple codes that must be implemented in the test code, as well as codes whose implementation is optional, and for example, each code is arranged according to its function.

[0238] The use case format is, for example, a format for explaining each implementation purpose, and for example, the items, explanations, and codes are described for each purpose. This allows the user U to perform the necessary implementation based on the purpose he or she wants to achieve, and can improve the convenience of the user U when there are too many functions and search does not work.

[0239] The generation unit 32 uses as input information, for example, information including the string "Please create the implementation document for the following code in the format specified below." (an example of instruction information), the target code acquired by the acquisition unit 30, and information specifying the format of the implementation document, and causes the language model to generate the implementation document.

[0240] The language model may be generated by performing transfer learning on a pre-trained language model using training information including a code of an API other than the target API, which is the target API of the implementation document, and an implementation document including information about the code. Such transfer learning is also called fine tuning, for example. The implementation document in the training information is used as a label, for example.

[0241] When using a language model subjected to transfer learning in this manner, the generating unit 32 can, for example, cause the language model to generate an implementation document using information including the target code acquired by the acquiring unit 30 as input information without using instruction information. Note that in this case as well, information such as a character string "Please create an implementation document for the following code" (an example of instruction information) may be included in the input information.

[0242] Furthermore, the generation unit 32 can cause the language model to generate an implementation document of the target code without performing transfer learning of the language model. The generation unit 32 causes the language model to generate an implementation document using, as input information, information including, for example, the target code acquired by the acquisition unit 30, another implementation document which is an implementation document of another API, and instruction information.

[0243] For example, the generation unit 32 generates an implementation document in a language model using as input information the string "Please create the implementation document for the following code by referring to the implementation document below," the target code acquired by the acquisition unit 30, and information including other implementation documents.

[0244] The other implementation document is, for example, an implementation document of an API different from the target API, and may be, but is not limited to, an implementation document created by an API engineer or an implementation document previously generated by a language model. Note that, in the case where code is added to or modified in the target API, the implementation document previously generated by a language model may be an implementation document of the code of the target API.

[0245] The generation unit 32 can also cause the language model to generate an implementation document using information including, in addition to the other implementation document, the code of another API corresponding to the other implementation document as input information. In this case, the other implementation document and the code of the other API corresponding to the other implementation document are used in so-called temporary memory learning in the language model as examples of input and output.

[0246] The generation unit 32 inputs a language model using as input information information including, for example, information on the character string "<input example>", codes of other APIs corresponding to other implementation documents, information on the character string "<output example>", other implementation documents, information on the character string "Please create an implementation document for the following code by referring to the above-mentioned example." (an example of instruction information), and the target code.

[0247] In addition, the generation unit 32 generates an implementation document in a language model using information including commented source code as input information for the target code, but can also generate an implementation document in a language model using information including uncommented code as input information.

[0248] In addition, the generation unit 32 can also cause the language model to generate an implementation document using as input information further including information on materials used during the development of the target API (e.g., materials on related confluencies of the target API and development materials for the target API, etc.).

[0249] The instruction information is not limited to the above-mentioned example, and may be any information that allows the language model to appropriately generate the implementation document. In addition, if the language model is a model that allows prompts to be input separately as system prompts and user prompts (e.g., gpt-3.5 or gpt-4 by OpenAI), the instruction information may be included in the input information as a system prompt. The system prompt is expressed, for example, as {"role":"system", "content":prompt}. Prompt is a system prompt and is expressed as text information.

[0250] In addition, if the language model is a model in which prompts can be input separately as system prompts, user prompts, and assistant prompts (for example, OpenAI's gpt-3.5 or gpt-4), the generation unit 32 can also include information indicating examples of the above-mentioned input and output for the user prompt and assistant prompt in the input information.

[0251] In addition, the generation unit 32 can, for example, cause a language model to generate a task for generating an implementation document for the target code, and input the execution result of such a task into the language model, thereby causing the language model to generate an implementation document for the target code.

[0252] For example, the generation unit 32 inputs information including the string "Please tell me the information necessary to generate an implementation document for the following code." (an example of instruction information) and the target code as input information into the language model, thereby causing the language model to generate specific information that identifies the information necessary to generate an implementation document for the target code.

[0253] In this case, the generation unit 32 collects information specified by the specific information output from the language model from the storage unit 11 or an external information processing device, etc. The information specified by the specific information is, for example, a code different from the target code, another implementation document that is an implementation document of such code, etc. The generation unit 32 can cause the language model to generate an implementation document of the target code using, for example, information including the information specified by the specific information and the target code, etc. as input information.

[0254] In this way, the generation unit 32 inputs, for example, input information including the target code to the language model, and causes the language model to generate an implementation document of the target code. Note that it is sufficient to cause the language model to generate an implementation document of the target code, and the input information input to the language model is not limited to the above-mentioned example.

[0255] [3.3.3.3. Generation of Question and Answer Information] The generation unit 32 generates question information and answer information using a language model that generates and outputs information according to input information.

[0256] [3.3.3.3.1. Generation of Question Information] First, generation of question information will be described. For example, the generation unit 32 causes a language model to generate information regarding a question for a code acquired by the acquisition unit 30, and acquires the information regarding the question from the language model. For example, the generation unit 32 causes a language model to generate information regarding a question for a code acquired by the acquisition unit 30 and having a predetermined unit, and acquires the information regarding the question from the language model.

[0257] The predetermined unit of code is, for example, but not limited to, a library unit of code, a class unit of code, a method unit of code, or other function unit of code. The language model is, for example, but not limited to, a model such as a transformer trained to estimate and output the next token from an input token string.

[0258] The generation unit 32, for example, inputs input information including a code of a predetermined unit and instruction information which is information indicating an instruction to output information indicating a question expected for the code, and performs a process of causing a language model to generate information indicating a question regarding the code of the predetermined unit for each code of the predetermined unit.

[0259] For example, the generation unit 32 uses as input information information including the character string "Please tell me some possible questions regarding the following code" (an example of instruction information) and a code of a predetermined unit, and generates information indicating a question regarding a code of a predetermined unit in a language model.

[0260] The language model may be generated by performing transfer learning on a pre-trained language model using learning information including a combination of past question information and answer information for each question information. The combination of past question information and answer information is a combination of past question information and answer information in an SDK, API, related conflu, etc., different from the information stored in the storage unit 11, but is not limited to such an example.

[0261] For example, when a combination of past question information and answer information for a code stored in the program-related information storage unit 21 or the like is stored in the question answer information storage unit 22 or the like, the generation unit 32 can use such combination as part or all of the learning information.

[0262] When using a language model that has undergone transfer learning in this way, the generation unit 32 can, for example, cause the language model to generate question information using information including a code of a predetermined unit as input information without using instruction information. Note that, in this case as well, the above-mentioned instruction information may be included in the input information.

[0263] [3.3.3.3.2. Generation of Answer Information] Next, generation of answer information will be described. The generating unit 32 generates answer information, which is information indicating an answer to a question indicated by question information acquired by the acquiring unit 30, using a language model that generates and outputs information according to input information. The language model is, for example, a model such as a transformer that is trained to estimate and output the next token from an input token string, but is not limited to such an example.

[0264] For example, the generation unit 32 inputs information including the question information acquired by the acquisition unit 30 to the language model as input information, and causes the language model to generate answer information or information for obtaining the answer information.

[0265] For example, the generation unit 32 uses information including the character string "Please create an answer to the following question" and the question information acquired by the acquisition unit 30 as input information and causes the language model to generate answer information.

[0266] In addition, the generation unit 32 can also generate answer information in a language model using as input information information including, for example, a character string "The following question is asked about the following code. Please create an answer to this question.", the code extracted by the extraction unit 34, and the question information acquired by the acquisition unit 30.

[0267] Furthermore, the generating unit 32 can cause the language model to generate information for obtaining answer information using, as input information, information including, for example, the character string "Please create an answer to the following question" (an example of instruction information) and the question information acquired by the acquiring unit 30. In this case, the generating unit 32 can also include the code extracted by the extracting unit 34 in the input information.

[0268] In addition, the generation unit 32 can generate information in a language model for obtaining answer information using information including, for example, the character string "Please tell me the information necessary to answer the following question" (an example of instruction information) and the question information acquired by the acquisition unit 30 as input information.

[0269] In this case, the generation unit 32 can also include the code extracted by the extraction unit 34 in the input information. For example, the generation unit 32 can cause the language model to generate information for obtaining answer information using as input information information including the character string "Please tell me the information necessary to answer the following question for the following code", the code extracted by the extraction unit 34, and the question information acquired by the acquisition unit 30.

[0270] The information for obtaining the answer information is, for example, search information corresponding to the question indicated in the question information acquired by the acquisition unit 30. The search information includes, for example, information for identifying a search target. The information for identifying a search target is, for example, information for identifying information such as a class or resource related to the code extracted by the extraction unit 34.

[0271] Classes related to the code extracted by the extraction unit 34 include, for example, classes that include methods and functions used by the code extracted by the extraction unit 34, and classes that are inherited by the class of the code extracted by the extraction unit 34.

[0272] Furthermore, the resource related to the code extracted by the extraction unit 34 is, for example, information on the resource required to execute the code extracted by the extraction unit 34. The resource is a configuration file, a database, a hardware resource, etc. The hardware resource is, but is not limited to, a CPU, a GPU, a RAM, a disk capacity, etc.

[0273] The generating unit 32 inputs information including the answer acquisition information generated by the language model and acquired by the acquiring unit 30 to the language model as input information, and can cause the language model to generate answer information.

[0274] For example, when the generation unit 32 causes the language model to generate search information as answer acquisition information, the generation unit 32 searches the storage unit 11 or the like for related information related to the question indicated by the question information acquired by the acquisition unit 30, based on the search information. The related information is, for example, information on classes, resources, etc. related to the code extracted by the extraction unit 34.

[0275] Then, the generation unit 32 inputs information including the related information searched as described above and the question information acquired by the acquisition unit 30 to the language model as input information, and causes the language model to generate answer information. In this case, the generation unit 32 can also use information further including the code extracted by the extraction unit 34 as input information.

[0276] When the extraction unit 34 extracts only one piece of answer information, the generation unit 32 can input information including this answer information and information indicating the question about the program from the user U acquired by the acquisition unit 30 as input information into the language model, and cause the language model to generate answer information to the question about the program from the user U. Hereinafter, answer information generated in the language model using information including the answer information extracted by the extraction unit 34 as input information may be referred to as answer information based on answer information.

[0277] For example, the generation unit 32 uses as input information information (instruction information) the character string "Please give an appropriate answer to the following question by referring to the answer examples below", information indicating a question about a program from the user U acquired by the acquisition unit 30, and information including one piece of answer information extracted by the extraction unit 34, and generates answer information to the question about the program from the user U in the language model. The information including one piece of answer information extracted by the extraction unit 34 is used as information indicating the answer example.

[0278] In addition, when there are multiple pieces of answer information extracted by the extraction unit 34, the generation unit 32 inputs information including these multiple pieces of answer information and information indicating a question about the program from user U acquired by the acquisition unit 30 into the language model as input information, and causes the language model to generate answer information to the question about the program from user U.

[0279] For example, the generation unit 32 uses as input information information (instruction information) such as the character string "Please give an appropriate answer to the following question by referring to the answer examples below", information indicating a question about a program from the user U acquired by the acquisition unit 30, and information including a plurality of pieces of answer information extracted by the extraction unit 34, and generates answer information to the question about the program from the user U in the language model. The information including the plurality of pieces of answer information extracted by the extraction unit 34 is used as information indicating the answer examples.

[0280] In addition, the generation unit 32 can also use information that further includes related information related to the question indicated in the question information acquired by the acquisition unit 30 as input information to generate answer information to a question regarding a program from a user U in a language model.

[0281] In addition, when a question regarding a program from user U is accepted by the accepting unit 31 and information indicating the question regarding the program from user U is acquired by the acquiring unit 30, the generating unit 32 can input information including the information indicating the question regarding the program from user U as question information into the language model as input information, and cause the language model to generate answer information or information for obtaining the answer information.

[0282] [3.3.3.3.3. Example of configuration of generation unit 32] Fig. 11 is a diagram illustrating an example of the configuration of the generation unit 32 of the information processing device 1 according to the embodiment. In the example illustrated in Fig. 11, the generation unit 32 includes a first generation unit 40, a search unit 41, and a second generation unit 42.

[0283] The first generating unit 40 generates an implementation document of the target code, question information, answer information, answer acquisition information, etc. For example, the first generating unit 40 generates an implementation document including information about the target code, which is code of the SDK, by using a language model that generates and outputs information according to input information.

[0284] The first generating unit 40 also generates an implementation document including information about the target code, which is the code of the API, using a language model that generates and outputs information according to the input information. The first generating unit 40 also inputs information including the question information acquired by the acquiring unit 30 as input information to the language model, and generates answer information, which is information indicating an answer to the question indicated by the question information, in the language model.

[0285] Furthermore, the first generating unit 40 inputs information including the question information acquired by the acquiring unit 30 to the language model as input information, and causes the language model to generate search information corresponding to the question indicated by the question information.

[0286] For example, the first generation unit 40 generates in a language model the above-mentioned search information, which is information for obtaining answer information using information including the character string "Please tell me the information necessary to answer the following question" (an example of instruction information) and the question information acquired by the acquisition unit 30 as input information.

[0287] The first generating unit 40 can also include the code extracted by the extracting unit 34 in the input information. For example, the first generating unit 40 can cause the language model to generate search information using, as input information, information including the character string "Please tell me the information necessary to answer the following question for the following code," the code extracted by the extracting unit 34, and the question information acquired by the acquiring unit 30.

[0288] The search information includes, for example, information for identifying a search target, such as information for identifying a class, resource, or other information related to the code extracted by the extraction unit 34, as described above.

[0289] The search unit 41 searches for related information related to the question based on the search information generated by the first generation unit 40. For example, when the first generation unit 40 causes a language model to generate search information, the search unit 41 searches the storage unit 11 or the like for related information related to the question indicated by the question information acquired by the acquisition unit 30 based on the search information. The related information is, for example, information such as a class or a resource related to the code extracted by the extraction unit 34.

[0290] The second generation unit 42 inputs information including the question information acquired by the acquisition unit 30 and the related information searched by the search unit 41 as input information into the language model, and causes the language model to generate answer information, which is information indicating an answer corresponding to the question.

[0291] [3.3.4. Memory Processing Unit 33] The storage processing unit 33 links the question information and the answer information to each other and stores them for each piece of question information in the question answer information storage unit 22. For example, the storage processing unit 33 links the question information acquired by the acquisition unit 30 and the answer information generated by the generation unit 32 to each other and stores them for each piece of question information in the question answer information storage unit 22.

[0292] For example, the storage processing unit 33 vectorizes the question information, links the vectorized question information to the answer information, and stores the vectorized question information in the question and answer information storage unit 22. The question information is vectorized by embedding using a language model such as text-embedding-ada or BERT. For example, the storage processing unit 33 inputs the question information as input information into the language model via an API or the like, and obtains information obtained by vectorizing the question information from the language model.

[0293] Note that the language model for vectorizing the question information may be provided in, for example, the information processing device 1. In this case, the storage processing unit 33 can vectorize the question information using the language model provided in the information processing device 1. Note that vectorization of the question information is not limited to embedding using the language model, and the question information may be vectorized using, for example, Doc2Vec, an average of word embedding, or the like.

[0294] [3.3.5. Extraction part 34] The extraction unit 34 extracts answer information linked to question information corresponding to information indicating a question about a program from a user U acquired by the acquisition unit 30, from among the multiple pieces of question information stored in the question and answer information storage unit 22.

[0295] For example, the extraction unit 34 vectorizes the information indicating a question about a program from the user U acquired by the acquisition unit 30, and generates input vector information. The vectorization of the information indicating a question about a program from the user U is performed by the same process as the vectorization of the question information.

[0296] Then, the extraction unit 34 extracts answer information linked to question vector information corresponding to the input vector information from among the multiple pieces of question information stored in the answer-to-question information storage unit 22. The question vector information is question information that has been vectorized as described above.

[0297] The extraction unit 34 extracts question vector information having a high similarity to the input vector information from the question answer information storage unit 22, for example, by vector neighborhood search. For example, the extraction unit 34 extracts question vector information having the highest similarity to the input vector information from the question answer information storage unit 22. The extraction unit 34 can also extract m pieces (m is an integer of 2 or more) of question vector information from the question answer information storage unit 22 in descending order of similarity to the input vector information.

[0298] Then, the extraction unit 34 extracts the answer information linked to the acquired question vector information from the question answer information storage unit 22. When there is a plurality of pieces of acquired question vector information, the extraction unit 34 extracts from the question answer information storage unit 22 the answer information linked to each of the plurality of pieces of acquired question vector information.

[0299] In this way, the extraction unit 34 can extract answer information linked to vectorized question information corresponding to the vectorized information, which is information indicating a question acquired by the acquisition unit 30, from the memory unit.

[0300] In the above example, the extraction unit 34 extracts question vector information having a high similarity to the input vector information from the storage unit 11, but the method of extracting question information is not limited to this example. For example, the extraction unit 34 can determine the similarity using the Jaccard coefficient or the Dice coefficient instead of vectorization, or can determine the similarity using TF-IDF or the like.

[0301] The extraction unit 34 can also determine the similarity using a language model. For example, the extraction unit 34 can input information including two pieces of information to be compared and information indicating an instruction for comparing these two pieces of information (for example, information of a character string "Please determine the similarity between the following two questions") to the language model as input information, and cause the language model to determine and output the similarity.

[0302] [3.3.6.Providing Department 35] The providing unit 35 provides various pieces of information. For example, the providing unit 35 provides the various pieces of information to the user U by transmitting the various pieces of information to the terminal device 2 via the communication unit 10.

[0303] When the receiving unit 31 receives an SDK code list request, the providing unit 35 causes the terminal device 2 to display information indicating a list of codes (e.g., test codes, libraries, classes, methods, other functions, etc.) included in the SDK stored in the program-related information storage unit 21. The providing unit 35 can also cause the terminal device 2 to display information indicating a list of codes newly added to the SDK, codes modified in the SDK, etc.

[0304] Furthermore, the providing unit 35 causes the terminal device 2 to display information indicating a list of APIs stored in the program-related information storage unit 21. Furthermore, the processing unit 12 can also cause the terminal device 2 to display information indicating a list of newly added APIs, modified APIs, and the like.

[0305] When a user U operates the terminal device 2 to select a code or an API while a list of SDK codes or a list of APIs is displayed on the terminal device 2, an implementation document generation request is sent from the terminal device 2 to the information processing device 1.

[0306] In addition, the providing unit 35 can transmit the implementation document generated by the generating unit 32 to the terminal device 2 and cause the terminal device 2 to display the implementation document generated by the generating unit 32 in a manner that allows the user U to edit it.

[0307] Furthermore, the providing unit 35 provides the answer information extracted by the extracting unit 34 or answer information based on the answer information to the user U. When the extracting unit 34 extracts one or more pieces of answer information, the providing unit 35 transmits the one or more pieces of answer information extracted by the extracting unit 34 to the terminal device 2, thereby providing the one or more pieces of answer information extracted by the extracting unit 34 to the user U.

[0308] In addition, the providing unit 35 can also provide the user U with answer information based on the answer information extracted by the extraction unit 34 by transmitting answer information generated by the generation unit 32 using one or more answer information extracted by the extraction unit 34 as answer information based on the answer information extracted by the extraction unit 34.

[0309] The providing unit 35 also provides the answer information generated by the generating unit 32 to the user U, which is information indicating an answer to the question received by the receiving unit 31 and is information indicating the question received by the receiving unit 31, as question information. The providing unit 35 provides the answer information generated by the generating unit 32 to the user U by transmitting the answer information generated by the generating unit 32 to the terminal device 2.

[0310] 4. Processing Procedure Next, a procedure of information processing by the processing unit 12 of the information processing device 1 according to the embodiment will be described. Fig. 12 is a flowchart showing an example of information processing by the processing unit 12 of the information processing device 1 according to the embodiment.

[0311] 12, the processing unit 12 of the information processing device 1 determines whether it is the first generation timing (step S30). The first generation timing is the timing at which an SDK implementation document generation request is received from the terminal device 2, but may also be the timing at which code is added to the SDK, the timing at which the SDK code is modified, or the timing at which a request is made by the operator of the information processing device 1.

[0312] When it is determined that it is the first generation timing (step S30: Yes), the processing unit 12 executes a first implementation document generation process (step S31). The process of step S31 is the process of steps S40 to S43 shown in FIG. 13, and will be described in detail later.

[0313] When the processing of step S31 is completed, or when it is determined that it is not the first generation timing (step S30: No), the processing unit 12 determines whether it is the second generation timing (step S32).

[0314] The second generation timing is the timing when a request for generating an API implementation document is received from the terminal device 2, but it may also be the timing when a new API is generated, when code is added to the API, when the API code is modified, or when a request is made by the operator of the information processing device 1.

[0315] When it is determined that it is the second generation timing (step S32: Yes), the processing unit 12 executes a second implementation document generation process (step S33). The process of step S33 is the process of steps S50 to S54 shown in FIG. 14, and will be described in detail later.

[0316] When the processing of step S33 is completed, or when it is determined that it is not the second generation timing (step S32: No), the processing unit 12 determines whether it is the third generation timing (step S ).

[0317] The third generation timing is, for example, the timing when a request is made by the operator of the information processing device 1, but it may also be the timing when code is added to the SDK, the timing when the SDK code is modified, the timing when a new API is generated, the timing when code is added to the API, the timing when the API code is modified, etc.

[0318] When it is determined that it is the third generation timing (step S34: Yes), the processing unit 12 executes a response information generation process (step S35). The process of step S35 is the process of steps S60 to S63 shown in FIG. 15, and will be described in detail later.

[0319] When the processing of step S35 is completed, or when it is determined that it is not the third generation timing (step S34: No), the processing unit 12 determines whether or not a question has been received from the user U (step S36).

[0320] When it is determined that a question from the user U has been accepted (step S36: Yes), the processing unit 12 executes an answering process (step S37). The process of step S37 is the process of steps S70 to S72 shown in FIG. 16, and will be described in detail later.

[0321] When the processing of step S37 is completed or when it is determined that a question from the user U has not been accepted (step S36: No), the processing unit 12 determines whether or not the operation end timing has arrived (step S38). The processing unit 12 determines that the operation end timing has arrived when, for example, the power supply of the information processing device 1 is turned off.

[0322] If the processing unit 12 determines that the operation end time has not arrived (step S38: No), it transitions to step S30, and if it determines that the operation end time has arrived (step S38: Yes), it terminates the processing shown in FIG. 12.

[0323] 13 is a flowchart showing an example of a first implementation document generation process by the processing unit 12 of the information processing device 1 according to the embodiment. As shown in FIG 13, the processing unit 12 selects code included in the SDK as target code (step S40), and extracts the selected target code from the storage unit 11 (step S41).

[0324] Next, the processing unit 12 uses the language model to generate an implementation document including information about the target code (step S42). Then, the processing unit 12 stores the implementation document generated in step S42 in the storage unit 11 (step S43), and ends the process shown in FIG.

[0325] 14 is a flowchart showing an example of a second implementation document generation process by the processing unit 12 of the information processing device 1 according to the embodiment. As shown in FIG 14, the processing unit 12 selects an API (step S50), and extracts the code of the selected API as a target code from the storage unit 11 (step S51).

[0326] Next, the processing unit 12 uses the language model to generate an implementation document including information about the target code (step S52). Then, the processing unit 12 stores the implementation document generated in step S52 in the storage unit 11 (step S53), and ends the process shown in FIG.

[0327] Fig. 15 is a flowchart showing an example of an answer information generation process by the processing unit 12 of the information processing device 1 according to the embodiment. As shown in Fig. 15, the processing unit 12 extracts a code from the storage unit 11 (step S60), and generates answer information for the code extracted in step S60 by using a language model (step S61).

[0328] Next, the processing unit 12 associates the answer information generated in step S61 with the question information and stores the answer information in the storage unit 11 (step S62). When the processing of step S62 ends, the processing unit 12 determines whether or not all codes that are the subject of the answer have been extracted (step S63).

[0329] If the processing unit 12 determines that not all codes have been extracted (step S63: No), it transitions to step S60, and if it determines that all codes have been extracted (step S63: Yes), it terminates the processing shown in FIG. 15.

[0330] Fig. 16 is a flowchart showing an example of an answering process by the processing unit 12 of the information processing device 1 according to the embodiment. As shown in Fig. 16, the processing unit 12 acquires information indicating a question about a program from the storage unit 11 (step S70), and acquires answering information corresponding to the information indicating the question about the program (step S71). Then, the processing unit 12 provides the acquired answering information to the user U (step S72), and ends the process shown in Fig. 16.

[0331] 5. Modifications The generating unit 32 can also generate answer information according to the attributes of the user U who has asked the question, for example. In this case, the generating unit 32 can cause the language model to generate information for obtaining answer information using as input information information including, for example, a character string "Please create an answer to the following question, for a questioner having the following attributes", the question information acquired by the acquiring unit 30, and information indicating the attributes of the user U who has asked the question.

[0332] The generation unit 32 can also generate an implementation document including a system configuration diagram. The generation unit 32 can generate a system configuration diagram from a target code or the like by using, for example, a multimodal language model (for example, gpt4) or an image generation AI (Artificial Intelligence).

[0333] In addition, the generation unit 32 can also generate implementation documents, answer information, question information, and the like, in the language model by using information that further includes information stored in a knowledge database such as KDocs (Knowledge, Documents, and Collaboration System) as input information for the language model.

[0334] Furthermore, when generating multiple implementation documents in succession, the generation unit 32 can cause the language model to generate the next implementation document using information including the implementation document generated using the language model immediately before as input information. For example, when multiple codes to be the subject of implementation documents are selected or when the code of the entire SDK is selected, the generation unit 32 causes the language model to generate the next implementation document using information including the implementation document previously generated using the language model as input information.

[0335] Furthermore, the source code in the above-mentioned target code may be, for example, names of classes, methods, etc. in the source code, variables in classes, methods, etc. in the source code, and added comments.

[0336] The generation unit 32 can also cause the language model to generate an implementation document using as input information information further including the answer information and question information generated as described above. The generation unit 32 can also cause the language model to generate answer information and question information using as input information information further including the implementation document generated as described above.

[0337] [6. Hardware Configuration] The information processing device 1 according to the embodiment described above is realized by a computer 80 having a configuration as shown in Fig. 17. Fig. 17 is a hardware configuration diagram showing an example of the computer 80 that realizes the functions of the information processing device 1 according to the embodiment. The computer 80 has a CPU 81, a RAM 82, a ROM (Read Only Memory) 83, a HDD (Hard Disk Drive) 84, a communication interface (I / F) 85, an input / output interface (I / F) 86, and a media interface (I / F) 87.

[0338] The CPU 81 operates and controls each part based on a program stored in the ROM 83 or the HDD 84. The ROM 83 stores a boot program executed by the CPU 81 when the computer 80 is started up, and programs that depend on the hardware of the computer 80.

[0339] The HDD 84 stores programs executed by the CPU 81, data used by such programs, etc. The communication interface 85 receives data from other devices via the network N (see FIG. 5) and sends it to the CPU 81, and transmits data generated by the CPU 81 to other devices via the network N.

[0340] The CPU 81 controls output devices such as a display and a printer, and input devices such as a keyboard and a mouse, via the input / output interface 86. The CPU 81 acquires data from the input devices via the input / output interface 86. The CPU 81 also outputs data generated via the input / output interface 86 to the output devices.

[0341] The media interface 87 reads a program or data stored in a recording medium 88 and provides it to the CPU 81 via the RAM 82. The CPU 81 loads the program from the recording medium 88 onto the RAM 82 via the media interface 87 and executes the loaded program. The recording medium 88 is, for example, an optical recording medium such as a DVD (Digital Versatile Disc) or a PD (Phase change rewritable Disc), a magneto-optical recording medium such as an MO (Magneto-Optical disk), a tape medium, a magnetic recording medium, or a semiconductor memory.

[0342] For example, when the computer 80 functions as the information processing device 1 according to the embodiment, the CPU 81 of the computer 80 executes a program loaded onto the RAM 82 to realize the function of the processing unit 12. In addition, the HDD 84 stores data in the storage unit 11. The CPU 81 of the computer 80 reads and executes these programs from a recording medium 88, but as another example, these programs may be obtained from another device via the network N.

[0343] [7. Other] In addition, among the processes described in the above embodiments, all or part of the processes described as being performed automatically can be performed manually, or all or part of the processes described as being performed manually can be performed automatically by a known method. In addition, the information including the processing procedures, specific names, various data and parameters shown in the above documents and drawings can be changed arbitrarily unless otherwise specified. For example, the various information shown in each drawing is not limited to the illustrated information.

[0344] In addition, each component of each device shown in the figure is a functional concept, and does not necessarily have to be physically configured as shown in the figure. In other words, the specific form of distribution and integration of each device is not limited to that shown in the figure, and all or part of them can be functionally or physically distributed and integrated in any unit according to various loads, usage conditions, etc.

[0345] For example, the above-mentioned information processing device 1 may be realized by a terminal device and a server computer, or may be realized by multiple server computers. Also, depending on the functions, the configuration can be flexibly changed, such as by calling an external platform using an API or network computing.

[0346] Furthermore, the above-described embodiments and modifications can be appropriately combined as long as the processing contents are not contradictory.

[0347] 8. Effects As described above, the information processing device 1 according to the embodiment includes an acquisition unit 30 and a generation unit 32. The acquisition unit 30 acquires target code, which is code included in a software development kit and is the subject of an implementation document. The generation unit 32 inputs input information including the target code acquired by the acquisition unit 30 to a language model that generates and outputs information according to the input information, and causes the language model to generate an implementation document including information related to the target code. This allows the information processing device 1 to reduce the burden of creating an implementation document for code included in an SDK.

[0348] In addition, the generation unit 32 causes the language model to generate an implementation document using information including an implementation document of another code different from the target code as input information. This allows the information processing device 1 to generate an implementation document of the code included in the SDK with high accuracy.

[0349] Moreover, the other implementation documents include implementation documents previously generated by the generating unit 32. This enables the information processing device 1 to reduce variations in the implementation documents of the code included in the SDK.

[0350] The other implementation documents include implementation documents of code different from the code of the software development kit, which allows the information processing device 1 to generate implementation documents of the code included in the SDK with high accuracy.

[0351] In addition, the generation unit 32 causes the language model to generate an implementation document using information further including a code corresponding to another implementation document as input information. This allows the information processing device 1 to accurately generate an implementation document of the code included in the SDK.

[0352] Furthermore, the generating unit 32 causes the language model to generate an implementation document using as input information information further including information indicating an instruction to output information related to the target code. This allows the information processing device 1 to generate an implementation document of the code included in the SDK with high accuracy.

[0353] The target code includes test code and source code included in the software development kit, which allows the information processing device 1 to generate implementation documentation for the code included in the SDK with high accuracy.

[0354] The information about the target code includes at least one of information indicating the function of the target code and information indicating an implementation procedure of the target code. This allows the information processing device 1 to reduce the burden of creating an implementation document for the code included in the SDK.

[0355] The language model is generated by performing transfer learning on a pre-trained language model using learning information including a code different from the code of the software development kit and an implementation document including information about the code. This allows the information processing device 1 to generate an implementation document of the code included in the SDK with high accuracy.

[0356] The above describes the embodiment of the present application in detail based on the drawings, but this is merely an example, and the present invention can be implemented in other forms that include various modifications and improvements based on the knowledge of those skilled in the art, including the forms described in the Disclosure of the Invention section.

[0357] Furthermore, the above-mentioned "section, module, unit" can be read as "means" or "circuit", etc. For example, an acquisition section can be read as an acquisition means or an acquisition circuit. [Explanation of symbols]

[0358] 1. Information processing device 2, 2A, 2B, 2C Terminal equipment 10. Communications Department 11 Storage section 12 Processing section 20 User information storage unit 21 Program related information storage unit 22 Question and answer information storage section 23 Generation history memory unit 30 Acquisition Department 31 Reception 32 Generation part 33 Memory Processing Unit 34 Extraction part 35 Provision Department 40 1st generation part 41 Search Department 42 Second generation part N Network

Claims

1. an acquisition unit that acquires target code, which is code included in the software development kit and is a target code of the implementation document; a generation unit that inputs input information including the target code acquired by the acquisition unit to a language model that generates and outputs information according to the input information, and causes the language model to generate an implementation document including information about the target code.

23. An information processing apparatus comprising:

2. The generation unit is The language model is caused to generate the implementation document using information including an implementation document of another code different from the target code as the input information.

2. The information processing apparatus according to claim 1,

3. The other implementation document may: The implementation document previously generated by the generation unit is included.

3. The information processing apparatus according to claim 2.

4. The other implementation document may: Includes implementation documentation for code that is different from the code in the software development kit 3. The information processing apparatus according to claim 2.

5. The generation unit is The language model is caused to generate the implementation document using information further including a code corresponding to the other implementation document as the input information.

5. The information processing apparatus according to claim 4.

6. The generation unit is and causing the language model to generate the implementation document using as the input information information further including information indicating an instruction to output information regarding the target code.

6. The information processing apparatus according to claim 1, wherein the information processing apparatus is a computer.

7. The subject code comprises: The test code and source code included in the software development kit 6. The information processing apparatus according to claim 1, wherein the information processing apparatus is a computer.

8. The language model is A language model that is generated by performing transfer learning on a pre-trained language model using learning information that includes a code different from the code of the software development kit and an implementation document that includes information about the code.

6. The information processing apparatus according to claim 1, wherein the information processing apparatus is a computer.

9. 1. A computer-implemented information processing method, comprising: obtaining subject code, the subject code being code included in the software development kit and subject to the implementation documentation; A generation process of inputting input information including the target code acquired by the acquisition process to a language model that generates and outputs information according to the input information, and causing the language model to generate an implementation document including information regarding the target code.

23. An information processing method comprising:

10. an acquisition step for acquiring Covered Code, the Covered Code being code contained in the Software Development Kit and covered by the Implementation Documentation; a generation step of inputting input information including the target code acquired by the acquisition step to a language model that generates and outputs information corresponding to the input information, and causing the language model to generate an implementation document including information regarding the target code.

23. An information processing program comprising:

Images