Method for generating application programs using natural language models

Abstract

This invention provides a method for generating application programs using natural language instructions input by developers, enabling application developers to easily develop applications, and a non-volatile recording medium on which the application development program is stored. [Solution] A method for developing an application program to be executed on a computing device, comprising the steps of: inputting natural language instructions from a developer developing the application program via a developer input interface; inputting the input natural language instructions into a predetermined language model; acquiring predetermined output information generated by the language model in response to the input of the natural language instructions; and generating source code or executable code for the application program using the acquired output information.

Description

Technical Field

[0001] The present invention relates to a method for developing computer application software, and particularly to a program for application development using a natural language model so that developers can easily develop computer application software.

Background Art

[0002] Low-code development is a software development approach that helps to quickly develop application programs with minimal manual coding. This approach assists developers in easily creating applications.

[0003] The low-code development method according to the prior art provides the following features. First, it can provide a visual development environment for configuring an application visually through a drag-and-drop interface, without creating complex code, and can configure the screen design and logic flow. Second, it can quickly configure an application by utilizing pre-made reusable components and templates, and such components include database connection, user interface elements, business logic, etc. Third, it can automate and easily set up backend operations such as database linkage, API calls, authentication, and permission management, thereby reducing development time and complexity. Fourth, it can quickly prototype ideas and receive early feedback, which is suitable for the agile development methodology. Fifth, if necessary, user-defined code can be added to expand the basic functions of the low-code platform, can be personalized according to specific requirements, and provides flexibility and scalability.

[0004] Examples of low-code platforms include Siemens' Mendix, OutSystems (a low-code platform for web and mobile application development), Microsoft Power Apps (Microsoft's low-code platform for easily creating business applications), and Appian (a platform combining business process management and low-code development).

[0005] The use of large-scale language models (LLMs) for natural language processing in low-code software development is steadily increasing, greatly contributing to making the development process simpler and more efficient. Typically, LLMs have the following characteristics: Firstly, developers describe application requirements in natural language, and the LLM understands this and automatically generates code or components usable on the low-code platform. For example, if the developer inputs "Create a user login screen," the code related to the login form will be automatically generated. Secondly, LLMs allow for documentation of the code's function and usage in natural language. After creating the code, the developer only needs to add a brief explanation, and the LLM will automatically generate detailed documentation. For example, if a short explanation of a function or module is created, the LLM will generate detailed documentation based on this. Thirdly, if the user asks questions in natural language about things they are curious about during the development process, the LLM will immediately provide answers or suggest relevant code. For example, it will provide specific code examples in response to the question, "How will this be stored in the database when this button is clicked?"

[0006] Examples of low-code software development using large-scale language models (LLMs) for natural language processing are as follows: Firstly, Microsoft Power Apps, as a low-code platform, has recently integrated OpenAI's GPT-3 to support development utilizing natural language processing. When a user describes their requirements in natural language, GPT-3 understands this and suggests appropriate Power Apps components and logic. For example, if a developer enters "I want to create an app that queries customer data," GPT-3 understands this and automatically generates a form linked to the customer database. Also, if a specific task is described, for example, "Add a button to update the order status," GPT-3 analyzes this and adds a button with the corresponding function to the app. Secondly, UiPath provides an RPA (Robotic Process Automation) solution as a low-code / no-code automation platform. UiPath integrates LLMs like GPT-3 to generate automated workflows through natural language processing. For example, if a developer inputs a natural language command such as "Check emails every morning and categorize important emails," GPT-3 analyzes this and generates a workflow that UiPath's automation robots perform. Based on requirements created in natural language, automation scripts are generated to automate business processes. Thirdly, Salesforce Einstein, as the AI ​​platform for Salesforce-6, provides various AI capabilities. GPT-3 is integrated into this to support the development of natural language-based low-code applications. For example, if a developer inputs "Create a new lead generation format," GPT-3 analyzes this and automatically generates the necessary format in the Salesforce environment. If a customer support scenario is described in natural language, GPT-3 generates the necessary data model and UI based on this. On the other hand, the specific core configurations in each of the above examples, where each platform processes the input natural language to support application development, have not been disclosed. [Overview of the project] [Problems that the invention aims to solve]

[0007] The objective of the present invention is to provide an application development program that generates applications using natural language instructions input by the developer, so that application developers can easily develop applications. [Means for solving the problem]

[0008] One embodiment of the present invention provides a method for generating an application program, comprising the steps of: a computing device inputting natural language instructions from a developer developing an application program via a developer input interface; the computing device inputting the input natural language instructions into a predetermined language model (LM); the computing device acquiring predetermined output information generated by the language model in response to the input natural language instructions; and the computing device generating source code or executable code for the application program using the acquired output information.

[0009] The output information includes a model object (F) configured to generate a table containing information about user input components for the user of the application program to input data filtering conditions; a model object (O) configured to generate a table containing data required by the user; a view template object (F) used to generate a condition input window containing the user input components; a view template object (O) used to output the data required by the user to the screen in a predetermined representation format; and an action object configured to output the filtered data, prepared by filtering the data required by the user according to the data filtering conditions, to the screen in the predetermined representation format.

[0010] The language model is supervised learning, and the supervised learning method includes the steps of preparing a plurality of training natural language sentences to input into the language model, preparing a label for each of the prepared training natural language sentences, and supervising learning the language model using the prepared training natural language sentences and the plurality of labels prepared in correspondence with the prepared training natural language sentences.

[0011] The output information includes a model object (F) configured to generate a table containing information about a user input component for the user of the application program to input data filtering conditions, a model object (O) configured to generate a table containing data required by the user, a view template object (F) used to generate a condition input window containing the user input component, a view template object (O) used to output the data required by the user to the screen in a predetermined representation format, and an action object configured to output the filtered data, prepared by filtering the data required by the user with the data filtering conditions, to the screen in the predetermined representation format. Here, each of the labels is one word from among a plurality of pre-prepared words indicating the model object (F), one word from among a plurality of pre-prepared words indicating the model object (O), one word from among a plurality of pre-prepared words indicating the view template object (F), It consists of a combination of one word that represents one of the pre-prepared view template objects (O) and one word that represents one of the pre-prepared action objects.

[0012] In another aspect of the present invention, a non-volatile recording medium is provided on which an application development program is recorded for causing a computing device to generate an application program. The application development program includes a command that causes the computing device to perform the following steps: input natural language instructions from a developer developing an application program via a developer input interface; input the input natural language instructions into a predetermined language model; acquire predetermined output information generated by the language model in response to the input natural language instructions; and generate executable code for the application program using the acquired output information.

[0013] The output information includes a model object (F) configured to generate a table containing information about user input components for the user of the application program to input data filtering conditions; a model object (O) configured to generate a table containing data required by the user; a view template object (F) used to generate a condition input window containing the user input components; a view template object (O) used to output the data required by the user to the screen in a predetermined representation format; and an action object configured to output the filtered data, prepared by filtering the data required by the user according to the data filtering conditions, to the screen in the predetermined representation format.

[0014] The language model is supervised learning, and the supervised learning method includes the steps of preparing a plurality of training natural language sentences to input into the language model, preparing a label for each of the prepared training natural language sentences, and supervising learning the language model using the prepared training natural language sentences and the plurality of labels prepared in correspondence with the prepared training natural language sentences.

[0015] The output information includes a model object (F) configured to generate a table containing information about a user input component for the user of the application program to input data filtering conditions, a model object (O) configured to generate a table containing data required by the user, a view template object (F) used to generate a condition input window containing the user input component, a view template object (O) used to output the data required by the user to the screen in a predetermined representation format, and an action object configured to output the filtered data, prepared by filtering the data required by the user with the data filtering conditions, to the screen in the predetermined representation format. Here, each of the labels is composed of a combination of one word from among a plurality of pre-prepared words indicating the model object (F), one word from among a plurality of pre-prepared words indicating the model object (O), one word from among a plurality of pre-prepared words indicating the view template object (F), one word from among a plurality of pre-prepared words indicating the view template object (O), and one word from among a plurality of pre-prepared words indicating the action object. [Effects of the Invention]

[0016] According to the present invention, it is possible to provide an application development program that generates applications using natural language instructions input by the developer, so that application developers can easily develop applications. [Brief explanation of the drawing]

[0017] [Figure 1] Figure 1 illustrates the concept of an application program developed by a developer and provided to a user, according to one embodiment of the present invention. [Figure 2] Figure 2 is a sequence diagram illustrating a method for developing an application program to run on a computing device, as provided by one embodiment of the present invention. [Figure 3] Figure 3A shows an example of a table prepared by a model object (F) provided by one embodiment of the present invention, and Figure 3B shows another example of the model object (F) provided by one embodiment of the present invention being represented in table form. [Figure 4] Figure 4A shows the process by which a new table is prepared from a pre-prepared group of tables using a pre-prepared model object (O) according to one embodiment of the present invention; Figure 4B shows the process by which a new table is prepared from a pre-prepared group of tables using a pre-prepared model object (F) according to one embodiment of the present invention; and Figure 4C shows the concept of how the tables generated by the pre-prepared model object (O) and model object (F), respectively, according to one embodiment of the present invention are used to generate the condition input window and output window in Figure 1. [Figure 5] Figure 5 shows yet another example of the application program in Figure 1. [Figure 6] Figure 6 shows examples of multiple representation methods. [Figure 7]FIG. 7 is a diagram showing various forms of design templates of a visualization format associated with a view template object (O) selected by an LM provided according to an embodiment of the present invention. [Figure 8] FIG. 8 is a sequence diagram showing a language model learning method provided according to an embodiment of the present invention. [Figure 9] FIG. 9 is a diagram showing two different model objects (F) that an LM can output. [Figure 10] FIGS. 10A and 10B are diagrams showing examples of screens output by an application program generated by the processing engine using the output information. [Figure 11] FIG. 11 is a diagram showing an example of a screen output by an application program generated by a processing engine provided according to an embodiment of the present invention using the output information. [Figure 12] FIG. 12 is a diagram showing the configuration of an application development program provided according to an embodiment of the present invention in functional blocks.

MODE FOR CARRYING OUT THE INVENTION

[0018] Hereinafter, embodiments of the present invention will be described with reference to the accompanying drawings. However, the present invention is not limited to the embodiments described in this specification and can be embodied in various other forms. The terms used in this specification are for assisting in the understanding of the embodiments and are not intended to limit the scope of the present invention. Also, the singular forms used hereinafter include the plural forms as well, unless the context clearly indicates the contrary meaning.

[0019] FIG. 1 is a diagram explaining the concept of an application program developed by a developer and provided to a user according to an embodiment of the present invention.

[0020] When the user executes the application program on the user terminal used by the user, a window 100 is displayed on the screen of the user terminal.

[0021] Window 100 includes a filtering condition input window 200 and an output window 300.

[0022] The filtering condition input window 200 is provided with a user input interface (user input component) 210 for the user to input predetermined data filtering conditions. The user input component 210 follows the representation method of one of the view templates provided in advance for various user inputs, as described later.

[0023] When a user enters the data filtering conditions into the user input component 210 and selects the trigger button 211, a predetermined action described later is executed, and user output information 310 for the user is displayed in the output window 300.

[0024] The information displayed in window 100 is generated by the execution results of a predetermined processing engine based on the output information output by LM, which will be described later.

[0025] The user output information 310 displayed in the output window 300 follows the representation method of one of the various view templates prepared for data output.

[0026] The present invention relates to an application development program that helps developers easily and quickly develop an application program including window 100 in Figure 1.

[0027] Figure 2 is a sequence diagram illustrating a method for developing an application program to run on a computing device, as provided by one embodiment of the present invention.

[0028] The method for developing the aforementioned application program is executed by the aforementioned application development program.

[0029] In step S100, the developer developing the application program inputs natural language commands using the user input interface (developer input interface) of the computing device.

[0030] In step S110, the input natural language instruction is input to the LM (language model) executed on the computing device.

[0031] In step S120, the LM generates output information corresponding to the natural language instruction input.

[0032] In step S130, a predetermined processing engine executed by the computing device generates the execution code of the application program based on the output information generated by the LM.

[0033] The aforementioned processing engine is a type of predefined program.

[0034] The method shown in Figure 2 will be explained in more detail below, along with other diagrams.

[0035] In step S100 of Figure 2, the natural language instruction is a text input.

[0036] In step S100 of Figure 2, the user input interface is, for example, a mouse, keyboard, or microphone. The natural language command is provided to the computing device either by inputting text using a keyboard, or by providing voice input and inputting text in the STT (Speak-to-Talk) method. In this specification, the user input interface used by the developer is also referred to as the developer input interface.

[0037] In step S110 of Figure 2, the LM was learned by the LM learning method described later.

[0038] The LM is a functional module provided by a third party, which is fine-tuned according to the present invention. In one preferred embodiment, the LM is a functional module provided by a third party that has been fine-tuned.

[0039] The aforementioned LM is configured to select one or more pre-prepared model objects (F), one or more pre-prepared model objects (O), one or more pre-prepared view template objects, and one or more pre-prepared action objects.

[0040] In other words, the LM outputs the identifier (ID) of the model object (F) it selected, the identifier of the model object (O), the identifier of the view template object, and the identifier of the action object.

[0041] In a preferred embodiment, the model object (F), model object (O), view template object, and action object selected by the LM are related to each other by the processing engine.

[0042] <Model Object> The model object (O) and model object (F) provided by the present invention are sets of instruction codes that generate tables used to manage information displayed on the screen of a user terminal by the application program. The data generated by the model object can also be represented in table form. For the sake of explanation, in this specification, the data generated by the model object will be represented in table form.

[0043] According to the present invention, a plurality of model objects (O) and a plurality of model objects (F) are prepared in advance. Model object (F) is a model object used to receive user input from the user of the application program. Model object (O) is a model object used to prepare a data table to be processed and output to the user of the application program in a specific design form.

[0044] Figure 3A shows an example of a table prepared by a model object (F) provided by one embodiment of the present invention.

[0045] Figure 3B shows another example of a model object (F) provided by one embodiment of the present invention being represented in a table format.

[0046] The aforementioned model object (F) is represented as a table consisting of multiple records and multiple fields.

[0047] In one preferred embodiment, the model object (F) includes a label field and a fieldtype field.

[0048] Here, the content of the label field of the first record among the model object (F) is displayed in the filtering condition input window 200 in Figure 1. Furthermore, the type of user input interface (user input component) for inputting the filtering conditions of the label field of the first record is determined by the value of the fieldtype field of the first record.

[0049] A specific model object (F) is predefined by the developer or others as needed, but the contents of the specific model object (F) are not changed by the LM. However, the LM selects one model object (F) from among multiple model objects (F) based on the natural language command input to the LM. That is, the LM outputs an ID that identifies the one model object (F) selected from among multiple model objects (F).

[0050] The LM outputs the model object (F) and the model object (O) in response to the natural language instruction. The model object (F) determines the type of user input interface (user input component) of the application program. A detailed explanation of this will be given later.

[0051] Figure 4A shows the process by which a new table is prepared from a pre-prepared group of tables using a pre-prepared model object (O) according to one embodiment of the present invention.

[0052] Figure 4B shows the process by which a new table is prepared from a pre-prepared group of tables using a pre-prepared model object (F) according to one embodiment of the present invention.

[0053] Figure 4C illustrates the concept that tables generated by pre-prepared model objects (O) and (F) according to one embodiment of the present invention are used to generate the condition input window and output window shown in Figure 1.

[0054] The following explanation will be given with reference to Figures 4A to 4C.

[0055] The multiple model objects (O) 1500 in Figure 4A are pre-prepared. The LM outputs an identifier that indicates any one of the multiple model objects (O) 1500. One model object (O) 1500 is configured to generate a new table 1510 by combining multiple pre-prepared tables 500.

[0056] The multiple model objects (F) 2500 in Figure 4B are pre-prepared. The LM outputs an identifier that indicates any one of the multiple model objects (F) 2500. One model object (F) 2500 is configured to generate a new table 2510 by combining multiple pre-prepared tables 500. The table 2510 output by model object (F) 2500 may contain information defining the attributes of the columns included in the table 1510 output by model object (O) 1500.

[0057] For example, the multiple tables 500 include a first table containing name / address / telephone number columns, a second table containing education column, and a third table containing career column. Furthermore, the table 1510 output by model object (O) 1500 is, for example, reconfigured to include the name / address / telephone number / education / career columns. Additionally, the table 2510 output by model object (F) 2500 is a table containing information defining the attributes of the columns representing name / address / telephone number / education / career.

[0058] Among multiple columns, for example, information defining the attributes of a first column includes the name (label) of the first column, the size (datasize) of the first column, and the type (datatype) of the first column. In a preferred embodiment of the present invention, the information defining the attributes of the first column further includes the field type of the first column. The function of the field type is as described above.

[0059] If the LM outputs identifiers indicating the first model object (O) 1500[1] and the first model object (F) 2500[1], then the processing engine provided by one embodiment of the present invention prepares the first table (O) 1510[1] using the first model object (O) 1500[1] and prepares the first table (F) 2510[1] using the first model object (F) 2500[1].

[0060] Furthermore, the processing engine generates an instruction code to output the condition input window 200 shown in Figure 1, using the view template object indicated by the identifier of the view template object output by the LM, the action object indicated by the identifier of the action object output by the LM, and the first table (F)2510[1].

[0061] Furthermore, the processing engine generates an instruction code to output the output window 300 of Figure 1 using the view template object indicated by the identifier of the view template object output by the LM, the action object indicated by the identifier of the action object output by the LM, and the first table (O)1510[1].

[0062] <View template object> In the present invention, the view template object output by the LM includes a view template object (O) and a view template object (F).

[0063] In the present invention, the view template object (O) output by the LM means a set of commands used to process a pre-prepared dataset into a specific design form and output it using the model object (O) output by the LM.

[0064] Furthermore, in the present invention, the view template object (F) output by the LM means a set of commands used to generate a predetermined condition input window using the model object (F) output by the LM.

[0065] Different view template objects are understood to represent different sets of commands, which are JavaScript.

[0066] The dataset managed by the model object (F) selected by the LM is visualized and displayed using one of several visualization formats selected from a range of visualization formats, where the view template object (O) is associated with one of the selected visualization formats.

[0067] In the present invention, different view template objects (O) are associated with different visualization formats. For example, the view template object (O) is a design template that represents the dataset managed by the model object (F) in a two-dimensional circular chart, a three-dimensional circular chart, a vertical bar chart, or a grid shape consisting of R rows and C columns. However, the present invention is not limited thereto.

[0068] Here, the visualization associated with the view template object (O) is an abstract concept in itself and lacks concreteness. However, when data from a table generated by a specific model object (O) is applied to the visualization associated with the view template object (O), the visualization is visualized and displayed in a meaningful pattern.

[0069] Therefore, in order for the visualization associated with the view template object (O) to be generated in a way that expresses valid meaning on the display screen, the visualization associated with the view template object (O) must be materialized by data from a table generated by a model object (O). In the present invention, the model object (O) is selected by the LM.

[0070] In other words, the visualization format associated with the view template object (O) is understood as a design template for processing the table dataset generated in the model object (O) selected by the LM and "outputting" it to the user in a specific representational format. That is, the view template object (O) is defined for outputting information to the user.

[0071] Figure 5 shows yet another example of the application program in Figure 1.

[0072] The application program shown in Figure 5 was generated based on the model object (F) in Figure 3B.

[0073] In the example in Figure 1, only one user input component 210 for entering data filtering conditions is shown in the filtering condition input window 200, but in the example in Figure 5, a total of three user input components 210 are shown. In addition, in Figure 5, a label 220 indicating the target of each user input component 210 is displayed as text to the left of each user input component 210.

[0074] In Figure 5, 220[1], 220[2], and 220[3] represent the "reception type," "processing type," and "customer name," respectively, which can also be seen in Figure 3B.

[0075] In Figure 5, the user input interface (user input component) indicated by 210[1] is provided as a SelectOne type combo component that allows the user to select one of several predetermined types indicating "reception type". This is because, in the third row of Figure 3B, the label "reception type" is associated with the field type "SelectOne".

[0076] In Figure 5, the user input interface (user input component) shown by 210[2] is provided as a SelectOne type combo component that allows the user to select one of several predetermined types that indicate the "processing type". This is because, in the fourth row of Figure 3B, the label "processing type" is associated with the fieldtype "SelectOne".

[0077] In Figure 5, the user input interface (user input component) shown by 210[3] is provided as an Edit component of type FreeText, which allows the user to freely enter the "customer name". This is because, in row 6 of Figure 3B, the label "customer name" is associated with the field type "FreeText".

[0078] Thus, the specific value of fieldtype defined in the model object (F) shown in Figure 3B determines the representation method of the user input component 210 for inputting data filtering conditions expressed in the application program (i.e., the view template that shows the user input component 210 for inputting data filtering conditions).

[0079] Multiple representation methods (view templates for user input) are predefined and prepared as representation methods (view templates for user input) for the user input component 210, which is used to input data filtering conditions expressed in the application program.

[0080] Figure 6 shows examples of the multiple representation methods (view templates for user input).

[0081] The user input interface (user input component) in Figure 6 is familiar to technicians in the relevant art, but is shown simply as an example to clarify the meaning of the user input component 210 of the present invention. For example, at the bottom of Figure 6, a user input component called Calendar is shown, and to its left, a user input controller 1924 is shown that triggers the output of the calendar 1925 shown on the right. The calendar 1925 is a user input component that allows the user to select a specific date from a general calendar that shows all the dates of a particular month in one-week intervals.

[0082] If, for example, the fieldtype associated with a certain label shown in Figure 3B is defined as "Calendar," then the calendar-shaped user input component at the bottom of Figure 6 can be provided as the filtering condition input window 200 of the application program as shown in Figure 5.

[0083] In one embodiment of the present invention, the user input component is a button component, radio component, listbox component, checkbox component, combo component, multicombo component, edit component, maskedit component, grid component, textarea component, or calendar component for user input. The user input component as defined by the present invention is not limited to the components described above.

[0084] Figure 7 shows the various forms of design templates that a visualization format associated with a view template object (O) selected by LM, provided by one embodiment of the present invention, has.

[0085] In Figure 5, the user output information 310 is shown in a grid shape, but depending on the view template object (O) selected by LM, the user output information 310 can be output in various representations as shown in Figure 7.

[0086] <Action Object> In this specification, an action object means a set of commands that, based on the model object (O) and view template object (O) selected by the LM, visualize the table data generated by the model object (O) in a visualization format associated with the view template object (O) and output it to the display screen. The set of commands is, for example, JavaScript.

[0087] Here, the action object can output the results of filtering the table dataset generated by the model object (O) according to the data filtering conditions entered by the user input component, in the visualization format on the screen. Therefore, the execution of the action object can be started when the user clicks the trigger button 211 after the data filtering conditions have been entered by the user.

[0088] As mentioned above, the data in the table generated by the model object (O), and the visualization format associated with the view template object (O), are conceptual in themselves, but when combined, they can be perceived more concretely by humans in a meaningful form.

[0089] The processing engine can generate executable code for an application program based on the model object (O), model object (F), view template object (O), view template object (F), and action object selected by the LM.

[0090] <LMのファインチューニング> Here, the LM is a program containing a set of commands that causes the computing device to take the steps of receiving the natural language instruction as input and generating the output information corresponding to the input natural language instruction. Here, the LM is prepared through a process of fine-tuning a predetermined LM.

[0091] The generation of the aforementioned output information means that the LM has generated identifiers indicating the selected model object (O), model object (F), view template object (O), view template object (F), and action object.

[0092] A method for developing an application program for a computing device according to one embodiment of the present invention includes step S130, in which the processing engine generates executable code for the application program based on the output information generated by the LM. When a user executes the executable code for the application program, the application program is executed.

[0093] <Execution of application development program> The method for developing the aforementioned application program involves executing an application development program that includes commands to perform each of the aforementioned steps S100, S110, S120, and S130.

[0094] When the computing device executes the application development program, the computing device can perform steps S100, S110, S120, and S130 to generate the execution code for the application, i.e., the application program.

[0095] It must be understood here that the application development program and the application program are different from each other. The application program is generated as a result of executing the application development program.

[0096] In one embodiment, the person executing the application development program is the developer (low-code developer), and the person executing the application program may be another user, not the developer.

[0097] <Execute application program> As described above, the output information includes identifiers indicating the model object (O), model object (F), view template object (O), view template object (F), and action object selected by the LM.

[0098] When the execution code of the application program (application program) is executed, the window 100 shown in Figures 1 and 5 is displayed. When the user enters data filtering conditions into one or more of the set of user input components and clicks the trigger button 211, the action object is executed. When the action object is executed, the information filtered by the data filtering conditions from the table data generated by the model object (O) is displayed on the screen in the representation format shown by the view template object (O). In other words, even when the execution code of the application (application program) is executed, the action object is not executed immediately, but rather when the trigger button 211 is clicked.

[0099] <LMのファインチューニング> The LM in step S110 of Figure 2 is a fine-tuned version of an LM provided by a third party. The fine-tuning process includes an LM learning method for supervised learning of the LM according to one aspect of the present invention. The LM learning method includes the following steps, as described in Figure 8.

[0100] Figure 8 is a sequence diagram illustrating a language model learning method provided by one embodiment of the present invention.

[0101] The LM learning method includes step S210 of preparing multiple training natural language sentences to be input to the LM.

[0102] In a preferred embodiment, each of the natural language sentences is prepared in a form that includes words and / or phrases corresponding to the model object (O), model object (F), view template object (O), view template object (F), and action object. The part of speech of the words may be, but is not limited to, nouns or verbs.

[0103] The words and / or phrases corresponding to the model object (O), model object (F), view template object (O), view template object (F), and action object, respectively, mean or imply the respective, or related words and / or phrases. This includes cases where, even if the corresponding words and / or phrases are not explicitly stated in the natural language text, the context of the natural language text makes it possible to infer the existence of the corresponding words and / or phrases.

[0104] The aforementioned model object (F) is selected from among multiple mutually distinct model objects (F).

[0105] The aforementioned model object (O) is selected from among a plurality of mutually distinct model objects (O).

[0106] The aforementioned view template object (F) is selected from among several mutually distinct design templates.

[0107] The aforementioned view template object (O) is selected from among several mutually distinct design templates.

[0108] The aforementioned action object is selected from among several mutually distinct action objects.

[0109] The prepared plurality of natural language sentences include all possible combinations of words and / or phrases that embody the model object (O), model object (F), view template object (O), view template object (F), and action object. Furthermore, given a first set of words and / or phrases that represent the selected first model object (O), first model object (F), first view template object (O), first view template object (F), and first action object, there are various ways in which these can be constructed into a single sentence, so there are multiple natural language sentences that can be constructed from the first set of words and / or phrases.

[0110] For example, if a request such as "Create as many natural language sentences as possible that can be composed of the first set of words and / or phrases!" is input to a conventional generative LLM model, the LLM model can provide multiple natural language sentences that can be composed of the first set of words. Performing this process for all possible combinations of words representing the multiple mutually distinct model objects, the multiple mutually distinct view template objects, and the multiple mutually distinct action objects will prepare a large number of natural language sentences.

[0111] The LM learning method includes step S220 of preparing labels for each of the prepared plurality of training natural language sentences.

[0112] Each of the prepared natural language sentences is used as input data for training the LM. When the fine-tuned LM to be prepared according to one aspect of the present invention receives each of the training natural language sentences as input to the LM, the LM will use, among a plurality of pre-prepared model objects (F), the model object (F) (or a word and / or phrase indicating a model object (F)) included in the input training natural language sentence, among a plurality of pre-prepared model objects (O), the LM will use, among a plurality of pre-prepared model objects (O), the model object (O) (or a word and / or phrase indicating a model object (O)) included in the input training natural language sentence, and among a plurality of pre-prepared view template objects (F), the LM will use as input It is desirable that the LM outputs a view template object (F) (or a word and / or phrase indicating a view template object (F)) contained in the natural language text for training, a view template object (O) (or a word and / or phrase indicating a view template object (O)) from among a plurality of pre-prepared view template objects (O) contained in the input natural language text for training, and an action object (or a word and / or phrase indicating an action object) from among a plurality of pre-prepared action objects contained in the input natural language text for training.

[0113] For this purpose, the LM can be supervised. Here, the supervised learning label for a specific training natural language text input to the LM consists of a word indicating a model object (F) that is evaluated as being indicated by the input training natural language text, a word indicating a model object (O) that is evaluated as being indicated by the input training natural language text, a word indicating a view template object (F) contained in the input training natural language text, a word indicating a view template object (O) contained in the input training natural language text, and a word indicating an action object contained in the input training natural language text.

[0114] The LM learning method includes step S230 of supervising the learning model using the prepared training natural language sentences and the corresponding prepared labels. [Examples]

[0115] <Example 1> To aid in understanding the present invention, the following provides specific examples of natural language instructions that developers input into an application development program to develop an application program, output information output by a learning module (LM) trained to process the natural language instructions, and an example of a screen output by an application program generated by a predetermined processing engine using the output information.

[0116] For example, the developer runs the application development program and inputs the natural language command "Create an application program that filters production items and inquiry periods and outputs the production volume of said production items in a bar chart by period!" into the application development program.

[0117] The fine-tuned LM used by the application development program then outputs information that identifies (1) a model object (F) used to generate a user input controller that can filter production items and inquiry periods, (2) a model object (O) used to manage a dataset relating to the production volume of production items, (3) a view template object (F) used to select the design format of the user input controller, (4) a view template object (O) used to output the dataset as a bar chart, and (5) an action object used to output the model object (O), the model object (F), the view template object (O), and the view template object (F) in relation to each other.

[0118] For example, the information output by the LM may have the following format: [xModel(F): "xMF[Production DB]", xModel(O): "xMO[Production DB]", Template(F): "Calendar and Combo Button", Template(O): "Bar Chart", Action: "Query"]. This is merely an example to help understand the present invention, and the invention is not limited thereto. Here, xModel(F) represents a model object (F), xModel(O) represents a model object (O), Template(F) represents a view template object (F), Template(O) represents a view template object (O), and Action represents an action object.

[0119] As an example to illustrate this point, suppose a developer executes the aforementioned application development program and inputs the natural language command, "Create an application program that filters discarded items and inquiry periods, and outputs the amount of discarded items in a bar chart by period!" into the application development program. In this case, the information output by the LM is preferably [xModel(F): "xMF[Discarded DB]", xModel(O): "xMO[Discarded DB]", Template(F): "Current and Combo Buttons", Template(O): "Bar Chart", Action: "Inquiry"].

[0120] To aid in understanding the present invention, the application programs illustrated herein are for performing a "data query" function. Therefore, the Actions presented are examples of "query" actions. However, the application programs may also perform functions other than "data querying." Therefore, the Actions for each application program may also be actions other than "querying." For example, depending on the purpose of the application program, the Actions may be defined and prepared in various ways, such as "message popup," "data copy," "AI data analysis request," "Excel import," and "Excel export."

[0121] Figure 9 shows two distinct model objects (F) that LM can output.

[0122] The upper part of Figure 9 shows xModel(F)=xMF[production DB], and the lower part of Figure 9 shows xModel(F)=xMF[waste DB].

[0123] Figures 10A and 10B show examples of screens output by an application program generated by the processing engine using the output information.

[0124] When the aforementioned application program is executed, a screen like that shown in Figure 10A is output.

[0125] Since the natural language command entered by the aforementioned developer is "Create an application program that filters production items and inquiry periods and outputs the production volume of said production items in a bar chart by period!", the filtering condition input window 200 presents user input components 210[1], 210[2], and 210[3] that filter the inquiry start date 220[1], inquiry end date 220[2], and production item 220[3], which are labels contained in the model object (F) (xModel(F)=xMF[Production DB]).

[0126] Figure 10B shows that when the user of the application program enters the data filtering conditions and then clicks the trigger button 211, the Action: "Query" is executed and the user output information 310 is displayed as a concrete design.

[0127] In contrast, if the natural language command entered by the developer were "Create an application program that filters the inquiry period and outputs the production volume as a bar chart by period!", the filtering condition input window 200 would not output the user input component 210[3] and the label 220[3], and the user output information 310 would display all types of production items together.

[0128] <Manifestation 2> To aid in understanding the present invention, the following provides specific examples of natural language instructions that developers input into an application development program to develop an application program, output information output by a learning module (LM) trained to process the natural language instructions, and other examples of screens output by an application program generated by a predetermined processing engine using the output information.

[0129] For example, a developer can run the application development program and input a natural language command into it: "Create an application program that filters all conditions and outputs the production volume of the production items in a bar chart over a period of time!" Here, the information output by the LM is, as described above, [xModel(F): "xMF[production DB]", xModel(O): "xMO[production DB]", Template(F): "calendar and combo buttons", Template(O): "bar chart", Action: "query"].

[0130] Figure 11 shows an example of a screen output by an application program generated using the output information by a processing engine provided according to one embodiment of the present invention.

[0131] The processing engine can display user input components for filtering all labels that can be filtered by the model object (F) (xMF[production DB]) in the filtering condition input window 200 in Figure 11.

[0132] After the developer has reviewed the filtering condition input window 200 in Figure 11 and is satisfied with it, they can distribute the application program generated by the processing engine to the user.

[0133] In contrast, if the developer is not satisfied with the filtering condition input window 200 in Figure 11, they can modify the natural language input again and redevelop the application program. For example, if it is determined that data filtering using "daily production volume" 220[4] and "production date" 220[5], two of the five user input components in Figure 11, is unnecessary, the developer can input the natural language command "Create an application program that filters all conditions except daily production volume and production date, and outputs the production volume of the production items in a bar chart by period!" into the application development program and redevelop the application program. In this way, the application development program provided by the present invention can generate an application program that outputs the screen shown in Figure 10A.

[0134] Figure 12 is a diagram showing the structure of an application development program provided by one embodiment of the present invention, in terms of functional blocks.

[0135] Program developers can input natural language instructions into computing devices.

[0136] The aforementioned natural language instructions are provided to a finely tuned LM (Language Model) 10.

[0137] LM(10) is an application executed on the computing device or another computing device, and consists of a first set of instruction codes.

[0138] LM10 can select one or more model objects (O), model objects (F), view template objects (O), view template objects (F), and action objects in response to the aforementioned natural language instructions. Although window 100 in Figure 1 shows only one condition input window and only one output window, a program developer can develop an application program that includes multiple windows 100, and LM10 is fine-tuned to output output information for multiple condition input windows and / or multiple output windows. With this in mind, Figure 12 shows that LM10 outputs a set consisting of the IDs of one or more model objects (O), a set consisting of the IDs of one or more model objects (F), a set consisting of the IDs of one or more view template objects (O), a set consisting of the IDs of one or more view template objects (F), and a set consisting of the IDs of one or more action objects in response to the aforementioned natural language instructions.

[0139] The processing engine 20 is an application executed on the computing device or another computing device, and consists of a second set of instruction codes. Based on the output information of the LM10, the processing engine 20 can generate and output the source code or executable code of the application program.

[0140] The aforementioned LM is sLLM (Small Language Model).

[0141] Large Language Models (LLMs) and Small Language Models (sLLMs) differ in terms of scale and application. These differences relate to model size, performance, use cases, distribution, and maintenance. The following outlines the main differences between LLMs and sLLMs.

[0142] LLMs are large-scale language models (LLMs) with billions to hundreds of billions of parameters. For example, GPT-3 has 175 billion parameters. The larger the size, the more data and computing resources are required. LLMs offer higher levels of performance and accuracy through their large number of parameters, demonstrating superior performance in complex language understanding and generation tasks and excelling in generalization capabilities across various domains. LLMs are used in a variety of tasks that demand high performance, such as complex question answering systems, conversational AI, text generation, and language translation. For example, they are used in customer service chatbots, automated writing tools, and research and analysis tools. Because LLMs require more computing resources and storage space, and have higher distribution and operating costs, they are often distributed through cloud-based services or large-scale infrastructure. LLMs require large amounts of data and long training times, demanding large computing resources during the training process, and model tuning and fine-tuning are complex and time-consuming. One example of an LLM is GPT-3, a large-scale language model that shows very high performance in general-purpose text generation and understanding tasks.

[0143] sLLM is a small language model with, for example, 7 billion to 70 billion parameters. Its small size allows for training and inference with less data and computational resources. While sLLM is less powerful than LLM, it is still very useful for specific tasks and domains. sLLM can perform general language understanding and generation tasks, but may have limitations in complex tasks. When tuned for a specific purpose, sLLM can provide efficient and fast responses. sLLM is used for relatively simple tasks or tasks specialized for specific domains. For example, it can be used for simple FAQ chatbots, text classification in specific domains, and individual recognition. sLLM requires relatively little computational resources and storage space, resulting in low distribution and operational costs, making it highly flexible and executable in on-premise environments and on edge devices. sLLM can create effective models with relatively small amounts of data and short training times, and model tuning and fine-tuning are easier and faster. TM Llama-2 released on [platform name] TM The model is a typical sLLM model, with a parameter size of 7 billion to 70 billion. Furthermore, Upstage, which is based on Llama-2 and has been customized and released specifically for the Korean language, is also available. TM Solar TM The model has 10.7 billion parameters.

[0144] Thus, LLM and sLLM can be selected and used according to their respective characteristics and applications. The LM used in this invention is an sLLM, which has the advantage of being able to be used efficiently even in lightweight environments.

[0145] Generally, a supervised learning method for fine-tuning a small language model (sLLM) involves the following steps. This process adjusts a pre-trained model to suit a specific task in order to obtain better performance. The LM learning method for supervising the LM in this invention follows such a general supervised learning method for sLLMs.

[0146] The method for fine-tuning the aforementioned sLLM using supervised learning includes step S310 of collecting and preprocessing data. A dataset containing the labels necessary for the task is collected. For example, for a text classification task, a dataset containing each text and its corresponding label is prepared. The text data is also normalized and processed to remove unnecessary characters and spaces. The dataset can also be split into a training set and a validation set. Generally, the training set and validation set are divided in an 80:20 ratio, but this ratio can be adjusted depending on the amount of data and the task.

[0147] The method for fine-tuning the aforementioned sLLM using supervised learning includes step S320 of loading a pre-trained model. For example, one can select a pre-trained small language model to be used in places such as the Hugging Face Transformers library. For example, Llama-2 TM Model, or Solar TM You can select a model, and you can also load a pre-trained model that has been selected.

[0148] A method for fine-tuning the aforementioned sLLM using supervised learning includes a dataset tokenizing step S330 in which text data is converted into tokens using a tokenizer for input into the model.

[0149] The method for fine-tuning the aforementioned sLLM using supervised learning includes a model fine-tuning step S340 in which the parameters necessary for training, such as the optimizer and learning rate, are set, and the model is fine-tuned using the training data.

[0150] The method for fine-tuning the aforementioned sLLM using supervised learning includes a model evaluation and validation step S350 in which the performance of the model is evaluated using validation data.

[0151] The present invention provides a method for supervised learning of the LM, which includes the step of fine-tuning the sLLM using supervised learning.

[0152] In embodiments intended to aid in understanding the present invention, the concept of a "view template object (O)" is presented. A "view template object (O)" is an output to the user, and is a concept that corresponds to cases where a visual output is provided. Even if an auditory output is provided as the output to the user, various forms of "audio template objects (O)" are defined and provided. Therefore, the concept and term "output template" can be defined as a higher-level concept than the "view template" and "audio template" concepts. Thus, the term and concept of "view template" presented herein can be replaced with the term "output template," and it can be understood that the present invention can be extended to this extent.

[0153] Using the embodiments of the present invention described above, persons in the art of the present invention can easily make various changes and modifications without departing from the essential characteristics of the present invention. The content of each claim may be combined with other unreferenced claims to the extent that can be understood through this specification.

Claims

1. The computing device receives natural language instructions from a developer who develops an application program via a developer input interface, The computing device inputs the input natural language command into a predetermined language model (LM), The computing device obtains predetermined output information generated by the language model in response to the input of the natural language instruction. The computing device includes the step of generating source code or executable code for the application program using the acquired output information, The output information is, A model object (O) that generates a table containing data required by the user of the aforementioned application program, A view template object (O) used to output the data required by the user to the screen in a predetermined format, The action object includes an action object that outputs the data required by the user to the screen in the predetermined format, A method for generating an application program, characterized in that the action object is performed when a trigger button provided by the running application program is selected by the user.

2. The aforementioned output information further includes, A model object (F) is configured to generate a table containing information about user input components for the user to input data filtering conditions, A view template object (F) used to generate a condition input window containing the user input component, The method for generating an application program according to claim 1, characterized in that the action object is configured to output the filtered data prepared by filtering the data required by the user according to the data filtering conditions to the screen in the predetermined representation format.

3. The aforementioned language model is supervised and learned. The aforementioned supervised learning method is The computer device prepares multiple training natural language sentences to be input into the language model, The computer device prepares labels for each of the prepared training natural language sentences, A method for generating an application program according to claim 1, characterized in that a computer device performs supervised learning of the language model using a plurality of prepared training natural language sentences and a plurality of labels prepared corresponding to the plurality of prepared training natural language sentences.

4. The output information includes a model object (F) configured to generate a table containing information about user input components for the user of the application program to input data filtering conditions, a model object (O) configured to generate a table containing data required by the user, a view template object (F) used to generate a condition input window containing the user input components, a view template object (O) used to output the data required by the user to the screen in a predetermined representation format, and an action object configured to output the filtered data prepared by filtering the data required by the user according to the data filtering conditions to the screen in the predetermined representation format. Each of the aforementioned labels is, One of the words that represent a plurality of pre-prepared model objects (F), One of the words that represent a plurality of pre-prepared model objects (O), One of the words that represent a plurality of pre-prepared view template objects (F), One of the words that represent a plurality of pre-prepared view template objects (O), The method for generating an application program according to claim 3, characterized in that it is composed of a combination of any one word that represents a plurality of pre-prepared action objects.

5. A non-volatile recording medium on which an application development program is recorded that causes a computing device to generate an application program, The aforementioned application development program is generated by the computing device, The steps include: a developer developing an application program inputting natural language commands via a developer input interface; The computing device inputs the input natural language command into a predetermined language model, The computing device obtains predetermined output information generated by the language model in response to the input of the natural language instruction. The computing device generates the execution code of the application program using the acquired output information, Includes a command to execute, The output information is, A model object (O) that generates a table containing data required by the user of the aforementioned application program, A view template object (O) used to output the data required by the user to the screen in a predetermined format, The action object includes an action object that outputs the data required by the user to the screen in the predetermined format, The action object is a non-volatile recording medium on which an application development program is recorded, characterized in that it is executed when a trigger button provided by the running application program is selected by the user.

6. The aforementioned output information further includes, A model object (F) is configured to generate a table containing information about user input components for the user to input data filtering conditions, It includes a view template object (F) used to generate a condition input window containing the user input component, The non-volatile recording medium on which the application development program according to claim 5 is recorded is characterized in that the action object is configured to output the filtered data prepared by filtering the data required by the user according to the data filtering conditions to the screen in the predetermined representation format.

7. The aforementioned language model is supervised and learned. The aforementioned supervised learning method is The steps include preparing multiple training natural language sentences to be input into the language model, The steps include preparing labels for each of the aforementioned set of training natural language sentences, A non-volatile recording medium on which an application development program according to claim 5 is recorded, comprising the step of supervising the language model using a plurality of prepared training natural language sentences and a plurality of labels prepared corresponding to the plurality of prepared training natural language sentences.

8. The output information includes a model object (F) configured to generate a table containing information about user input components for the user of the application program to input data filtering conditions, a model object (O) configured to generate a table containing data required by the user, a view template object (F) used to generate a condition input window containing the user input components, a view template object (O) used to output the data required by the user to the screen in a predetermined representation format, and an action object configured to output the filtered data prepared by filtering the data required by the user according to the data filtering conditions to the screen in the predetermined representation format. Each of the aforementioned labels is, One of the words that represent a plurality of pre-prepared model objects (F), One of the words that represent a plurality of pre-prepared model objects (O), One of the words that represent a plurality of pre-prepared view template objects (F), One of the words that represent a plurality of pre-prepared view template objects (O), A non-volatile recording medium on which an application development program according to claim 7 is recorded, characterized in that it is composed of a combination of any one word representing a plurality of pre-prepared action objects.

Images