System

Abstract

A system is provided.SOLUTION: A system comprising: means for inputting requirements described in natural language by a user; means for analyzing the natural language to extract requirements; means for identifying required functions based on the extracted requirements; means for generating code of an application based on the identified functions; and means for linking the generated code to an application development platform.SELECTED DRAWING: Figure 1

Description

[Technical Field]

[0001] The technology of the present disclosure relates to a system. [Background technology]

[0002] Patent document 1 discloses a persona chatbot control method performed by at least one processor, the method including the steps of receiving a user utterance, adding the user utterance to a prompt including an instruction sentence related to a description of the chatbot character, encoding the prompt, and inputting the encoded prompt into a language model to generate a chatbot utterance in response to the user utterance. [Prior art documents] [Patent documents]

[0003] [Patent Document 1] Japanese Patent Publication No. 2022-180282 Summary of the Invention [Problem to be solved by the invention]

[0004] In modern companies, the need for developing customized in-house applications is increasing, but the need for programming knowledge poses technical hurdles. Application development and maintenance can be difficult, especially in small and medium-sized enterprises and environments lacking specialized engineers. To solve this problem, a system is needed that allows users to easily create applications based on their own requirements, even without programming knowledge. [Means for solving the problem]

[0005] The present invention solves the above-mentioned problems by providing a system including: means for inputting requirements written in natural language by a user; means for extracting requirements by analyzing the natural language; means for identifying necessary functions based on the extracted requirements; means for generating application code based on the identified functions; and means for linking the generated code to an application development platform. This system eliminates the need for specialized programming knowledge and enables users to develop and deploy applications simply by inputting application requirements in natural language.

[0006] A "user" is a person or organization that utilizes the system to input application requirements in natural language.

[0007] A "natural language" is a language that humans use on a daily basis, and is a general linguistic expression that differs from a specific programming language.

[0008] "Requirements" are detailed descriptions of the functions and specifications that users require from a system.

[0009] "Input means" refers to the interface or device through which the user provides requirements to the system in natural language.

[0010] "Means of analysis" refers to the system's ability to interpret natural language requirements and extract relevant keywords and context.

[0011] "Extraction means" is the process of extracting important requirements and keywords from the analyzed natural language.

[0012] "Means of identification" is a function that clarifies the required functions and services based on the extracted requirements and keywords.

[0013] A "function" refers to an operation or service that can be performed in an application.

[0014] A "means for generating" is a function of the system that automatically generates code for an application based on the specified functionality.

[0015] "Code" is text that describes the instructions and data necessary to run a program.

[0016] "Means of integration" refers to the process of integrating the generated code into an application development platform and making it executable.

[0017] "Application development platform" means a software development environment and a platform for operating and managing developed applications.

[0018] "Deployment" is the process of placing a generated application in an execution environment and making it available for use. [Brief explanation of the drawings]

[0019] [Figure 1] 1 is a conceptual diagram showing an example of the configuration of a data processing system according to a first embodiment. [Figure 2] 1 is a conceptual diagram showing an example of main functions of a data processing device and a smart device according to a first embodiment. [Figure 3] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a second embodiment. [Figure 4] FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and smart glasses according to a second embodiment. [Figure 5] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a third embodiment. [Figure 6] FIG. 11 is a conceptual diagram showing an example of main functions of a data processing device and a headset-type terminal according to a third embodiment. [Figure 7] FIG. 10 is a conceptual diagram showing an example of the configuration of a data processing system according to a fourth embodiment. [Figure 8]FIG. 10 is a conceptual diagram showing an example of main functions of a data processing device and a robot according to a fourth embodiment. [Figure 9] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 10] 1 shows an emotion map onto which multiple emotions are mapped. [Figure 11] FIG. 3 is a sequence diagram showing a processing flow of the data processing system according to the first embodiment. [Figure 12] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 1. [Figure 13] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system according to the second embodiment when an emotion engine is combined. [Figure 14] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 2 when an emotion engine is combined. DETAILED DESCRIPTION OF THE INVENTION

[0020] An example of an embodiment of a system according to the technology of the present disclosure will be described below with reference to the accompanying drawings.

[0021] First, the terms used in the following description will be explained.

[0022] In the following embodiments, a coded processor (hereinafter simply referred to as a "processor") may be a single arithmetic device or a combination of multiple arithmetic devices. Furthermore, a processor may be a single type of arithmetic device or a combination of multiple types of arithmetic devices. Examples of arithmetic devices include a CPU (Central Processing Unit), a GPU (Graphics Processing Unit), a GPGPU (General-Purpose computing on Graphics Processing Units), and an APU (Accelerated Processing Unit).

[0023] In the following embodiments, a coded RAM (Random Access Memory) is a memory in which information is temporarily stored and is used as a working memory by a processor.

[0024] In the following embodiments, the coded storage is one or more non-volatile storage devices that store various programs, various parameters, etc. Examples of non-volatile storage devices include flash memory (SSD (Solid State Drive)), magnetic disks (e.g., hard disks), and magnetic tapes.

[0025] In the following embodiments, a communication I / F (Interface) with a symbol is an interface including a communication processor, an antenna, etc. The communication I / F controls communication between multiple computers. Examples of communication standards applied to the communication I / F include wireless communication standards including 5G (5th Generation Mobile Communication System), Wi-Fi (registered trademark), Bluetooth (registered trademark), etc.

[0026] In the following embodiments, "A and / or B" is synonymous with "at least one of A and B." In other words, "A and / or B" means that it may be only A, only B, or a combination of A and B. Furthermore, in this specification, the same concept as "A and / or B" is also applied when three or more things are expressed connected by "and / or."

[0027] [First embodiment]

[0028] FIG. 1 shows an example of the configuration of a data processing system 10 according to the first embodiment.

[0029] 1, a data processing system 10 includes a data processing device 12 and a smart device 14. An example of the data processing device 12 is a server.

[0030] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0031] The smart device 14 includes a computer 36, a reception device 38, an output device 40, a camera 42, and a communication I / F 44. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The reception device 38, the output device 40, and the camera 42 are also connected to the bus 52.

[0032] The reception device 38 includes a touch panel 38A, a microphone 38B, and the like, and receives user input. The touch panel 38A detects contact with an indicator (for example, a pen or a finger) to receive user input by the touch of the indicator. The microphone 38B detects the user's voice to receive user input by voice. The control unit 46A transmits data indicating the user input received by the touch panel 38A and the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the data indicating the user input.

[0033] The output device 40 includes a display 40A and a speaker 40B, and presents data to the user 20 by outputting the data in a form of expression that the user 20 can perceive (for example, audio and / or text). The display 40A displays visible information such as text and images in accordance with instructions from the processor 46. The speaker 40B outputs audio in accordance with instructions from the processor 46. The camera 42 is a compact digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor.

[0034] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 control the exchange of various information between the processor 46 and the processor 28 via the network 54.

[0035] FIG. 2 shows an example of the main functions of the data processing device 12 and the smart device 14.

[0036] 2, in the data processing device 12, a specific process is performed by the processor 28. A specific processing program 56 is stored in the storage 32. The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific process is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0037] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0038] In the smart device 14, the processor 46 performs the reception output process. The storage 50 stores a reception output program 60. The reception output program 60 is used in conjunction with the specific processing program 56 by the data processing system 10. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0039] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0040] The system of the present invention analyzes application requirements entered by users in natural language, automatically generates code based on specific functions, and deploys it on an application development platform, allowing users to create customized in-house applications without requiring programming knowledge.

[0041] Specific explanation of program processing

[0042] 1. Enter your requirements

[0043] User: Enters application requirements in natural language using a web interface or application. For example, a user might enter a requirement like "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0044] 2. Natural Language Analysis

[0045] Server: A Natural Language Processing (NLP) module analyzes the input requirements. This module segments the text, extracts key keywords and context, and understands the requirements.

[0046] For example, the NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[0047] 3. Identifying Requirements

[0048] Server: The requirements analysis module identifies the required features based on the information sent from the NLP module. Based on the extracted requirements, this module determines the feature set required for the application.

[0049] For example, CRUD operations (Create, Read, Update, Delete) and expiration functions are specified.

[0050] 4. Code Generation

[0051] Server: The program generation module generates the code for the application based on the identified functions. For each determined function, this module generates the appropriate code block.

[0052] For example, code is generated for a task add button, a task list view, task edit / delete functions, a deadline setting form, etc.

[0053] 5. Deploying your code

[0054] Server: The Kony platform integration module integrates the generated code into the application development platform and executes the deployment, which makes the application ready for production.

[0055] Specific examples

[0056] Let's say a user types, "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[0057] 1. User: Enters requirements in natural language.

[0058] 2. Server: The NLP module extracts keywords such as "project," "task," "progress," and "deadline."

[0059] 3. Server: The requirements analysis module identifies the required functionality (CRUD operations, progress update functionality, deadline setting).

[0060] 4. Server: The program generation module generates code corresponding to each function.

[0061] 5. Server: Deploys the generated code using the Kony platform integration module and publishes the application.

[0062] This process allows users to automatically create and deploy applications based on requirements entered in natural language.

[0063] The processing flow will be explained below.

[0064] Step 1:

[0065] User: Accesses a web interface and enters application requirements in natural language, for example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0066] Step 2:

[0067] Server: The Natural Language Processing (NLP) module receives the input text and begins analyzing it. It uses word segmentation and grammar analysis to extract key keywords (such as "project," "task," "progress," and "deadline") and understand contextual relationships.

[0068] Step 3:

[0069] Server: The NLP module sends the extracted keywords and context information to the requirements analysis module, which identifies the required features based on the extracted keywords.

[0070] Step 4:

[0071] Server: The requirements analysis module clarifies the identified feature set and plans the overall application structure, including specific features such as CRUD operations (create, read, update, delete) and task progress tracking and deadline setting.

[0072] Step 5:

[0073] Server: The program generation module generates the necessary code based on the information provided by the requirements analysis module. Code generation combines the corresponding code blocks for each function (CRUD operations, progress management, deadline setting).

[0074] Step 6:

[0075] Server: The code generated by the program generation module is sent to the Kony Platform integration module, which uploads the generated code to the appropriate location on the Kony Platform.

[0076] Step 7:

[0077] Server: The Kony platform integration module deploys the application based on the uploaded code and makes it executable, so that the application can be used by real users.

[0078] Step 8:

[0079] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, and set deadlines.

[0080] In this way, the system automatically analyzes requirements entered by the user in natural language, generates code, and deploys the application.

[0081] Example 1

[0082] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0083] Conventional application development requires experts with programming knowledge, making it difficult for users without technical knowledge to create applications on their own. It is also difficult to accurately incorporate and quickly reflect user requirements. For these reasons, there is a demand for application development methods that are efficient in terms of both time and cost.

[0084] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0085] In this invention, the server includes means for inputting requirements written in natural language by a user, means for extracting requirements by analyzing the natural language, means for identifying necessary functions based on the extracted requirements, means for generating application code based on the identified functions, and means for linking the generated code to an application development platform and deploying it. This enables users, even without programming knowledge, to create customized applications based on their specific requirements in a short period of time and have them immediately operational.

[0086] A "user" is an entity that uses the system to input requirements in natural language.

[0087] "Natural language" refers to a language used by humans on a daily basis, and is a language form that does not include program code or special notation.

[0088] "Requirements" are applications functions and characteristics that a user desires from a system, expressed in natural language.

[0089] "Parsing" refers to the process of converting input natural language requirements into a form that the system can understand.

[0090] "Keywords" are key words extracted from natural language requirements and are the basis for a system to understand the requirements.

[0091] "Context" refers to the context or background information in a natural language requirement, used to clarify the meaning of a keyword.

[0092] "Function" refers to the specific operations or behaviors provided by an application, and is specified based on the requirements desired by the user.

[0093] "Code" is a set of instructions written in a programming language that implements the behavior of an application.

[0094] "Application Development Platform" means a software tool or environment for building, managing, and deploying applications based on generated code.

[0095] "Deployment" refers to the process of placing the generated code on an application development platform and making it executable.

[0096] The system of the present invention analyzes application requirements entered by the user in natural language, automatically generates code based on the requirements, and deploys it on an application development platform. This system consists of three main components: the user, the terminal, and the server.

[0097] Hardware and software used

[0098] Hardware: Servers and devices used by users (PCs, smartphones, etc.).

[0099] software:

[0100] Natural Language Processing Module (NLP Module)

[0101] Requirement Analysis Module

[0102] Program Generation Module

[0103] Application development platform linkage module

[0104] Application development platform (e.g., general-purpose application development platform)

[0105] Specific explanation of the process

[0106] Entering requirements

[0107] Using a web interface or application, a user enters their application requirements in natural language, for example, "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0108] Natural Language Analysis

[0109] The server parses the input requirements using a natural language processing (NLP) module. This module understands the requirements by segmenting the text and extracting key keywords and context. For example, the NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[0110] Identifying requirements

[0111] The server uses a requirements analysis module to identify the required functionality based on the information sent by the NLP module, for example, CRUD operations (Create, Read, Update, Delete) and deadline setting functionality.

[0112] Code generation

[0113] The server uses a program generation module to generate application code based on the specified features, such as an add task button, a task list view, task edit and delete functions, a deadline setting form, etc.

[0114] Deploying your code

[0115] The server integrates the generated code into the application development platform using the application development platform integration module and executes deployment, which makes the application ready for actual operation.

[0116] Specific examples

[0117] Here is a concrete example:

[0118] A user types, "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[0119] 1. User: Enters requirements in natural language into a web interface.

[0120] 2. Server: The NLP module extracts keywords such as "project," "task," "progress," and "deadline."

[0121] 3. Server: The requirements analysis module identifies the required functionality (CRUD operations, progress update functionality, deadline setting).

[0122] 4. Server: The program generation module generates code corresponding to each function.

[0123] 5. Server: Deploys the generated code using the application development platform integration module and publishes the application.

[0124] Prompt Sentence Examples

[0125] "I want to build a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0126] "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[0127] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0128] Step 1: Entering requirements

[0129] A user opens a web interface or application and enters the application requirements in natural language.

[0130] Input: A user enters requirements such as "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0131] Output: User requirements become text data that is input into the system.

[0132] Specific behavior: The user enters their requirements into the text field and clicks the "Submit" button.

[0133] Step 2: Parsing natural language

[0134] The server receives the requirements sent from the terminal and activates a natural language processing (NLP) module.

[0135] Input: The text data of the requirement entered by the user.

[0136] Data processing: The NLP module segments the text and extracts key keywords and context.

[0137] Output: Parsed keywords and context information.

[0138] What it does: The NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[0139] Step 3: Identify requirements

[0140] The server uses a requirements analysis module to identify the required functionality based on the information sent from the NLP module.

[0141] Input: Parsed keywords and context information.

[0142] Data calculation: The requirements analysis module maps the keywords to corresponding standard functions (CRUD operations, deadline setting).

[0143] Output: Identification of the required feature set.

[0144] Specific behavior: The requirements analysis module identifies CRUD operations (Create, Read, Update, Delete) and deadline setting functions.

[0145] Step 4: Generate code

[0146] The server uses a program generation module to generate code for the application based on the specified functions.

[0147] Input: The identified feature set.

[0148] Data processing: The program generation module generates the appropriate code block for each function.

[0149] Output: The source code of the application.

[0150] Specific operation: The program generation module creates code for the task addition button, task list view, task edit / delete function, deadline setting form, etc.

[0151] Step 5: Deploy your code

[0152] The server integrates the generated code using the application development platform cooperation module into the application development platform and deploys it.

[0153] Input: The source code of the generated application.

[0154] Data processing: The linking module compiles the code and applies it to the platform.

[0155] Output: A working application.

[0156] What happens: The server uploads the code to the application development platform, applies the configuration, and publishes the application.

[0157] (Application example 1)

[0158] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0159] Task management in conventional logistics centers is often done manually, resulting in a lack of efficiency and accuracy. Furthermore, it is difficult to share task progress in real time and manage deadlines. Therefore, there is a need to provide an effective task management method and improve the operational efficiency of logistics centers.

[0160] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0161] In this invention, the server includes: means for inputting requirements written in natural language by a user; means for analyzing the natural language to extract requirements; means for identifying necessary functions based on the extracted requirements; means for generating application code based on the identified functions; means for linking the generated code to an application development platform; and means for identifying a task management application for managing the operation of a logistics center. This enables logistics staff to add, edit, and delete tasks and track their progress in real time. It also makes it easy to set deadlines for tasks and share progress, significantly improving the operational efficiency of the logistics center.

[0162] A "user" is a person who utilizes the system to input application requirements in natural language.

[0163] A "natural language" is a language that humans use on a daily basis, and is different from a programming language.

[0164] "Requirements" refers to the functions and specifications required for an application that are input by the user in natural language.

[0165] "Parsing" is the process of interpreting requirements entered in natural language and extracting specific keywords and context.

[0166] A "feature" refers to a specific set of operations or behaviors implemented in an application.

[0167] "Code" is a collection of instructions and rules for writing a program that defines the behavior of an application.

[0168] An "application development platform" is the underlying software or environment for executing generated code and running it as an application.

[0169] "Integration" is the process of integrating the generated code into an application development platform and deploying it as a working application.

[0170] A logistics center is a facility that receives, stores, and ships goods, and is a place that requires efficient operational management.

[0171] A "task management application" is software that supports the operation and management of a logistics center, and provides functions such as adding, editing, deleting, and managing progress of tasks.

[0172] This invention is a system that automatically generates a task management application for managing the operation of a logistics center based on requirements entered by a user in natural language.

[0173] The system of the present invention includes the following major components:

[0174] 1. User terminal: Enter application requirements in natural language through a web interface or mobile application.

[0175] 2. Server: Analyzes natural language, identifies required functionality, generates application code, and integrates that code with the application development platform.

[0176] Program operation and description of the hardware and software used

[0177] Natural Language Input and Analysis

[0178] User device: Using a smartphone or computer, the user enters their requirements in natural language.

[0179] Server: Analyzes the text using a natural language processing (NLP) module. This NLP module includes functions to extract key keywords and context. The specific software used is a Python natural language processing library (e.g., NLTK, SpaCy).

[0180] Requirements Identification and Code Generation

[0181] Server: The requirements analysis module identifies the required functions based on the information sent from the NLP module. For example, functions such as database operations (CRUD), progress updates, and deadline settings are identified. Next, the program generation module creates the code based on these identified functions. Specifically, it generates code in Python or JavaScript (registered trademark).

[0182] Deploying your code

[0183] Server: The generated code is integrated into the application development platform and deployed. Here, deployment is performed using Flask (a Python micro web framework) and MongoDB.

[0184] Specific examples

[0185] When inputting requirements for a task management application to support the operation of a logistics center, the following can be entered in natural language: "I want to create an app that can add new inventory check tasks and update their progress. I want the app to set deadlines for tasks and issue alerts when tasks pass their deadlines." Based on this natural language input, the NLP module extracts keywords such as "inventory check," "progress," "deadline," and "alert," and uses these to identify the required functions.

[0186] Prompt Sentence Examples

[0187] "I want to create an app that allows users to add new inventory check tasks and update their progress. I want tasks to have deadlines and be alerted when tasks are past their deadline."

[0188] In this way, the system of the present invention can automatically generate task management applications that significantly improve the operational efficiency of a logistics center.

[0189] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0190] Step 1:

[0191] Users enter requirements in natural language

[0192] Users use their smartphones or computers to input requirements in natural language through a web interface or mobile application, along with prompts such as, "I want to create an app that allows logistics staff to add tasks and update their progress. I want tasks to have deadlines and be alerted when a task is past its deadline."

[0193] Input: Natural Language Requirements

[0194] Output: Natural language text data

[0195] Step 2:

[0196] The server analyzes natural language

[0197] The server uses a natural language processing (NLP) module to parse the requirements entered by the user. It uses a Python natural language processing library (NLTK, SpaCy, etc.) to extract key keywords and context from the text data. For example, keywords such as "task management," "add," "delete," "edit," and "deadline" are extracted.

[0198] Input: Natural language text data

[0199] Output: Extracted keywords and context data

[0200] Step 3:

[0201] The server identifies the required functionality based on the requirements

[0202] The server's requirements analysis module identifies required functionality based on keywords and contextual data obtained from the NLP module, such as database operations (CRUD operations), deadline setting functionality, and progress updates.

[0203] Input: Extracted keywords and context data

[0204] Output: Required feature set

[0205] Step 4:

[0206] The server generates the application code

[0207] The server's program generation module generates application code based on the identified functionality, using Python, JavaScript, or other programming languages ​​to generate code blocks for each functionality (e.g., task addition, edit, delete, progress display, deadline setting form, etc.).

[0208] Input: desired feature set

[0209] Output: Generated application code

[0210] Step 5:

[0211] The server integrates and deploys the generated code to the application development platform.

[0212] The server's deployment module automatically deploys the generated code to an application development platform (e.g., a platform using Flask or MongoDB), and the code is deployed as a working application.

[0213] Input: Generated application code

[0214] Output: Deployed application

[0215] Through this step-by-step process, a system is realized in which a task management application that supports the operation of a logistics center is automatically generated and deployed based on requirements entered by the user in natural language.

[0216] Furthermore, an emotion engine that estimates the user's emotion may be combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59 and perform identification processing using the user's emotion.

[0217] The system of the present invention analyzes application requirements entered by the user in natural language, identifies the necessary functions, generates code, and deploys it in conjunction with an application development platform. Furthermore, it combines an emotion engine that recognizes the user's emotions and adjusts the application's functions and interface based on the user's emotional state, providing a more user-friendly experience.

[0218] Specific explanation of program processing

[0219] 1. Enter your requirements

[0220] Users: Enter their application requirements in natural language through a web interface or application, for example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0221] 2. Natural Language Analysis

[0222] Server: The Natural Language Processing (NLP) module receives and analyzes the input text. This module segments the text and extracts key keywords and context. At the same time, the emotion engine analyzes the text to recognize the user's emotions.

[0223] 3. Emotional Recognition

[0224] Server: The emotion engine analyzes the user's emotional state from natural language input. For example, if the user uses an expression such as "I'm in a hurry," the emotion engine recognizes the emotional state as "urgent."

[0225] 4. Identifying Requirements

[0226] Server: Sends the analysis results of the NLP module and the emotion engine to the requirements analysis module to identify the required features, taking into account the information from the emotion engine to determine the feature set that best suits the user's needs.

[0227] 5. Code Generation

[0228] Server: The program generation module generates the necessary code based on the information provided by the requirements analysis module. This generated code corresponds to specific functions (e.g., CRUD operations, progress management, deadline setting).

[0229] 6. Emotion-Based Regulation

[0230] Server: Based on the information obtained from the emotion engine, the server adjusts the application functions and interface according to the user's emotional state. For example, if the user is in an "urgent" state, the server adjusts the user interface to prioritize important tasks.

[0231] 7. Deploying your code

[0232] Server: The Kony platform integration module integrates the generated code into the application development platform and executes the deployment, making the application ready for production.

[0233] 8. User Usage

[0234] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. Furthermore, the emotion engine provides appropriate feedback and interfaces based on the user's emotional state.

[0235] In this way, the system can provide user-friendly applications by analyzing requirements entered by the user in natural language, combining an emotion engine, generating code, and deploying the application.

[0236] The processing flow will be explained below.

[0237] Step 1:

[0238] User: Accesses a web interface and enters their application requirements in natural language, such as "I want an app that allows employees to share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0239] Step 2:

[0240] Server: The Natural Language Processing (NLP) module receives the user input and starts text analysis, segmenting the text and extracting key keywords (e.g., "project," "task," "progress," "deadline") and contextual relationships.

[0241] Step 3:

[0242] Server: The emotion engine analyzes the user's input text and recognizes the emotional state. For example, if the text contains the expression "hurrying," the emotion engine recognizes the emotional state as "urgent."

[0243] Step 4:

[0244] Server: Sends the analysis results of the NLP module and emotion engine to the requirements analysis module, which identifies the required function set (CRUD operations, progress management, deadline setting) based on the extracted keywords and emotion information.

[0245] Step 5:

[0246] Server: The program generation module generates the corresponding code blocks based on the information sent from the requirements analysis module. For example, it builds the code including the functions to add, edit, and delete tasks and the deadline setting function.

[0247] Step 6:

[0248] Server: Using the emotional information obtained from the emotion engine, the application's functions and interface are adjusted based on the user's emotional state. For example, if the emotional state is "urgent," important tasks are displayed at the top and the user interface is simplified.

[0249] Step 7:

[0250] Server: The Kony platform integration module uploads the generated code to the application development platform and executes the deployment, while simultaneously configuring and building the necessary runtime environment and dependencies.

[0251] Step 8:

[0252] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. Furthermore, they are provided with feedback and an interface that is tailored to their emotional state.

[0253] In this way, the system can automatically analyze, generate code, and deploy the optimal application based on the requirements entered by the user in natural language and their emotional state at the time.

[0254] Example 2

[0255] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0256] Conventional application development systems often suffer from misunderstandings when users communicate their specific requirements to engineers, and are unable to respond quickly. Furthermore, they are unable to adjust the application interface or functionality to take the user's emotional state into account, resulting in a suboptimal user experience. Therefore, there is a need for an application development system that is intuitive, easy to use, and customizable according to the user's emotional state.

[0257] The specification process by the specification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes: means for inputting requirements written in natural language by a user; means for extracting requirements by analyzing the natural language; means for recognizing the user's emotional state from the natural language input; means for identifying required functions based on the extracted requirements and the emotional state; means for generating application code based on the identified functions; means for linking the generated code to an application development platform; and means for adjusting the application functions and interface based on the emotional state. This makes it possible to accurately grasp specific user requirements and quickly develop and deploy applications that can be customized to adapt to the emotional state.

[0258] A "user" is a person or entity that utilizes the system to input application requirements in natural language.

[0259] "Natural language" refers to everyday human language that allows users to interact with systems without requiring specific programming languages ​​or coding skills.

[0260] "Requirements" are natural language descriptions of the functions and objectives that a user requires from an application.

[0261] "Emotional state" refers to the user's psychological and emotional state, and is information parsed from the natural language input by the user.

[0262] A "function" refers to a specific operation or set of operations provided by an application, such as adding a task, updating progress, setting a deadline, and so on.

[0263] "Code" is the set of instructions that make up a computer program, written to perform a particular function.

[0264] An "application development platform" is a platform used for software development and deployment that provides the developed code in a working form.

[0265] "Means" refer to the methods or techniques used to achieve a specific function or purpose.

[0266] "Parsing" is the process of breaking down input natural language requirements and emotional states and extracting meaning and information from them.

[0267] "Extraction" is the process of extracting important information and requirements from input natural language or data.

[0268] "Identification" refers to clarifying the required application functionality based on the extracted information and emotional state.

[0269] "Integration" is the process of integrating the generated code into the application development infrastructure so that the functionality can work.

[0270] "Adjustment" refers to optimizing an application's functionality and interface according to the user's emotional state.

[0271] "Customization" refers to changing the settings and functionality of a system or application according to a user's specific requirements or emotional state.

[0272] The present invention relates to a system that allows a user to input application requirements in natural language, analyzes the input, and generates and deploys application code. Furthermore, the system can recognize the user's emotional state and adjust the application's functionality and interface accordingly. Specific embodiments for implementing the present invention are described below.

[0273] Overview of program processing

[0274] Hardware and Software

[0275] Server: A server for managing and executing the entire process.

[0276] Terminal: A device that runs a web interface or application through which a user can enter requirements and access the application.

[0277] Natural language processing module: Uses the Python nltk library.

[0278] Emotion engine: Uses Microsoft(R) Azure(R) Text Analytics API.

[0279] Program generation module: Uses the Codex API from OpenAI (registered trademark).

[0280] Application development infrastructure: Uses a common CI / CD pipeline.

[0281] User actions

[0282] Requirements input: Users input their requirements in natural language through a web interface or application, for example, "I want an app that allows employees to share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0283] Processing performed by the server

[0284] Natural language analysis: The server uses a natural language processing module to analyze the input text and extract key keywords and context. Specifically, it divides the text into sentences and identifies requirements such as "project," "add task," "update progress," and "set deadline."

[0285] Emotion recognition: The emotion engine running on the server analyzes the user's emotional state from the input text. For example, if the user writes "I'm in a hurry," the emotion engine will recognize this as "urgent" and tag it.

[0286] Requirements Identification and Code Generation: Based on the identified requirements and emotional state, the server uses a program generation module to generate the necessary application code, including an API that enables CRUD operations and a front-end React component.

[0287] Emotion-based adjustment: The server adjusts the application interface and functionality based on the information from the emotion engine. For example, if the state is "urgent," it changes the user interface to highlight important tasks. This is done using React's state management.

[0288] Code deployment: Finally, the server deploys the generated code to the application development platform. Specifically, the code is pushed to a Git repository and automatically deployed to the production environment through a CI / CD pipeline.

[0289] Specific examples

[0290] The user prompts the system with the following:

[0291] I need an app that allows employees to share project progress. I need the ability to add tasks to projects, update progress, and set deadlines. I'm also in a rush, so something that works quickly is helpful.

[0292] In response to this prompt, the system generates, adapts, and deploys the desired application, making it immediately available to the user.

[0293] Although the specific embodiments for carrying out the present invention have been described above, the present invention is not limited to these, and various modifications and improvements can be made thereto.

[0294] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0295] Step 1: Entering requirements

[0296] User: Enters application requirements in natural language through a web interface or application. For example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0297] Input: The user's natural language requirements.

[0298] Output: The input natural language text.

[0299] Step 2: Parsing natural language

[0300] Server: Analyzes the user's input text using the Natural Language Processing (NLP) module. It uses the Python nltk library to split the text into sentences and extract key keywords and context.

[0301] Input: Natural language text entered by the user.

[0302] Output: A list of key keywords and feature requirements (e.g. "project management", "add tasks", "update progress", "set deadlines").

[0303] Step 3: Recognize emotions

[0304] Server: Analyzes the user's emotional state from the text input using the emotion engine. It uses Microsoft Azure's Text Analytics API to generate emotion tags (e.g., "urgency," "expectation," "confusion," etc.).

[0305] Input: Natural language text entered by the user.

[0306] Output: User's emotional state (e.g., "urgent").

[0307] Step 4: Identify requirements

[0308] Server: The requirements analysis module receives the functional requirements list from the NLP module and the emotional state information from the emotion engine, and identifies specific application functions. For example, it determines that functions such as "add task," "update progress," and "set deadline" are required.

[0309] Input: Functional requirements list and emotional state information.

[0310] Output: A list of required application features.

[0311] Step 5: Generate Code

[0312] Server: Uses the program generation module to generate code based on the identified application functionality. Uses OpenAI's Codex API to generate APIs and React components with CRUD operations.

[0313] Input: A list of required application features.

[0314] Output: The generated application code.

[0315] Step 6: Emotional Adjustment

[0316] Server: Based on the information from the emotion engine, the interface and functionality of the generated application are adjusted to match the user's emotional state. For example, in an "urgent" state, the interface and functionality are adjusted to prioritize important tasks.

[0317] Input: Generated application code and emotional state information.

[0318] Output: Application code adapted to the user's emotional state.

[0319] Step 7: Deploy your code

[0320] Server: The generated application code is integrated into the application development platform and deployed. The code is pushed to a Git repository and deployed to the production environment through a CI / CD pipeline.

[0321] Input: Application code adapted to the user's emotional state.

[0322] Output: The deployed application.

[0323] Step 8: User Adoption

[0324] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. The emotion engine also provides appropriate feedback and interfaces.

[0325] Input: Access to deployed applications.

[0326] Output: The application usage and user operation results.

[0327] (Application example 2)

[0328] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart device 14 will be referred to as a "terminal."

[0329] Traditional application development methods require users to define specific requirements and functions in detail and then incorporate them into the code, requiring advanced programming skills. It is also difficult to provide interface adjustments and functions that take into account the user's emotions and urgency. This results in poor usability and makes it difficult for users to quickly obtain applications that meet their needs.

[0330] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[0331] In this invention, the server includes means for inputting requirements written in natural language by the user, means for extracting requirements by analyzing the natural language, and means for identifying necessary functions based on the extracted requirements, thereby enabling automatic generation of an application based on simple requests input in natural language by the user.

[0332] The server further includes means for generating application code based on the identified functions, means for linking the generated code to an application development platform, means for analyzing the user's emotional state, and means for adjusting the application's functions and interface based on the emotional state, thereby enabling the provision of an optimal application taking into account the user's emotions and urgency, thereby improving the user experience.

[0333] "Natural language" refers to the words and expressions people use in their daily lives, rather than technical or code language.

[0334] "Requirements" are the specific conditions and requirements for the functions and performance that users expect from an application.

[0335] "Analysis" is the process of deciphering input data or information and clarifying its meaning and content.

[0336] "Emotional state" refers to the mental state a user is feeling at a particular moment, and may include, for example, happiness, sadness, impatience, etc.

[0337] "Function" refers to a specific operation or capability of an application, and refers to a series of operations that a user desires.

[0338] "Code" is the set of instructions or statements that make up a program, written in a form that a computer can understand and execute.

[0339] "Application Development Platform" means a combination of software and hardware to support the development, deployment, and operation of applications.

[0340] An "interface" is a point of contact or means through which a user and an application interact with each other, and is also called a user interface (UI).

[0341] "Identifying" means clearly identifying an object and defining its properties and characteristics.

[0342] "Collaboration" means that multiple systems and modules work together, sharing information and data to function.

[0343] "Adjust" means to change the settings or behavior of a system or component to suit specific conditions or circumstances.

[0344] The following system configuration is conceivable as an embodiment for carrying out the present invention: The system is composed of a server, a user terminal, and an application development platform.

[0345] The server first provides a means for users to input their requirements written in natural language, for example through a text input field in a web interface or mobile application, which may include prompts such as "I'm in a hurry and want a smartphone that arrives as quickly as possible."

[0346] Next, the server analyzes the input text using a natural language analysis module. At this stage, key keywords and context are extracted. Natural language processing (NLP) technology is used for the analysis. Commonly used NLP libraries such as "TENSORFLOW (registered trademark)" and "spaCy" are used as NLP technology.

[0347] In parallel, the server uses an emotion engine to recognize the user's emotional state. Suitable emotion engines include "Affectiva" and "IBM Watson (registered trademark) Tone Analyzer." For example, the server can recognize the emotional state of "urgent" from the expression "I'm in a hurry."

[0348] Based on the analysis results, the server identifies the required functions through the requirements analysis module. These include task management, progress display, and deadline setting. Based on this information, the program generation module automatically generates code. Generative AI models such as "OpenAI GPT-3 (registered trademark)" and "Codex" are used for code generation.

[0349] The server then adjusts the generated code and interface based on the user's emotional state, dynamically changing the user interface depending on the user's emotional state. For example, in an "emergency" situation, the interface adjusts to bring important information and actions to the forefront.

[0350] Finally, the server deploys the generated code using an application development platform such as Kony, and the actual application is put into production, allowing users to access the developed application and use its various functions.

[0351] Specific examples

[0352] For example, if a user inputs "I'm in a hurry, so I want a smartphone that can be delivered as quickly as possible," the server will analyze this input, recognize the emotional state of "urgency" from the expression "in a hurry," search for smartphones that can be delivered as quickly as possible, and display them as a priority.

[0353] Example prompt sentence:

[0354] "I'm in a hurry, so I want the fastest possible smartphone."

[0355] In this way, the system can easily provide applications that accurately reflect the user's requirements and emotional state.

[0356] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0357] Step 1:

[0358] The user enters requirements written in natural language.

[0359] What it does: A user uses a web interface or a mobile application to enter their desired product and requirements in natural language using a text input field, for example, "I'm in a hurry and want a smartphone that arrives as quickly as possible."

[0360] Input: User's natural language text.

[0361] Output: The requirement text entered.

[0362] Step 2:

[0363] The server analyzes the text using a natural language processing module (NLP).

[0364] How it works: The server uses NLP libraries like TensorFlow and spaCy to analyze the input requirements text and extract key keywords and context. For example, it extracts keywords like "urgent," "fastest," and "smartphone."

[0365] Input: The requirement text entered.

[0366] Output: Extracted keywords and context information.

[0367] Step 3:

[0368] The server uses an emotion engine to recognize the user's emotional state.

[0369] Specific operation: The server uses emotion analysis tools such as "Affectiva" and "IBM Watson Tone Analyzer" to analyze the emotional state of the input text, such as "urgent" or "relaxed." For example, it recognizes the emotional state of "urgent" from the expression "in a hurry."

[0370] Input: The requirement text entered.

[0371] Output: Perceived emotional state (e.g., "urgent").

[0372] Step 4:

[0373] The server uses a requirements analysis module to identify the required functionality.

[0374] Specific operation: Based on the information analyzed by the NLP module and emotion engine, the server's requirements analysis module identifies the functions that meet the user's needs. For example, since the emotional state is urgent, the server selects the function to display products for fastest delivery.

[0375] Input: extracted keywords and recognized emotional states.

[0376] Output: Identified features (e.g., display items with fastest shipping).

[0377] Step 5:

[0378] The server uses a program generation module to generate code for the application based on the identified functionality.

[0379] How it works: The server uses generative AI models such as OpenAI GPT-3 and Codex to automatically generate appropriate code based on the functions identified through requirements analysis. For example, it generates code to display the products that can be delivered the fastest.

[0380] Input: Identified feature information.

[0381] Output: The generated application code.

[0382] Step 6:

[0383] The server adjusts the generated code and interface based on the emotional state.

[0384] Specific behavior: The server adjusts the interface and functions of the generated application according to the recognized emotional state. For example, in an emergency, it adjusts the layout to prioritize important information.

[0385] Input: Generated application code and recognized emotional state.

[0386] Output: Adjusted application code and interfaces.

[0387] Step 7:

[0388] The server ultimately deploys the code to an application development platform.

[0389] What it does: The server uses an application development platform such as Kony to deploy the generated and tailored code and put the application into production.

[0390] Input: The adjusted application code.

[0391] Output: The deployed application.

[0392] Step 8:

[0393] A user accesses the deployed application and utilizes the functionality provided.

[0394] Specific operation: The user accesses the deployed application from a web browser or mobile app and performs operations such as searching and displaying the fastest available smartphone.

[0395] Input: User interaction with deployed application.

[0396] Output: Providing the information or functionality the user requests.

[0397] The specific processing unit 290 transmits the result of the specific processing to the smart device 14. In the smart device 14, the control unit 46A causes the output device 40 to output the result of the specific processing. The microphone 38B acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 38B to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0398] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (registered trademark) (Internet search engine).<URL: https: / / openai.com / blog / chatgpt> ), Gemini (registered trademark) (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0399] In the above embodiment, an example in which the specific process is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific process may be performed by the smart device 14.

[0400] [Second embodiment]

[0401] FIG. 3 shows an example of the configuration of a data processing system 210 according to the second embodiment.

[0402] 3, the data processing system 210 includes the data processing device 12 and smart glasses 214. An example of the data processing device 12 is a server.

[0403] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0404] The smart glasses 214 include a computer 36, a microphone 238, a speaker 240, a camera 42, and a communication I / F 44. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, and the camera 42 are also connected to the bus 52.

[0405] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[0406] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[0407] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0408] Fig. 4 shows an example of the main functions of the data processing device 12 and the smart glasses 214. As shown in Fig. 4, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0409] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0410] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0411] In the smart glasses 214, the reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0412] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the smart glasses 214 will be referred to as the "terminal."

[0413] The system of the present invention analyzes application requirements entered by users in natural language, automatically generates code based on specific functions, and deploys it on an application development platform, allowing users to create customized in-house applications without requiring programming knowledge.

[0414] Specific explanation of program processing

[0415] 1. Enter your requirements

[0416] User: Enters application requirements in natural language using a web interface or application. For example, a user might enter a requirement like "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0417] 2. Natural Language Analysis

[0418] Server: A Natural Language Processing (NLP) module analyzes the input requirements. This module segments the text, extracts key keywords and context, and understands the requirements.

[0419] For example, the NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[0420] 3. Identifying Requirements

[0421] Server: The requirements analysis module identifies the required features based on the information sent from the NLP module. Based on the extracted requirements, this module determines the feature set required for the application.

[0422] For example, CRUD operations (Create, Read, Update, Delete) and expiration functions are specified.

[0423] 4. Code Generation

[0424] Server: The program generation module generates the code for the application based on the identified functions. For each determined function, this module generates the appropriate code block.

[0425] For example, code is generated for a task add button, a task list view, task edit / delete functions, a deadline setting form, etc.

[0426] 5. Deploying your code

[0427] Server: The Kony platform integration module integrates the generated code into the application development platform and executes the deployment, which makes the application ready for production.

[0428] Specific examples

[0429] Let's say a user types, "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[0430] 1. User: Enters requirements in natural language.

[0431] 2. Server: The NLP module extracts keywords such as "project," "task," "progress," and "deadline."

[0432] 3. Server: The requirements analysis module identifies the required functionality (CRUD operations, progress update functionality, deadline setting).

[0433] 4. Server: The program generation module generates code corresponding to each function.

[0434] 5. Server: Deploys the generated code using the Kony platform integration module and publishes the application.

[0435] This process allows users to automatically create and deploy applications based on requirements entered in natural language.

[0436] The processing flow will be explained below.

[0437] Step 1:

[0438] User: Accesses a web interface and enters application requirements in natural language, for example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0439] Step 2:

[0440] Server: The Natural Language Processing (NLP) module receives the input text and begins analyzing it. It uses word segmentation and grammar analysis to extract key keywords (such as "project," "task," "progress," and "deadline") and understand contextual relationships.

[0441] Step 3:

[0442] Server: The NLP module sends the extracted keywords and context information to the requirements analysis module, which identifies the required features based on the extracted keywords.

[0443] Step 4:

[0444] Server: The requirements analysis module clarifies the identified feature set and plans the overall application structure, including specific features such as CRUD operations (create, read, update, delete) and task progress tracking and deadline setting.

[0445] Step 5:

[0446] Server: The program generation module generates the necessary code based on the information provided by the requirements analysis module. Code generation combines the corresponding code blocks for each function (CRUD operations, progress management, deadline setting).

[0447] Step 6:

[0448] Server: The code generated by the program generation module is sent to the Kony Platform integration module, which uploads the generated code to the appropriate location on the Kony Platform.

[0449] Step 7:

[0450] Server: The Kony platform integration module deploys the application based on the uploaded code and makes it executable, so that the application can be used by real users.

[0451] Step 8:

[0452] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, and set deadlines.

[0453] In this way, the system automatically analyzes requirements entered by the user in natural language, generates code, and deploys the application.

[0454] Example 1

[0455] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0456] Conventional application development requires experts with programming knowledge, making it difficult for users without technical knowledge to create applications on their own. It is also difficult to accurately incorporate and quickly reflect user requirements. For these reasons, there is a demand for application development methods that are efficient in terms of both time and cost.

[0457] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0458] In this invention, the server includes means for inputting requirements written in natural language by a user, means for extracting requirements by analyzing the natural language, means for identifying necessary functions based on the extracted requirements, means for generating application code based on the identified functions, and means for linking the generated code to an application development platform and deploying it. This enables users, even without programming knowledge, to create customized applications based on their specific requirements in a short period of time and have them immediately operational.

[0459] A "user" is an entity that uses the system to input requirements in natural language.

[0460] "Natural language" refers to a language used by humans on a daily basis, and is a language form that does not include program code or special notation.

[0461] "Requirements" are applications functions and characteristics that a user desires from a system, expressed in natural language.

[0462] "Parsing" refers to the process of converting input natural language requirements into a form that the system can understand.

[0463] "Keywords" are key words extracted from natural language requirements and are the basis for a system to understand the requirements.

[0464] "Context" refers to the context or background information in a natural language requirement, used to clarify the meaning of a keyword.

[0465] "Function" refers to the specific operations or behaviors provided by an application, and is specified based on the requirements desired by the user.

[0466] "Code" is a set of instructions written in a programming language that implements the behavior of an application.

[0467] "Application Development Platform" means a software tool or environment for building, managing, and deploying applications based on generated code.

[0468] "Deployment" refers to the process of placing the generated code on an application development platform and making it executable.

[0469] The system of the present invention analyzes application requirements entered by the user in natural language, automatically generates code based on the requirements, and deploys it on an application development platform. This system consists of three main components: the user, the terminal, and the server.

[0470] Hardware and software used

[0471] Hardware: Servers and devices used by users (PCs, smartphones, etc.).

[0472] software:

[0473] Natural Language Processing Module (NLP Module)

[0474] Requirement Analysis Module

[0475] Program Generation Module

[0476] Application development platform linkage module

[0477] Application development platform (e.g., general-purpose application development platform)

[0478] Specific explanation of the process

[0479] Entering requirements

[0480] Using a web interface or application, a user enters their application requirements in natural language, for example, "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0481] Natural Language Analysis

[0482] The server parses the input requirements using a natural language processing (NLP) module. This module understands the requirements by segmenting the text and extracting key keywords and context. For example, the NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[0483] Identifying requirements

[0484] The server uses a requirements analysis module to identify the required functionality based on the information sent by the NLP module, for example, CRUD operations (Create, Read, Update, Delete) and deadline setting functionality.

[0485] Code generation

[0486] The server uses a program generation module to generate application code based on the specified features, such as an add task button, a task list view, task edit and delete functions, a deadline setting form, etc.

[0487] Deploying your code

[0488] The server integrates the generated code into the application development platform using the application development platform integration module and executes deployment, which makes the application ready for actual operation.

[0489] Specific examples

[0490] Here is a concrete example:

[0491] A user types, "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[0492] 1. User: Enters requirements in natural language into a web interface.

[0493] 2. Server: The NLP module extracts keywords such as "project," "task," "progress," and "deadline."

[0494] 3. Server: The requirements analysis module identifies the required functionality (CRUD operations, progress update functionality, deadline setting).

[0495] 4. Server: The program generation module generates code corresponding to each function.

[0496] 5. Server: Deploys the generated code using the application development platform integration module and publishes the application.

[0497] Prompt Sentence Examples

[0498] "I want to build a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0499] "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[0500] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0501] Step 1: Entering requirements

[0502] A user opens a web interface or application and enters the application requirements in natural language.

[0503] Input: A user enters requirements such as "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0504] Output: User requirements become text data that is input into the system.

[0505] Specific behavior: The user enters their requirements into the text field and clicks the "Submit" button.

[0506] Step 2: Parsing natural language

[0507] The server receives the requirements sent from the terminal and activates a natural language processing (NLP) module.

[0508] Input: The text data of the requirement entered by the user.

[0509] Data processing: The NLP module segments the text and extracts key keywords and context.

[0510] Output: Parsed keywords and context information.

[0511] What it does: The NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[0512] Step 3: Identify requirements

[0513] The server uses a requirements analysis module to identify the required functionality based on the information sent from the NLP module.

[0514] Input: Parsed keywords and context information.

[0515] Data calculation: The requirements analysis module maps the keywords to corresponding standard functions (CRUD operations, deadline setting).

[0516] Output: Identification of the required feature set.

[0517] Specific behavior: The requirements analysis module identifies CRUD operations (Create, Read, Update, Delete) and deadline setting functions.

[0518] Step 4: Generate code

[0519] The server uses a program generation module to generate code for the application based on the specified functions.

[0520] Input: The identified feature set.

[0521] Data processing: The program generation module generates the appropriate code block for each function.

[0522] Output: The source code of the application.

[0523] Specific operation: The program generation module creates code for the task addition button, task list view, task edit / delete function, deadline setting form, etc.

[0524] Step 5: Deploy your code

[0525] The server integrates the generated code using the application development platform cooperation module into the application development platform and deploys it.

[0526] Input: The source code of the generated application.

[0527] Data processing: The linking module compiles the code and applies it to the platform.

[0528] Output: A working application.

[0529] What happens: The server uploads the code to the application development platform, applies the configuration, and publishes the application.

[0530] (Application example 1)

[0531] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0532] Task management in conventional logistics centers is often done manually, resulting in a lack of efficiency and accuracy. Furthermore, it is difficult to share task progress in real time and manage deadlines. Therefore, there is a need to provide an effective task management method and improve the operational efficiency of logistics centers.

[0533] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0534] In this invention, the server includes: means for inputting requirements written in natural language by a user; means for analyzing the natural language to extract requirements; means for identifying necessary functions based on the extracted requirements; means for generating application code based on the identified functions; means for linking the generated code to an application development platform; and means for identifying a task management application for managing the operation of a logistics center. This enables logistics staff to add, edit, and delete tasks and track their progress in real time. It also makes it easy to set deadlines for tasks and share progress, significantly improving the operational efficiency of the logistics center.

[0535] A "user" is a person who utilizes the system to input application requirements in natural language.

[0536] A "natural language" is a language that humans use on a daily basis, and is different from a programming language.

[0537] "Requirements" refers to the functions and specifications required for an application that are input by the user in natural language.

[0538] "Parsing" is the process of interpreting requirements entered in natural language and extracting specific keywords and context.

[0539] A "feature" refers to a specific set of operations or behaviors implemented in an application.

[0540] "Code" is a collection of instructions and rules for writing a program that defines the behavior of an application.

[0541] An "application development platform" is the underlying software or environment for executing generated code and running it as an application.

[0542] "Integration" is the process of integrating the generated code into an application development platform and deploying it as a working application.

[0543] A logistics center is a facility that receives, stores, and ships goods, and is a place that requires efficient operational management.

[0544] A "task management application" is software that supports the operation and management of a logistics center, and provides functions such as adding, editing, deleting, and managing progress of tasks.

[0545] This invention is a system that automatically generates a task management application for managing the operation of a logistics center based on requirements entered by a user in natural language.

[0546] The system of the present invention includes the following major components:

[0547] 1. User terminal: Enter application requirements in natural language through a web interface or mobile application.

[0548] 2. Server: Analyzes natural language, identifies required functionality, generates application code, and integrates that code with the application development platform.

[0549] Program operation and description of the hardware and software used

[0550] Natural Language Input and Analysis

[0551] User device: Using a smartphone or computer, the user enters their requirements in natural language.

[0552] Server: Analyzes the text using a natural language processing (NLP) module. This NLP module includes functions to extract key keywords and context. The specific software used is a Python natural language processing library (e.g., NLTK, SpaCy).

[0553] Requirements Identification and Code Generation

[0554] Server: The requirements analysis module identifies the required functionality based on the information sent from the NLP module. For example, it identifies functions such as database operations (CRUD), progress updates, and deadline settings. Next, the program generation module creates the code based on these identified functions. Specifically, it generates code in Python or JavaScript.

[0555] Deploying your code

[0556] Server: The generated code is integrated into the application development platform and deployed. Here, deployment is performed using Flask (a Python micro web framework) and MongoDB.

[0557] Specific examples

[0558] When inputting requirements for a task management application to support the operation of a logistics center, the following can be entered in natural language: "I want to create an app that can add new inventory check tasks and update their progress. I want the app to set deadlines for tasks and issue alerts when tasks pass their deadlines." Based on this natural language input, the NLP module extracts keywords such as "inventory check," "progress," "deadline," and "alert," and uses these to identify the required functions.

[0559] Prompt Sentence Examples

[0560] "I want to create an app that allows users to add new inventory check tasks and update their progress. I want tasks to have deadlines and be alerted when tasks are past their deadline."

[0561] In this way, the system of the present invention can automatically generate task management applications that significantly improve the operational efficiency of a logistics center.

[0562] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0563] Step 1:

[0564] Users enter requirements in natural language

[0565] Users use their smartphones or computers to input requirements in natural language through a web interface or mobile application, along with prompts such as, "I want to create an app that allows logistics staff to add tasks and update their progress. I want tasks to have deadlines and be alerted when a task is past its deadline."

[0566] Input: Natural Language Requirements

[0567] Output: Natural language text data

[0568] Step 2:

[0569] The server analyzes natural language

[0570] The server uses a natural language processing (NLP) module to parse the requirements entered by the user. It uses a Python natural language processing library (NLTK, SpaCy, etc.) to extract key keywords and context from the text data. For example, keywords such as "task management," "add," "delete," "edit," and "deadline" are extracted.

[0571] Input: Natural language text data

[0572] Output: Extracted keywords and context data

[0573] Step 3:

[0574] The server identifies the required functionality based on the requirements

[0575] The server's requirements analysis module identifies required functionality based on keywords and contextual data obtained from the NLP module, such as database operations (CRUD operations), deadline setting functionality, and progress updates.

[0576] Input: Extracted keywords and context data

[0577] Output: Required feature set

[0578] Step 4:

[0579] The server generates the application code

[0580] The server's program generation module generates application code based on the identified functionality, using Python, JavaScript, or other programming languages ​​to generate code blocks for each functionality (e.g., task addition, edit, delete, progress display, deadline setting form, etc.).

[0581] Input: desired feature set

[0582] Output: Generated application code

[0583] Step 5:

[0584] The server integrates and deploys the generated code to the application development platform.

[0585] The server's deployment module automatically deploys the generated code to an application development platform (e.g., a platform using Flask or MongoDB), and the code is deployed as a working application.

[0586] Input: Generated application code

[0587] Output: Deployed application

[0588] Through this step-by-step process, a system is realized in which a task management application that supports the operation of a logistics center is automatically generated and deployed based on requirements entered by the user in natural language.

[0589] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0590] The system of the present invention analyzes application requirements entered by the user in natural language, identifies the necessary functions, generates code, and deploys it in conjunction with an application development platform. Furthermore, it combines an emotion engine that recognizes the user's emotions and adjusts the application's functions and interface based on the user's emotional state, providing a more user-friendly experience.

[0591] Specific explanation of program processing

[0592] 1. Enter your requirements

[0593] Users: Enter their application requirements in natural language through a web interface or application, for example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0594] 2. Natural Language Analysis

[0595] Server: The Natural Language Processing (NLP) module receives and analyzes the input text. This module segments the text and extracts key keywords and context. At the same time, the emotion engine analyzes the text to recognize the user's emotions.

[0596] 3. Emotional Recognition

[0597] Server: The emotion engine analyzes the user's emotional state from natural language input. For example, if the user uses an expression such as "I'm in a hurry," the emotion engine recognizes the emotional state as "urgent."

[0598] 4. Identifying Requirements

[0599] Server: Sends the analysis results of the NLP module and the emotion engine to the requirements analysis module to identify the required features, taking into account the information from the emotion engine to determine the feature set that best suits the user's needs.

[0600] 5. Code Generation

[0601] Server: The program generation module generates the necessary code based on the information provided by the requirements analysis module. This generated code corresponds to specific functions (e.g., CRUD operations, progress management, deadline setting).

[0602] 6. Emotion-Based Regulation

[0603] Server: Based on the information obtained from the emotion engine, the server adjusts the application functions and interface according to the user's emotional state. For example, if the user is in an "urgent" state, the server adjusts the user interface to prioritize important tasks.

[0604] 7. Deploying your code

[0605] Server: The Kony platform integration module integrates the generated code into the application development platform and executes the deployment, making the application ready for production.

[0606] 8. User Usage

[0607] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. Furthermore, the emotion engine provides appropriate feedback and interfaces based on the user's emotional state.

[0608] In this way, the system can provide user-friendly applications by analyzing requirements entered by the user in natural language, combining an emotion engine, generating code, and deploying the application.

[0609] The processing flow will be explained below.

[0610] Step 1:

[0611] User: Accesses a web interface and enters their application requirements in natural language, such as "I want an app that allows employees to share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0612] Step 2:

[0613] Server: The Natural Language Processing (NLP) module receives the user input and starts text analysis, segmenting the text and extracting key keywords (e.g., "project," "task," "progress," "deadline") and contextual relationships.

[0614] Step 3:

[0615] Server: The emotion engine analyzes the user's input text and recognizes the emotional state. For example, if the text contains the expression "hurrying," the emotion engine recognizes the emotional state as "urgent."

[0616] Step 4:

[0617] Server: Sends the analysis results of the NLP module and emotion engine to the requirements analysis module, which identifies the required function set (CRUD operations, progress management, deadline setting) based on the extracted keywords and emotion information.

[0618] Step 5:

[0619] Server: The program generation module generates the corresponding code blocks based on the information sent from the requirements analysis module. For example, it builds the code including the functions to add, edit, and delete tasks and the deadline setting function.

[0620] Step 6:

[0621] Server: Using the emotional information obtained from the emotion engine, the application's functions and interface are adjusted based on the user's emotional state. For example, if the emotional state is "urgent," important tasks are displayed at the top and the user interface is simplified.

[0622] Step 7:

[0623] Server: The Kony platform integration module uploads the generated code to the application development platform and executes the deployment, while simultaneously configuring and building the necessary runtime environment and dependencies.

[0624] Step 8:

[0625] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. Furthermore, they are provided with feedback and an interface that is tailored to their emotional state.

[0626] In this way, the system can automatically analyze, generate code, and deploy the optimal application based on the requirements entered by the user in natural language and their emotional state at the time.

[0627] Example 2

[0628] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0629] Conventional application development systems often suffer from misunderstandings when users communicate their specific requirements to engineers, and are unable to respond quickly. Furthermore, they are unable to adjust the application interface or functionality to take the user's emotional state into account, resulting in a suboptimal user experience. Therefore, there is a need for an application development system that is intuitive, easy to use, and customizable according to the user's emotional state.

[0630] The specification process by the specification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes: means for inputting requirements written in natural language by a user; means for extracting requirements by analyzing the natural language; means for recognizing the user's emotional state from the natural language input; means for identifying required functions based on the extracted requirements and the emotional state; means for generating application code based on the identified functions; means for linking the generated code to an application development platform; and means for adjusting the application functions and interface based on the emotional state. This makes it possible to accurately grasp specific user requirements and quickly develop and deploy applications that can be customized to adapt to the emotional state.

[0631] A "user" is a person or entity that utilizes the system to input application requirements in natural language.

[0632] "Natural language" refers to everyday human language that allows users to interact with systems without requiring specific programming languages ​​or coding skills.

[0633] "Requirements" are natural language descriptions of the functions and objectives that a user requires from an application.

[0634] "Emotional state" refers to the user's psychological and emotional state, and is information parsed from the natural language input by the user.

[0635] A "function" refers to a specific operation or set of operations provided by an application, such as adding a task, updating progress, setting a deadline, and so on.

[0636] "Code" is the set of instructions that make up a computer program, written to perform a particular function.

[0637] An "application development platform" is a platform used for software development and deployment that provides the developed code in a working form.

[0638] "Means" refer to the methods or techniques used to achieve a specific function or purpose.

[0639] "Parsing" is the process of breaking down input natural language requirements and emotional states and extracting meaning and information from them.

[0640] "Extraction" is the process of extracting important information and requirements from input natural language or data.

[0641] "Identification" refers to clarifying the required application functionality based on the extracted information and emotional state.

[0642] "Integration" is the process of integrating the generated code into the application development infrastructure so that the functionality can work.

[0643] "Adjustment" refers to optimizing an application's functionality and interface according to the user's emotional state.

[0644] "Customization" refers to changing the settings and functionality of a system or application according to a user's specific requirements or emotional state.

[0645] The present invention relates to a system that allows a user to input application requirements in natural language, analyzes the input, and generates and deploys application code. Furthermore, the system can recognize the user's emotional state and adjust the application's functionality and interface accordingly. Specific embodiments for implementing the present invention are described below.

[0646] Overview of program processing

[0647] Hardware and Software

[0648] Server: A server for managing and executing the entire process.

[0649] Terminal: A device that runs a web interface or application through which a user can enter requirements and access the application.

[0650] Natural language processing module: Uses the Python nltk library.

[0651] Sentiment engine: Uses Microsoft Azure's Text Analytics API.

[0652] Program generation module: Uses OpenAI's Codex API.

[0653] Application development infrastructure: Uses a common CI / CD pipeline.

[0654] User actions

[0655] Requirements input: Users input their requirements in natural language through a web interface or application, for example, "I want an app that allows employees to share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0656] Processing performed by the server

[0657] Natural language analysis: The server uses a natural language processing module to analyze the input text and extract key keywords and context. Specifically, it divides the text into sentences and identifies requirements such as "project," "add task," "update progress," and "set deadline."

[0658] Emotion recognition: The emotion engine running on the server analyzes the user's emotional state from the input text. For example, if the user writes "I'm in a hurry," the emotion engine will recognize this as "urgent" and tag it.

[0659] Requirements Identification and Code Generation: Based on the identified requirements and emotional state, the server uses a program generation module to generate the necessary application code, including an API that enables CRUD operations and a front-end React component.

[0660] Emotion-based adjustment: The server adjusts the application interface and functionality based on the information from the emotion engine. For example, if the state is "urgent," it changes the user interface to highlight important tasks. This is done using React's state management.

[0661] Code deployment: Finally, the server deploys the generated code to the application development platform. Specifically, the code is pushed to a Git repository and automatically deployed to the production environment through a CI / CD pipeline.

[0662] Specific examples

[0663] The user prompts the system with the following:

[0664] I need an app that allows employees to share project progress. I need the ability to add tasks to projects, update progress, and set deadlines. I'm also in a rush, so something that works quickly is helpful.

[0665] In response to this prompt, the system generates, adapts, and deploys the desired application, making it immediately available to the user.

[0666] Although the specific embodiments for carrying out the present invention have been described above, the present invention is not limited to these, and various modifications and improvements can be made thereto.

[0667] The flow of the identification process in the second embodiment will be described with reference to FIG.

[0668] Step 1: Entering requirements

[0669] User: Enters application requirements in natural language through a web interface or application. For example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0670] Input: The user's natural language requirements.

[0671] Output: The input natural language text.

[0672] Step 2: Parsing natural language

[0673] Server: Analyzes the user's input text using the Natural Language Processing (NLP) module. It uses the Python nltk library to split the text into sentences and extract key keywords and context.

[0674] Input: Natural language text entered by the user.

[0675] Output: A list of key keywords and feature requirements (e.g. "project management", "add tasks", "update progress", "set deadlines").

[0676] Step 3: Recognize emotions

[0677] Server: Analyzes the user's emotional state from the text input using the emotion engine. It uses Microsoft Azure's Text Analytics API to generate emotion tags (e.g., "urgency," "expectation," "confusion," etc.).

[0678] Input: Natural language text entered by the user.

[0679] Output: User's emotional state (e.g., "urgent").

[0680] Step 4: Identify requirements

[0681] Server: The requirements analysis module receives the functional requirements list from the NLP module and the emotional state information from the emotion engine, and identifies specific application functions. For example, it determines that functions such as "add task," "update progress," and "set deadline" are required.

[0682] Input: Functional requirements list and emotional state information.

[0683] Output: A list of required application features.

[0684] Step 5: Generate Code

[0685] Server: Uses the program generation module to generate code based on the identified application functionality. Uses OpenAI's Codex API to generate APIs and React components with CRUD operations.

[0686] Input: A list of required application features.

[0687] Output: The generated application code.

[0688] Step 6: Emotional Adjustment

[0689] Server: Based on the information from the emotion engine, the interface and functionality of the generated application are adjusted to match the user's emotional state. For example, in an "urgent" state, the interface and functionality are adjusted to prioritize important tasks.

[0690] Input: Generated application code and emotional state information.

[0691] Output: Application code adapted to the user's emotional state.

[0692] Step 7: Deploy your code

[0693] Server: The generated application code is integrated into the application development platform and deployed. The code is pushed to a Git repository and deployed to the production environment through a CI / CD pipeline.

[0694] Input: Application code adapted to the user's emotional state.

[0695] Output: The deployed application.

[0696] Step 8: User Adoption

[0697] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. The emotion engine also provides appropriate feedback and interfaces.

[0698] Input: Access to deployed applications.

[0699] Output: The application usage and user operation results.

[0700] (Application example 2)

[0701] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the smart glasses 214 will be referred to as a "terminal."

[0702] Traditional application development methods require users to define specific requirements and functions in detail and then incorporate them into the code, requiring advanced programming skills. It is also difficult to provide interface adjustments and functions that take into account the user's emotions and urgency. This results in poor usability and makes it difficult for users to quickly obtain applications that meet their needs.

[0703] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[0704] In this invention, the server includes means for inputting requirements written in natural language by the user, means for extracting requirements by analyzing the natural language, and means for identifying necessary functions based on the extracted requirements, thereby enabling automatic generation of an application based on simple requests input in natural language by the user.

[0705] The server further includes means for generating application code based on the identified functions, means for linking the generated code to an application development platform, means for analyzing the user's emotional state, and means for adjusting the application's functions and interface based on the emotional state, thereby enabling the provision of an optimal application taking into account the user's emotions and urgency, thereby improving the user experience.

[0706] "Natural language" refers to the words and expressions people use in their daily lives, rather than technical or code language.

[0707] "Requirements" are the specific conditions and requirements for the functions and performance that users expect from an application.

[0708] "Analysis" is the process of deciphering input data or information and clarifying its meaning and content.

[0709] "Emotional state" refers to the mental state a user is feeling at a particular moment, and may include, for example, happiness, sadness, impatience, etc.

[0710] "Function" refers to a specific operation or capability of an application, and refers to a series of operations that a user desires.

[0711] "Code" is the set of instructions or statements that make up a program, written in a form that a computer can understand and execute.

[0712] "Application Development Platform" means a combination of software and hardware to support the development, deployment, and operation of applications.

[0713] An "interface" is a point of contact or means through which a user and an application interact with each other, and is also called a user interface (UI).

[0714] "Identifying" means clearly identifying an object and defining its properties and characteristics.

[0715] "Collaboration" means that multiple systems and modules work together, sharing information and data to function.

[0716] "Adjust" means to change the settings or behavior of a system or component to suit specific conditions or circumstances.

[0717] The following system configuration is conceivable as an embodiment for carrying out the present invention: The system is composed of a server, a user terminal, and an application development platform.

[0718] The server first provides a means for users to input their requirements written in natural language, for example through a text input field in a web interface or mobile application, which may include prompts such as "I'm in a hurry and want a smartphone that arrives as quickly as possible."

[0719] Next, the server analyzes the input text using a natural language analysis module. At this stage, key keywords and context are extracted. Natural language processing (NLP) techniques are used for the analysis. Commonly used NLP libraries such as "TensorFlow" and "spaCy" are used for the NLP techniques.

[0720] In parallel, the server uses an emotion engine to recognize the user's emotional state. Suitable emotion engines include Affectiva and IBM Watson Tone Analyzer. For example, it can recognize the emotional state of "urgent" from the expression "I'm in a hurry."

[0721] Based on the analysis results, the server uses the requirements analysis module to identify necessary functions, such as task management, progress display, and deadline setting. Based on this information, the program generation module automatically generates code. Generative AI models such as OpenAI GPT-3 and Codex are used for code generation.

[0722] The server then adjusts the generated code and interface based on the user's emotional state, dynamically changing the user interface depending on the user's emotional state. For example, in an "emergency" situation, the interface adjusts to bring important information and actions to the forefront.

[0723] Finally, the server deploys the generated code using an application development platform such as Kony, and the actual application is put into production, allowing users to access the developed application and use its various functions.

[0724] Specific examples

[0725] For example, if a user inputs "I'm in a hurry, so I want a smartphone that can be delivered as quickly as possible," the server will analyze this input, recognize the emotional state of "urgency" from the expression "in a hurry," search for smartphones that can be delivered as quickly as possible, and display them as a priority.

[0726] Example prompt sentence:

[0727] "I'm in a hurry, so I want the fastest possible smartphone."

[0728] In this way, the system can easily provide applications that accurately reflect the user's requirements and emotional state.

[0729] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[0730] Step 1:

[0731] The user enters requirements written in natural language.

[0732] What it does: A user uses a web interface or a mobile application to enter their desired product and requirements in natural language using a text input field, for example, "I'm in a hurry and want a smartphone that arrives as quickly as possible."

[0733] Input: User's natural language text.

[0734] Output: The requirement text entered.

[0735] Step 2:

[0736] The server analyzes the text using a natural language processing module (NLP).

[0737] How it works: The server uses NLP libraries like TensorFlow and spaCy to analyze the input requirements text and extract key keywords and context. For example, it extracts keywords like "urgent," "fastest," and "smartphone."

[0738] Input: The requirement text entered.

[0739] Output: Extracted keywords and context information.

[0740] Step 3:

[0741] The server uses an emotion engine to recognize the user's emotional state.

[0742] Specific operation: The server uses emotion analysis tools such as "Affectiva" and "IBM Watson Tone Analyzer" to analyze the emotional state of the input text, such as "urgent" or "relaxed." For example, it recognizes the emotional state of "urgent" from the expression "in a hurry."

[0743] Input: The requirement text entered.

[0744] Output: Perceived emotional state (e.g., "urgent").

[0745] Step 4:

[0746] The server uses a requirements analysis module to identify the required functionality.

[0747] Specific operation: Based on the information analyzed by the NLP module and emotion engine, the server's requirements analysis module identifies the functions that meet the user's needs. For example, since the emotional state is urgent, the server selects the function to display products for fastest delivery.

[0748] Input: extracted keywords and recognized emotional states.

[0749] Output: Identified features (e.g., display items with fastest shipping).

[0750] Step 5:

[0751] The server uses a program generation module to generate code for the application based on the identified functionality.

[0752] How it works: The server uses generative AI models such as OpenAI GPT-3 and Codex to automatically generate appropriate code based on the functions identified through requirements analysis. For example, it generates code to display the products that can be delivered the fastest.

[0753] Input: Identified feature information.

[0754] Output: The generated application code.

[0755] Step 6:

[0756] The server adjusts the generated code and interface based on the emotional state.

[0757] Specific behavior: The server adjusts the interface and functions of the generated application according to the recognized emotional state. For example, in an emergency, it adjusts the layout to prioritize important information.

[0758] Input: Generated application code and recognized emotional state.

[0759] Output: Adjusted application code and interfaces.

[0760] Step 7:

[0761] The server ultimately deploys the code to an application development platform.

[0762] What it does: The server uses an application development platform such as Kony to deploy the generated and tailored code and put the application into production.

[0763] Input: The adjusted application code.

[0764] Output: The deployed application.

[0765] Step 8:

[0766] A user accesses the deployed application and utilizes the functionality provided.

[0767] Specific operation: The user accesses the deployed application from a web browser or mobile app and performs operations such as searching and displaying the fastest available smartphone.

[0768] Input: User interaction with deployed application.

[0769] Output: Providing the information or functionality the user requests.

[0770] The specific processing unit 290 transmits the result of the specific processing to the smart glasses 214. In the smart glasses 214, the control unit 46A causes the speaker 240 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[0771] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[0772] In the above embodiment, an example in which the specific processing is performed by the data processing device 12 has been given, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the smart glasses 214.

[0773] [Third embodiment]

[0774] FIG. 5 shows an example of the configuration of a data processing system 310 according to the third embodiment.

[0775] 5, the data processing system 310 includes the data processing device 12 and a headset type terminal 314. An example of the data processing device 12 is a server.

[0776] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[0777] The headset type terminal 314 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a display 343. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the display 343 are also connected to the bus 52.

[0778] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[0779] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[0780] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[0781] Fig. 6 shows an example of the main functions of the data processing device 12 and the headset type terminal 314. As shown in Fig. 6, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[0782] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[0783] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[0784] In the headset type terminal 314, a reception output process is performed by the processor 46. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[0785] Next, a description will be given of the identification process performed by the identification processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as the "server" and the headset type terminal 314 will be referred to as the "terminal."

[0786] The system of the present invention analyzes application requirements entered by users in natural language, automatically generates code based on specific functions, and deploys it on an application development platform, allowing users to create customized in-house applications without requiring programming knowledge.

[0787] Specific explanation of program processing

[0788] 1. Enter your requirements

[0789] User: Enters application requirements in natural language using a web interface or application. For example, a user might enter a requirement like "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0790] 2. Natural Language Analysis

[0791] Server: A Natural Language Processing (NLP) module analyzes the input requirements. This module segments the text, extracts key keywords and context, and understands the requirements.

[0792] For example, the NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[0793] 3. Identifying Requirements

[0794] Server: The requirements analysis module identifies the required features based on the information sent from the NLP module. Based on the extracted requirements, this module determines the feature set required for the application.

[0795] For example, CRUD operations (Create, Read, Update, Delete) and expiration functions are specified.

[0796] 4. Code Generation

[0797] Server: The program generation module generates the code for the application based on the identified functions. For each determined function, this module generates the appropriate code block.

[0798] For example, code is generated for a task add button, a task list view, task edit / delete functions, a deadline setting form, etc.

[0799] 5. Deploying your code

[0800] Server: The Kony platform integration module integrates the generated code into the application development platform and executes the deployment, which makes the application ready for production.

[0801] Specific examples

[0802] Let's say a user types, "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[0803] 1. User: Enters requirements in natural language.

[0804] 2. Server: The NLP module extracts keywords such as "project," "task," "progress," and "deadline."

[0805] 3. Server: The requirements analysis module identifies the required functionality (CRUD operations, progress update functionality, deadline setting).

[0806] 4. Server: The program generation module generates code corresponding to each function.

[0807] 5. Server: Deploys the generated code using the Kony platform integration module and publishes the application.

[0808] This process allows users to automatically create and deploy applications based on requirements entered in natural language.

[0809] The processing flow will be explained below.

[0810] Step 1:

[0811] User: Accesses a web interface and enters application requirements in natural language, for example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0812] Step 2:

[0813] Server: The Natural Language Processing (NLP) module receives the input text and begins analyzing it. It uses word segmentation and grammar analysis to extract key keywords (such as "project," "task," "progress," and "deadline") and understand contextual relationships.

[0814] Step 3:

[0815] Server: The NLP module sends the extracted keywords and context information to the requirements analysis module, which identifies the required features based on the extracted keywords.

[0816] Step 4:

[0817] Server: The requirements analysis module clarifies the identified feature set and plans the overall application structure, including specific features such as CRUD operations (create, read, update, delete) and task progress tracking and deadline setting.

[0818] Step 5:

[0819] Server: The program generation module generates the necessary code based on the information provided by the requirements analysis module. Code generation combines the corresponding code blocks for each function (CRUD operations, progress management, deadline setting).

[0820] Step 6:

[0821] Server: The code generated by the program generation module is sent to the Kony Platform integration module, which uploads the generated code to the appropriate location on the Kony Platform.

[0822] Step 7:

[0823] Server: The Kony platform integration module deploys the application based on the uploaded code and makes it executable, so that the application can be used by real users.

[0824] Step 8:

[0825] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, and set deadlines.

[0826] In this way, the system automatically analyzes requirements entered by the user in natural language, generates code, and deploys the application.

[0827] Example 1

[0828] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0829] Conventional application development requires experts with programming knowledge, making it difficult for users without technical knowledge to create applications on their own. It is also difficult to accurately incorporate and quickly reflect user requirements. For these reasons, there is a demand for application development methods that are efficient in terms of both time and cost.

[0830] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[0831] In this invention, the server includes means for inputting requirements written in natural language by a user, means for extracting requirements by analyzing the natural language, means for identifying necessary functions based on the extracted requirements, means for generating application code based on the identified functions, and means for linking the generated code to an application development platform and deploying it. This enables users, even without programming knowledge, to create customized applications based on their specific requirements in a short period of time and have them immediately operational.

[0832] A "user" is an entity that uses the system to input requirements in natural language.

[0833] "Natural language" refers to a language used by humans on a daily basis, and is a language form that does not include program code or special notation.

[0834] "Requirements" are applications functions and characteristics that a user desires from a system, expressed in natural language.

[0835] "Parsing" refers to the process of converting input natural language requirements into a form that the system can understand.

[0836] "Keywords" are key words extracted from natural language requirements and are the basis for a system to understand the requirements.

[0837] "Context" refers to the context or background information in a natural language requirement, used to clarify the meaning of a keyword.

[0838] "Function" refers to the specific operations or behaviors provided by an application, and is specified based on the requirements desired by the user.

[0839] "Code" is a set of instructions written in a programming language that implements the behavior of an application.

[0840] "Application Development Platform" means a software tool or environment for building, managing, and deploying applications based on generated code.

[0841] "Deployment" refers to the process of placing the generated code on an application development platform and making it executable.

[0842] The system of the present invention analyzes application requirements entered by the user in natural language, automatically generates code based on the requirements, and deploys it on an application development platform. This system consists of three main components: the user, the terminal, and the server.

[0843] Hardware and software used

[0844] Hardware: Servers and devices used by users (PCs, smartphones, etc.).

[0845] software:

[0846] Natural Language Processing Module (NLP Module)

[0847] Requirement Analysis Module

[0848] Program Generation Module

[0849] Application development platform linkage module

[0850] Application development platform (e.g., general-purpose application development platform)

[0851] Specific explanation of the process

[0852] Entering requirements

[0853] Using a web interface or application, a user enters their application requirements in natural language, for example, "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0854] Natural Language Analysis

[0855] The server parses the input requirements using a natural language processing (NLP) module. This module understands the requirements by segmenting the text and extracting key keywords and context. For example, the NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[0856] Identifying requirements

[0857] The server uses a requirements analysis module to identify the required functionality based on the information sent by the NLP module, for example, CRUD operations (Create, Read, Update, Delete) and deadline setting functionality.

[0858] Code generation

[0859] The server uses a program generation module to generate application code based on the specified features, such as an add task button, a task list view, task edit and delete functions, a deadline setting form, etc.

[0860] Deploying your code

[0861] The server integrates the generated code into the application development platform using the application development platform integration module and executes deployment, which makes the application ready for actual operation.

[0862] Specific examples

[0863] Here is a concrete example:

[0864] A user types, "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[0865] 1. User: Enters requirements in natural language into a web interface.

[0866] 2. Server: The NLP module extracts keywords such as "project," "task," "progress," and "deadline."

[0867] 3. Server: The requirements analysis module identifies the required functionality (CRUD operations, progress update functionality, deadline setting).

[0868] 4. Server: The program generation module generates code corresponding to each function.

[0869] 5. Server: Deploys the generated code using the application development platform integration module and publishes the application.

[0870] Prompt Sentence Examples

[0871] "I want to build a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0872] "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[0873] The flow of the identification process in the first embodiment will be described with reference to FIG.

[0874] Step 1: Entering requirements

[0875] A user opens a web interface or application and enters the application requirements in natural language.

[0876] Input: A user enters requirements such as "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[0877] Output: User requirements become text data that is input into the system.

[0878] Specific behavior: The user enters their requirements into the text field and clicks the "Submit" button.

[0879] Step 2: Parsing natural language

[0880] The server receives the requirements sent from the terminal and activates a natural language processing (NLP) module.

[0881] Input: The text data of the requirement entered by the user.

[0882] Data processing: The NLP module segments the text and extracts key keywords and context.

[0883] Output: Parsed keywords and context information.

[0884] What it does: The NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[0885] Step 3: Identify requirements

[0886] The server uses a requirements analysis module to identify the required functionality based on the information sent from the NLP module.

[0887] Input: Parsed keywords and context information.

[0888] Data calculation: The requirements analysis module maps the keywords to corresponding standard functions (CRUD operations, deadline setting).

[0889] Output: Identification of the required feature set.

[0890] Specific behavior: The requirements analysis module identifies CRUD operations (Create, Read, Update, Delete) and deadline setting functions.

[0891] Step 4: Generate code

[0892] The server uses a program generation module to generate code for the application based on the specified functions.

[0893] Input: The identified feature set.

[0894] Data processing: The program generation module generates the appropriate code block for each function.

[0895] Output: The source code of the application.

[0896] Specific operation: The program generation module creates code for the task addition button, task list view, task edit / delete function, deadline setting form, etc.

[0897] Step 5: Deploy your code

[0898] The server integrates the generated code using the application development platform cooperation module into the application development platform and deploys it.

[0899] Input: The source code of the generated application.

[0900] Data processing: The linking module compiles the code and applies it to the platform.

[0901] Output: A working application.

[0902] What happens: The server uploads the code to the application development platform, applies the configuration, and publishes the application.

[0903] (Application example 1)

[0904] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[0905] Task management in conventional logistics centers is often done manually, resulting in a lack of efficiency and accuracy. Furthermore, it is difficult to share task progress in real time and manage deadlines. Therefore, there is a need to provide an effective task management method and improve the operational efficiency of logistics centers.

[0906] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[0907] In this invention, the server includes: means for inputting requirements written in natural language by a user; means for analyzing the natural language to extract requirements; means for identifying necessary functions based on the extracted requirements; means for generating application code based on the identified functions; means for linking the generated code to an application development platform; and means for identifying a task management application for managing the operation of a logistics center. This enables logistics staff to add, edit, and delete tasks and track their progress in real time. It also makes it easy to set deadlines for tasks and share progress, significantly improving the operational efficiency of the logistics center.

[0908] A "user" is a person who utilizes the system to input application requirements in natural language.

[0909] A "natural language" is a language that humans use on a daily basis, and is different from a programming language.

[0910] "Requirements" refers to the functions and specifications required for an application that are input by the user in natural language.

[0911] "Parsing" is the process of interpreting requirements entered in natural language and extracting specific keywords and context.

[0912] A "feature" refers to a specific set of operations or behaviors implemented in an application.

[0913] "Code" is a collection of instructions and rules for writing a program that defines the behavior of an application.

[0914] An "application development platform" is the underlying software or environment for executing generated code and running it as an application.

[0915] "Integration" is the process of integrating the generated code into an application development platform and deploying it as a working application.

[0916] A logistics center is a facility that receives, stores, and ships goods, and is a place that requires efficient operational management.

[0917] A "task management application" is software that supports the operation and management of a logistics center, and provides functions such as adding, editing, deleting, and managing progress of tasks.

[0918] This invention is a system that automatically generates a task management application for managing the operation of a logistics center based on requirements entered by a user in natural language.

[0919] The system of the present invention includes the following major components:

[0920] 1. User terminal: Enter application requirements in natural language through a web interface or mobile application.

[0921] 2. Server: Analyzes natural language, identifies required functionality, generates application code, and integrates that code with the application development platform.

[0922] Program operation and description of the hardware and software used

[0923] Natural Language Input and Analysis

[0924] User device: Using a smartphone or computer, the user enters their requirements in natural language.

[0925] Server: Analyzes the text using a natural language processing (NLP) module. This NLP module includes functions to extract key keywords and context. The specific software used is a Python natural language processing library (e.g., NLTK, SpaCy).

[0926] Requirements Identification and Code Generation

[0927] Server: The requirements analysis module identifies the required functionality based on the information sent from the NLP module. For example, it identifies functions such as database operations (CRUD), progress updates, and deadline settings. Next, the program generation module creates the code based on these identified functions. Specifically, it generates code in Python or JavaScript.

[0928] Deploying your code

[0929] Server: The generated code is integrated into the application development platform and deployed. Here, deployment is performed using Flask (a Python micro web framework) and MongoDB.

[0930] Specific examples

[0931] When inputting requirements for a task management application to support the operation of a logistics center, the following can be entered in natural language: "I want to create an app that can add new inventory check tasks and update their progress. I want the app to set deadlines for tasks and issue alerts when tasks pass their deadlines." Based on this natural language input, the NLP module extracts keywords such as "inventory check," "progress," "deadline," and "alert," and uses these to identify the required functions.

[0932] Prompt Sentence Examples

[0933] "I want to create an app that allows users to add new inventory check tasks and update their progress. I want tasks to have deadlines and be alerted when tasks are past their deadline."

[0934] In this way, the system of the present invention can automatically generate task management applications that significantly improve the operational efficiency of a logistics center.

[0935] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[0936] Step 1:

[0937] Users enter requirements in natural language

[0938] Users use their smartphones or computers to input requirements in natural language through a web interface or mobile application, along with prompts such as, "I want to create an app that allows logistics staff to add tasks and update their progress. I want tasks to have deadlines and be alerted when a task is past its deadline."

[0939] Input: Natural Language Requirements

[0940] Output: Natural language text data

[0941] Step 2:

[0942] The server analyzes natural language

[0943] The server uses a natural language processing (NLP) module to parse the requirements entered by the user. It uses a Python natural language processing library (NLTK, SpaCy, etc.) to extract key keywords and context from the text data. For example, keywords such as "task management," "add," "delete," "edit," and "deadline" are extracted.

[0944] Input: Natural language text data

[0945] Output: Extracted keywords and context data

[0946] Step 3:

[0947] The server identifies the required functionality based on the requirements

[0948] The server's requirements analysis module identifies required functionality based on keywords and contextual data obtained from the NLP module, such as database operations (CRUD operations), deadline setting functionality, and progress updates.

[0949] Input: Extracted keywords and context data

[0950] Output: Required feature set

[0951] Step 4:

[0952] The server generates the application code

[0953] The server's program generation module generates application code based on the identified functionality, using Python, JavaScript, or other programming languages ​​to generate code blocks for each functionality (e.g., task addition, edit, delete, progress display, deadline setting form, etc.).

[0954] Input: desired feature set

[0955] Output: Generated application code

[0956] Step 5:

[0957] The server integrates and deploys the generated code to the application development platform.

[0958] The server's deployment module automatically deploys the generated code to an application development platform (e.g., a platform using Flask or MongoDB), and the code is deployed as a working application.

[0959] Input: Generated application code

[0960] Output: Deployed application

[0961] Through this step-by-step process, a system is realized in which a task management application that supports the operation of a logistics center is automatically generated and deployed based on requirements entered by the user in natural language.

[0962] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[0963] The system of the present invention analyzes application requirements entered by the user in natural language, identifies the necessary functions, generates code, and deploys it in conjunction with an application development platform. Furthermore, it combines an emotion engine that recognizes the user's emotions and adjusts the application's functions and interface based on the user's emotional state, providing a more user-friendly experience.

[0964] Specific explanation of program processing

[0965] 1. Enter your requirements

[0966] Users: Enter their application requirements in natural language through a web interface or application, for example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0967] 2. Natural Language Analysis

[0968] Server: The Natural Language Processing (NLP) module receives and analyzes the input text. This module segments the text and extracts key keywords and context. At the same time, the emotion engine analyzes the text to recognize the user's emotions.

[0969] 3. Emotional Recognition

[0970] Server: The emotion engine analyzes the user's emotional state from natural language input. For example, if the user uses an expression such as "I'm in a hurry," the emotion engine recognizes the emotional state as "urgent."

[0971] 4. Identifying Requirements

[0972] Server: Sends the analysis results of the NLP module and the emotion engine to the requirements analysis module to identify the required features, taking into account the information from the emotion engine to determine the feature set that best suits the user's needs.

[0973] 5. Code Generation

[0974] Server: The program generation module generates the necessary code based on the information provided by the requirements analysis module. This generated code corresponds to specific functions (e.g., CRUD operations, progress management, deadline setting).

[0975] 6. Emotion-Based Regulation

[0976] Server: Based on the information obtained from the emotion engine, the server adjusts the application functions and interface according to the user's emotional state. For example, if the user is in an "urgent" state, the server adjusts the user interface to prioritize important tasks.

[0977] 7. Deploying your code

[0978] Server: The Kony platform integration module integrates the generated code into the application development platform and executes the deployment, making the application ready for production.

[0979] 8. User Usage

[0980] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. Furthermore, the emotion engine provides appropriate feedback and interfaces based on the user's emotional state.

[0981] In this way, the system can provide user-friendly applications by analyzing requirements entered by the user in natural language, combining an emotion engine, generating code, and deploying the application.

[0982] The processing flow will be explained below.

[0983] Step 1:

[0984] User: Accesses a web interface and enters their application requirements in natural language, such as "I want an app that allows employees to share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[0985] Step 2:

[0986] Server: The Natural Language Processing (NLP) module receives the user input and starts text analysis, segmenting the text and extracting key keywords (e.g., "project," "task," "progress," "deadline") and contextual relationships.

[0987] Step 3:

[0988] Server: The emotion engine analyzes the user's input text and recognizes the emotional state. For example, if the text contains the expression "hurrying," the emotion engine recognizes the emotional state as "urgent."

[0989] Step 4:

[0990] Server: Sends the analysis results of the NLP module and emotion engine to the requirements analysis module, which identifies the required function set (CRUD operations, progress management, deadline setting) based on the extracted keywords and emotion information.

[0991] Step 5:

[0992] Server: The program generation module generates the corresponding code blocks based on the information sent from the requirements analysis module. For example, it builds the code including the functions to add, edit, and delete tasks and the deadline setting function.

[0993] Step 6:

[0994] Server: Using the emotional information obtained from the emotion engine, the application's functions and interface are adjusted based on the user's emotional state. For example, if the emotional state is "urgent," important tasks are displayed at the top and the user interface is simplified.

[0995] Step 7:

[0996] Server: The Kony platform integration module uploads the generated code to the application development platform and executes the deployment, while simultaneously configuring and building the necessary runtime environment and dependencies.

[0997] Step 8:

[0998] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. Furthermore, they are provided with feedback and an interface that is tailored to their emotional state.

[0999] In this way, the system can automatically analyze, generate code, and deploy the optimal application based on the requirements entered by the user in natural language and their emotional state at the time.

[1000] Example 2

[1001] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1002] Conventional application development systems often suffer from misunderstandings when users communicate their specific requirements to engineers, and are unable to respond quickly. Furthermore, they are unable to adjust the application interface or functionality to take the user's emotional state into account, resulting in a suboptimal user experience. Therefore, there is a need for an application development system that is intuitive, easy to use, and customizable according to the user's emotional state.

[1003] The specification process by the specification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes: means for inputting requirements written in natural language by a user; means for extracting requirements by analyzing the natural language; means for recognizing the user's emotional state from the natural language input; means for identifying required functions based on the extracted requirements and the emotional state; means for generating application code based on the identified functions; means for linking the generated code to an application development platform; and means for adjusting the application functions and interface based on the emotional state. This makes it possible to accurately grasp specific user requirements and quickly develop and deploy applications that can be customized to adapt to the emotional state.

[1004] A "user" is a person or entity that utilizes the system to input application requirements in natural language.

[1005] "Natural language" refers to everyday human language that allows users to interact with systems without requiring specific programming languages ​​or coding skills.

[1006] "Requirements" are natural language descriptions of the functions and objectives that a user requires from an application.

[1007] "Emotional state" refers to the user's psychological and emotional state, and is information parsed from the natural language input by the user.

[1008] A "function" refers to a specific operation or set of operations provided by an application, such as adding a task, updating progress, setting a deadline, and so on.

[1009] "Code" is the set of instructions that make up a computer program, written to perform a particular function.

[1010] An "application development platform" is a platform used for software development and deployment that provides the developed code in a working form.

[1011] "Means" refer to the methods or techniques used to achieve a specific function or purpose.

[1012] "Parsing" is the process of breaking down input natural language requirements and emotional states and extracting meaning and information from them.

[1013] "Extraction" is the process of extracting important information and requirements from input natural language or data.

[1014] "Identification" refers to clarifying the required application functionality based on the extracted information and emotional state.

[1015] "Integration" is the process of integrating the generated code into the application development infrastructure so that the functionality can work.

[1016] "Adjustment" refers to optimizing an application's functionality and interface according to the user's emotional state.

[1017] "Customization" refers to changing the settings and functionality of a system or application according to a user's specific requirements or emotional state.

[1018] The present invention relates to a system that allows a user to input application requirements in natural language, analyzes the input, and generates and deploys application code. Furthermore, the system can recognize the user's emotional state and adjust the application's functionality and interface accordingly. Specific embodiments for implementing the present invention are described below.

[1019] Overview of program processing

[1020] Hardware and Software

[1021] Server: A server for managing and executing the entire process.

[1022] Terminal: A device that runs a web interface or application through which a user can enter requirements and access the application.

[1023] Natural language processing module: Uses the Python nltk library.

[1024] Sentiment engine: Uses Microsoft Azure's Text Analytics API.

[1025] Program generation module: Uses OpenAI's Codex API.

[1026] Application development infrastructure: Uses a common CI / CD pipeline.

[1027] User actions

[1028] Requirements input: Users input their requirements in natural language through a web interface or application, for example, "I want an app that allows employees to share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[1029] Processing performed by the server

[1030] Natural language analysis: The server uses a natural language processing module to analyze the input text and extract key keywords and context. Specifically, it divides the text into sentences and identifies requirements such as "project," "add task," "update progress," and "set deadline."

[1031] Emotion recognition: The emotion engine running on the server analyzes the user's emotional state from the input text. For example, if the user writes "I'm in a hurry," the emotion engine will recognize this as "urgent" and tag it.

[1032] Requirements Identification and Code Generation: Based on the identified requirements and emotional state, the server uses a program generation module to generate the necessary application code, including an API that enables CRUD operations and a front-end React component.

[1033] Emotion-based adjustment: The server adjusts the application interface and functionality based on the information from the emotion engine. For example, if the state is "urgent," it changes the user interface to highlight important tasks. This is done using React's state management.

[1034] Code deployment: Finally, the server deploys the generated code to the application development platform. Specifically, the code is pushed to a Git repository and automatically deployed to the production environment through a CI / CD pipeline.

[1035] Specific examples

[1036] The user prompts the system with the following:

[1037] I need an app that allows employees to share project progress. I need the ability to add tasks to projects, update progress, and set deadlines. I'm also in a rush, so something that works quickly is helpful.

[1038] In response to this prompt, the system generates, adapts, and deploys the desired application, making it immediately available to the user.

[1039] Although the specific embodiments for carrying out the present invention have been described above, the present invention is not limited to these, and various modifications and improvements can be made thereto.

[1040] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1041] Step 1: Entering requirements

[1042] User: Enters application requirements in natural language through a web interface or application. For example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[1043] Input: The user's natural language requirements.

[1044] Output: The input natural language text.

[1045] Step 2: Parsing natural language

[1046] Server: Analyzes the user's input text using the Natural Language Processing (NLP) module. It uses the Python nltk library to split the text into sentences and extract key keywords and context.

[1047] Input: Natural language text entered by the user.

[1048] Output: A list of key keywords and feature requirements (e.g. "project management", "add tasks", "update progress", "set deadlines").

[1049] Step 3: Recognize emotions

[1050] Server: Analyzes the user's emotional state from the text input using the emotion engine. It uses Microsoft Azure's Text Analytics API to generate emotion tags (e.g., "urgency," "expectation," "confusion," etc.).

[1051] Input: Natural language text entered by the user.

[1052] Output: User's emotional state (e.g., "urgent").

[1053] Step 4: Identify requirements

[1054] Server: The requirements analysis module receives the functional requirements list from the NLP module and the emotional state information from the emotion engine, and identifies specific application functions. For example, it determines that functions such as "add task," "update progress," and "set deadline" are required.

[1055] Input: Functional requirements list and emotional state information.

[1056] Output: A list of required application features.

[1057] Step 5: Generate Code

[1058] Server: Uses the program generation module to generate code based on the identified application functionality. Uses OpenAI's Codex API to generate APIs and React components with CRUD operations.

[1059] Input: A list of required application features.

[1060] Output: The generated application code.

[1061] Step 6: Emotional Adjustment

[1062] Server: Based on the information from the emotion engine, the interface and functionality of the generated application are adjusted to match the user's emotional state. For example, in an "urgent" state, the interface and functionality are adjusted to prioritize important tasks.

[1063] Input: Generated application code and emotional state information.

[1064] Output: Application code adapted to the user's emotional state.

[1065] Step 7: Deploy your code

[1066] Server: The generated application code is integrated into the application development platform and deployed. The code is pushed to a Git repository and deployed to the production environment through a CI / CD pipeline.

[1067] Input: Application code adapted to the user's emotional state.

[1068] Output: The deployed application.

[1069] Step 8: User Adoption

[1070] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. The emotion engine also provides appropriate feedback and interfaces.

[1071] Input: Access to deployed applications.

[1072] Output: The application usage and user operation results.

[1073] (Application example 2)

[1074] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the headset type terminal 314 will be referred to as a "terminal."

[1075] Traditional application development methods require users to define specific requirements and functions in detail and then incorporate them into the code, requiring advanced programming skills. It is also difficult to provide interface adjustments and functions that take into account the user's emotions and urgency. This results in poor usability and makes it difficult for users to quickly obtain applications that meet their needs.

[1076] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[1077] In this invention, the server includes means for inputting requirements written in natural language by the user, means for extracting requirements by analyzing the natural language, and means for identifying necessary functions based on the extracted requirements, thereby enabling automatic generation of an application based on simple requests input in natural language by the user.

[1078] The server further includes means for generating application code based on the identified functions, means for linking the generated code to an application development platform, means for analyzing the user's emotional state, and means for adjusting the application's functions and interface based on the emotional state, thereby enabling the provision of an optimal application taking into account the user's emotions and urgency, thereby improving the user experience.

[1079] "Natural language" refers to the words and expressions people use in their daily lives, rather than technical or code language.

[1080] "Requirements" are the specific conditions and requirements for the functions and performance that users expect from an application.

[1081] "Analysis" is the process of deciphering input data or information and clarifying its meaning and content.

[1082] "Emotional state" refers to the mental state a user is feeling at a particular moment, and may include, for example, happiness, sadness, impatience, etc.

[1083] "Function" refers to a specific operation or capability of an application, and refers to a series of operations that a user desires.

[1084] "Code" is the set of instructions or statements that make up a program, written in a form that a computer can understand and execute.

[1085] "Application Development Platform" means a combination of software and hardware to support the development, deployment, and operation of applications.

[1086] An "interface" is a point of contact or means through which a user and an application interact with each other, and is also called a user interface (UI).

[1087] "Identifying" means clearly identifying an object and defining its properties and characteristics.

[1088] "Collaboration" means that multiple systems and modules work together, sharing information and data to function.

[1089] "Adjust" means to change the settings or behavior of a system or component to suit specific conditions or circumstances.

[1090] The following system configuration is conceivable as an embodiment for carrying out the present invention: The system is composed of a server, a user terminal, and an application development platform.

[1091] The server first provides a means for users to input their requirements written in natural language, for example through a text input field in a web interface or mobile application, which may include prompts such as "I'm in a hurry and want a smartphone that arrives as quickly as possible."

[1092] Next, the server analyzes the input text using a natural language analysis module. At this stage, key keywords and context are extracted. Natural language processing (NLP) techniques are used for the analysis. Commonly used NLP libraries such as "TensorFlow" and "spaCy" are used for the NLP techniques.

[1093] In parallel, the server uses an emotion engine to recognize the user's emotional state. Suitable emotion engines include Affectiva and IBM Watson Tone Analyzer. For example, it can recognize the emotional state of "urgent" from the expression "I'm in a hurry."

[1094] Based on the analysis results, the server uses the requirements analysis module to identify necessary functions, such as task management, progress display, and deadline setting. Based on this information, the program generation module automatically generates code. Generative AI models such as OpenAI GPT-3 and Codex are used for code generation.

[1095] The server then adjusts the generated code and interface based on the user's emotional state, dynamically changing the user interface depending on the user's emotional state. For example, in an "emergency" situation, the interface adjusts to bring important information and actions to the forefront.

[1096] Finally, the server deploys the generated code using an application development platform such as Kony, and the actual application is put into production, allowing users to access the developed application and use its various functions.

[1097] Specific examples

[1098] For example, if a user inputs "I'm in a hurry, so I want a smartphone that can be delivered as quickly as possible," the server will analyze this input, recognize the emotional state of "urgency" from the expression "in a hurry," search for smartphones that can be delivered as quickly as possible, and display them as a priority.

[1099] Example prompt sentence:

[1100] "I'm in a hurry, so I want the fastest possible smartphone."

[1101] In this way, the system can easily provide applications that accurately reflect the user's requirements and emotional state.

[1102] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1103] Step 1:

[1104] The user enters requirements written in natural language.

[1105] What it does: A user uses a web interface or a mobile application to enter their desired product and requirements in natural language using a text input field, for example, "I'm in a hurry and want a smartphone that arrives as quickly as possible."

[1106] Input: User's natural language text.

[1107] Output: The requirement text entered.

[1108] Step 2:

[1109] The server analyzes the text using a natural language processing module (NLP).

[1110] How it works: The server uses NLP libraries like TensorFlow and spaCy to analyze the input requirements text and extract key keywords and context. For example, it extracts keywords like "urgent," "fastest," and "smartphone."

[1111] Input: The requirement text entered.

[1112] Output: Extracted keywords and context information.

[1113] Step 3:

[1114] The server uses an emotion engine to recognize the user's emotional state.

[1115] Specific operation: The server uses emotion analysis tools such as "Affectiva" and "IBM Watson Tone Analyzer" to analyze the emotional state of the input text, such as "urgent" or "relaxed." For example, it recognizes the emotional state of "urgent" from the expression "in a hurry."

[1116] Input: The requirement text entered.

[1117] Output: Perceived emotional state (e.g., "urgent").

[1118] Step 4:

[1119] The server uses a requirements analysis module to identify the required functionality.

[1120] Specific operation: Based on the information analyzed by the NLP module and emotion engine, the server's requirements analysis module identifies the functions that meet the user's needs. For example, since the emotional state is urgent, the server selects the function to display products for fastest delivery.

[1121] Input: extracted keywords and recognized emotional states.

[1122] Output: Identified features (e.g., display items with fastest shipping).

[1123] Step 5:

[1124] The server uses a program generation module to generate code for the application based on the identified functionality.

[1125] How it works: The server uses generative AI models such as OpenAI GPT-3 and Codex to automatically generate appropriate code based on the functions identified through requirements analysis. For example, it generates code to display the products that can be delivered the fastest.

[1126] Input: Identified feature information.

[1127] Output: The generated application code.

[1128] Step 6:

[1129] The server adjusts the generated code and interface based on the emotional state.

[1130] Specific behavior: The server adjusts the interface and functions of the generated application according to the recognized emotional state. For example, in an emergency, it adjusts the layout to prioritize important information.

[1131] Input: Generated application code and recognized emotional state.

[1132] Output: Adjusted application code and interfaces.

[1133] Step 7:

[1134] The server ultimately deploys the code to an application development platform.

[1135] What it does: The server uses an application development platform such as Kony to deploy the generated and tailored code and put the application into production.

[1136] Input: The adjusted application code.

[1137] Output: The deployed application.

[1138] Step 8:

[1139] A user accesses the deployed application and utilizes the functionality provided.

[1140] Specific operation: The user accesses the deployed application from a web browser or mobile app and performs operations such as searching and displaying the fastest available smartphone.

[1141] Input: User interaction with deployed application.

[1142] Output: Providing the information or functionality the user requests.

[1143] The specific processing unit 290 transmits the result of the specific processing to the headset type terminal 314. In the headset type terminal 314, the control unit 46A causes the speaker 240 and the display 343 to output the result of the specific processing. The microphone 238 acquires audio indicating a user input regarding the result of the specific processing. The control unit 46A transmits audio data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the audio data.

[1144] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1145] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the headset type terminal 314.

[1146] [Fourth embodiment]

[1147] FIG. 7 shows an example of the configuration of a data processing system 410 according to the fourth embodiment.

[1148] 7, a data processing system 410 includes a data processing device 12 and a robot 414. An example of the data processing device 12 is a server.

[1149] The data processing device 12 includes a computer 22, a database 24, and a communication I / F 26. The computer 22 is an example of a "computer" according to the technology of the present disclosure. The computer 22 includes a processor 28, a RAM 30, and a storage 32. The processor 28, the RAM 30, and the storage 32 are connected to a bus 34. The database 24 and the communication I / F 26 are also connected to the bus 34. The communication I / F 26 is connected to a network 54. Examples of the network 54 include a WAN (Wide Area Network) and / or a LAN (Local Area Network).

[1150] The robot 414 includes a computer 36, a microphone 238, a speaker 240, a camera 42, a communication I / F 44, and a control target 443. The computer 36 includes a processor 46, a RAM 48, and a storage 50. The processor 46, the RAM 48, and the storage 50 are connected to a bus 52. The microphone 238, the speaker 240, the camera 42, and the control target 443 are also connected to the bus 52.

[1151] The microphone 238 receives instructions and the like from the user 20 by receiving voice uttered by the user 20. The microphone 238 captures the voice uttered by the user 20, converts the captured voice into audio data, and outputs it to the processor 46. The speaker 240 outputs audio in accordance with instructions from the processor 46.

[1152] Camera 42 is a small digital camera equipped with an optical system including a lens, aperture, and shutter, and an imaging element such as a CMOS (Complementary Metal-Oxide-Semiconductor) image sensor or a CCD (Charge Coupled Device) image sensor, and captures images of the surroundings of user 20 (for example, an imaging range defined by an angle of view equivalent to the field of vision of a typical healthy person).

[1153] The communication I / F 44 is connected to a network 54. The communication I / Fs 44 and 26 are responsible for the exchange of various information between the processor 46 and the processor 28 via the network 54. The exchange of various information between the processor 46 and the processor 28 using the communication I / Fs 44 and 26 is carried out in a secure state.

[1154] The control object 443 includes a display device, LEDs in the eyes, and motors for driving the arms, hands, and feet. The posture and gestures of the robot 414 are controlled by controlling the motors of the arms, hands, and feet. Some of the emotions of the robot 414 can be expressed by controlling these motors. In addition, the facial expressions of the robot 414 can also be expressed by controlling the light emission state of the LEDs in the eyes of the robot 414.

[1155] Fig. 8 shows an example of the main functions of the data processing device 12 and the robot 414. As shown in Fig. 8, in the data processing device 12, a specific process is performed by the processor 28. A specific process program 56 is stored in the storage 32.

[1156] The specific processing program 56 is an example of a "program" according to the technology of the present disclosure. The processor 28 reads the specific processing program 56 from the storage 32 and executes the read specific processing program 56 on the RAM 30. The specific processing is realized by the processor 28 operating as a specific processing unit 290 in accordance with the specific processing program 56 executed on the RAM 30.

[1157] The storage 32 stores a data generation model 58 and an emotion identification model 59. The data generation model 58 and the emotion identification model 59 are used by the identification processing unit 290.

[1158] In the robot 414, the processor 46 performs the reception output process. A reception output program 60 is stored in the storage 50. The processor 46 reads the reception output program 60 from the storage 50 and executes the read reception output program 60 on the RAM 48. The reception output process is realized by the processor 46 operating as the control unit 46A in accordance with the reception output program 60 executed on the RAM 48.

[1159] Next, a description will be given of the specific processing performed by the specific processing unit 290 of the data processing device 12. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1160] The system of the present invention analyzes application requirements entered by users in natural language, automatically generates code based on specific functions, and deploys it on an application development platform, allowing users to create customized in-house applications without requiring programming knowledge.

[1161] Specific explanation of program processing

[1162] 1. Enter your requirements

[1163] User: Enters application requirements in natural language using a web interface or application. For example, a user might enter a requirement like "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[1164] 2. Natural Language Analysis

[1165] Server: A Natural Language Processing (NLP) module analyzes the input requirements. This module segments the text, extracts key keywords and context, and understands the requirements.

[1166] For example, the NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[1167] 3. Identifying Requirements

[1168] Server: The requirements analysis module identifies the required features based on the information sent from the NLP module. Based on the extracted requirements, this module determines the feature set required for the application.

[1169] For example, CRUD operations (Create, Read, Update, Delete) and expiration functions are specified.

[1170] 4. Code Generation

[1171] Server: The program generation module generates the code for the application based on the identified functions. For each determined function, this module generates the appropriate code block.

[1172] For example, code is generated for a task add button, a task list view, task edit / delete functions, a deadline setting form, etc.

[1173] 5. Deploying your code

[1174] Server: The Kony platform integration module integrates the generated code into the application development platform and executes the deployment, which makes the application ready for production.

[1175] Specific examples

[1176] Let's say a user types, "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[1177] 1. User: Enters requirements in natural language.

[1178] 2. Server: The NLP module extracts keywords such as "project," "task," "progress," and "deadline."

[1179] 3. Server: The requirements analysis module identifies the required functionality (CRUD operations, progress update functionality, deadline setting).

[1180] 4. Server: The program generation module generates code corresponding to each function.

[1181] 5. Server: Deploys the generated code using the Kony platform integration module and publishes the application.

[1182] This process allows users to automatically create and deploy applications based on requirements entered in natural language.

[1183] The processing flow will be explained below.

[1184] Step 1:

[1185] User: Accesses a web interface and enters application requirements in natural language, for example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[1186] Step 2:

[1187] Server: The Natural Language Processing (NLP) module receives the input text and begins analyzing it. It uses word segmentation and grammar analysis to extract key keywords (such as "project," "task," "progress," and "deadline") and understand contextual relationships.

[1188] Step 3:

[1189] Server: The NLP module sends the extracted keywords and context information to the requirements analysis module, which identifies the required features based on the extracted keywords.

[1190] Step 4:

[1191] Server: The requirements analysis module clarifies the identified feature set and plans the overall application structure, including specific features such as CRUD operations (create, read, update, delete) and task progress tracking and deadline setting.

[1192] Step 5:

[1193] Server: The program generation module generates the necessary code based on the information provided by the requirements analysis module. Code generation combines the corresponding code blocks for each function (CRUD operations, progress management, deadline setting).

[1194] Step 6:

[1195] Server: The code generated by the program generation module is sent to the Kony Platform integration module, which uploads the generated code to the appropriate location on the Kony Platform.

[1196] Step 7:

[1197] Server: The Kony platform integration module deploys the application based on the uploaded code and makes it executable, so that the application can be used by real users.

[1198] Step 8:

[1199] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, and set deadlines.

[1200] In this way, the system automatically analyzes requirements entered by the user in natural language, generates code, and deploys the application.

[1201] Example 1

[1202] Next, a description will be given of Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1203] Conventional application development requires experts with programming knowledge, making it difficult for users without technical knowledge to create applications on their own. It is also difficult to accurately incorporate and quickly reflect user requirements. For these reasons, there is a demand for application development methods that are efficient in terms of both time and cost.

[1204] The specific processing by the specific processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means.

[1205] In this invention, the server includes means for inputting requirements written in natural language by a user, means for extracting requirements by analyzing the natural language, means for identifying necessary functions based on the extracted requirements, means for generating application code based on the identified functions, and means for linking the generated code to an application development platform and deploying it. This enables users, even without programming knowledge, to create customized applications based on their specific requirements in a short period of time and have them immediately operational.

[1206] A "user" is an entity that uses the system to input requirements in natural language.

[1207] "Natural language" refers to a language used by humans on a daily basis, and is a language form that does not include program code or special notation.

[1208] "Requirements" are applications functions and characteristics that a user desires from a system, expressed in natural language.

[1209] "Parsing" refers to the process of converting input natural language requirements into a form that the system can understand.

[1210] "Keywords" are key words extracted from natural language requirements and are the basis for a system to understand the requirements.

[1211] "Context" refers to the context or background information in a natural language requirement, used to clarify the meaning of a keyword.

[1212] "Function" refers to the specific operations or behaviors provided by an application, and is specified based on the requirements desired by the user.

[1213] "Code" is a set of instructions written in a programming language that implements the behavior of an application.

[1214] "Application Development Platform" means a software tool or environment for building, managing, and deploying applications based on generated code.

[1215] "Deployment" refers to the process of placing the generated code on an application development platform and making it executable.

[1216] The system of the present invention analyzes application requirements entered by the user in natural language, automatically generates code based on the requirements, and deploys it on an application development platform. This system consists of three main components: the user, the terminal, and the server.

[1217] Hardware and software used

[1218] Hardware: Servers and devices used by users (PCs, smartphones, etc.).

[1219] software:

[1220] Natural Language Processing Module (NLP Module)

[1221] Requirement Analysis Module

[1222] Program Generation Module

[1223] Application development platform linkage module

[1224] Application development platform (e.g., general-purpose application development platform)

[1225] Specific explanation of the process

[1226] Entering requirements

[1227] Using a web interface or application, a user enters their application requirements in natural language, for example, "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[1228] Natural Language Analysis

[1229] The server parses the input requirements using a natural language processing (NLP) module. This module understands the requirements by segmenting the text and extracting key keywords and context. For example, the NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[1230] Identifying requirements

[1231] The server uses a requirements analysis module to identify the required functionality based on the information sent by the NLP module, for example, CRUD operations (Create, Read, Update, Delete) and deadline setting functionality.

[1232] Code generation

[1233] The server uses a program generation module to generate application code based on the specified features, such as an add task button, a task list view, task edit and delete functions, a deadline setting form, etc.

[1234] Deploying your code

[1235] The server integrates the generated code into the application development platform using the application development platform integration module and executes deployment, which makes the application ready for actual operation.

[1236] Specific examples

[1237] Here is a concrete example:

[1238] A user types, "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[1239] 1. User: Enters requirements in natural language into a web interface.

[1240] 2. Server: The NLP module extracts keywords such as "project," "task," "progress," and "deadline."

[1241] 3. Server: The requirements analysis module identifies the required functionality (CRUD operations, progress update functionality, deadline setting).

[1242] 4. Server: The program generation module generates code corresponding to each function.

[1243] 5. Server: Deploys the generated code using the application development platform integration module and publishes the application.

[1244] Prompt Sentence Examples

[1245] "I want to build a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[1246] "I want an app that lets employees share project progress. I want the ability to add tasks to projects, update their progress, and set deadlines."

[1247] The flow of the identification process in the first embodiment will be described with reference to FIG.

[1248] Step 1: Entering requirements

[1249] A user opens a web interface or application and enters the application requirements in natural language.

[1250] Input: A user enters requirements such as "I want to create a task management app. I want users to be able to add, delete, and edit tasks. I want tasks to have due dates."

[1251] Output: User requirements become text data that is input into the system.

[1252] Specific behavior: The user enters their requirements into the text field and clicks the "Submit" button.

[1253] Step 2: Parsing natural language

[1254] The server receives the requirements sent from the terminal and activates a natural language processing (NLP) module.

[1255] Input: The text data of the requirement entered by the user.

[1256] Data processing: The NLP module segments the text and extracts key keywords and context.

[1257] Output: Parsed keywords and context information.

[1258] What it does: The NLP module extracts keywords such as "task management," "add," "delete," "edit," and "deadline."

[1259] Step 3: Identify requirements

[1260] The server uses a requirements analysis module to identify the required functionality based on the information sent from the NLP module.

[1261] Input: Parsed keywords and context information.

[1262] Data calculation: The requirements analysis module maps the keywords to corresponding standard functions (CRUD operations, deadline setting).

[1263] Output: Identification of the required feature set.

[1264] Specific behavior: The requirements analysis module identifies CRUD operations (Create, Read, Update, Delete) and deadline setting functions.

[1265] Step 4: Generate code

[1266] The server uses a program generation module to generate code for the application based on the specified functions.

[1267] Input: The identified feature set.

[1268] Data processing: The program generation module generates the appropriate code block for each function.

[1269] Output: The source code of the application.

[1270] Specific operation: The program generation module creates code for the task addition button, task list view, task edit / delete function, deadline setting form, etc.

[1271] Step 5: Deploy your code

[1272] The server integrates the generated code using the application development platform cooperation module into the application development platform and deploys it.

[1273] Input: The source code of the generated application.

[1274] Data processing: The linking module compiles the code and applies it to the platform.

[1275] Output: A working application.

[1276] What happens: The server uploads the code to the application development platform, applies the configuration, and publishes the application.

[1277] (Application example 1)

[1278] Next, a description will be given of Application Example 1. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1279] Task management in conventional logistics centers is often done manually, resulting in a lack of efficiency and accuracy. Furthermore, it is difficult to share task progress in real time and manage deadlines. Therefore, there is a need to provide an effective task management method and improve the operational efficiency of logistics centers.

[1280] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 1 is realized by the following means.

[1281] In this invention, the server includes: means for inputting requirements written in natural language by a user; means for analyzing the natural language to extract requirements; means for identifying necessary functions based on the extracted requirements; means for generating application code based on the identified functions; means for linking the generated code to an application development platform; and means for identifying a task management application for managing the operation of a logistics center. This enables logistics staff to add, edit, and delete tasks and track their progress in real time. It also makes it easy to set deadlines for tasks and share progress, significantly improving the operational efficiency of the logistics center.

[1282] A "user" is a person who utilizes the system to input application requirements in natural language.

[1283] A "natural language" is a language that humans use on a daily basis, and is different from a programming language.

[1284] "Requirements" refers to the functions and specifications required for an application that are input by the user in natural language.

[1285] "Parsing" is the process of interpreting requirements entered in natural language and extracting specific keywords and context.

[1286] A "feature" refers to a specific set of operations or behaviors implemented in an application.

[1287] "Code" is a collection of instructions and rules for writing a program that defines the behavior of an application.

[1288] An "application development platform" is the underlying software or environment for executing generated code and running it as an application.

[1289] "Integration" is the process of integrating the generated code into an application development platform and deploying it as a working application.

[1290] A logistics center is a facility that receives, stores, and ships goods, and is a place that requires efficient operational management.

[1291] A "task management application" is software that supports the operation and management of a logistics center, and provides functions such as adding, editing, deleting, and managing progress of tasks.

[1292] This invention is a system that automatically generates a task management application for managing the operation of a logistics center based on requirements entered by a user in natural language.

[1293] The system of the present invention includes the following major components:

[1294] 1. User terminal: Enter application requirements in natural language through a web interface or mobile application.

[1295] 2. Server: Analyzes natural language, identifies required functionality, generates application code, and integrates that code with the application development platform.

[1296] Program operation and description of the hardware and software used

[1297] Natural Language Input and Analysis

[1298] User device: Using a smartphone or computer, the user enters their requirements in natural language.

[1299] Server: Analyzes the text using a natural language processing (NLP) module. This NLP module includes functions to extract key keywords and context. The specific software used is a Python natural language processing library (e.g., NLTK, SpaCy).

[1300] Requirements Identification and Code Generation

[1301] Server: The requirements analysis module identifies the required functionality based on the information sent from the NLP module. For example, it identifies functions such as database operations (CRUD), progress updates, and deadline settings. Next, the program generation module creates the code based on these identified functions. Specifically, it generates code in Python or JavaScript.

[1302] Deploying your code

[1303] Server: The generated code is integrated into the application development platform and deployed. Here, deployment is performed using Flask (a Python micro web framework) and MongoDB.

[1304] Specific examples

[1305] When inputting requirements for a task management application to support the operation of a logistics center, the following can be entered in natural language: "I want to create an app that can add new inventory check tasks and update their progress. I want the app to set deadlines for tasks and issue alerts when tasks pass their deadlines." Based on this natural language input, the NLP module extracts keywords such as "inventory check," "progress," "deadline," and "alert," and uses these to identify the required functions.

[1306] Prompt Sentence Examples

[1307] "I want to create an app that allows users to add new inventory check tasks and update their progress. I want tasks to have deadlines and be alerted when tasks are past their deadline."

[1308] In this way, the system of the present invention can automatically generate task management applications that significantly improve the operational efficiency of a logistics center.

[1309] The flow of the specific processing in the application example 1 will be described with reference to FIG.

[1310] Step 1:

[1311] Users enter requirements in natural language

[1312] Users use their smartphones or computers to input requirements in natural language through a web interface or mobile application, along with prompts such as, "I want to create an app that allows logistics staff to add tasks and update their progress. I want tasks to have deadlines and be alerted when a task is past its deadline."

[1313] Input: Natural Language Requirements

[1314] Output: Natural language text data

[1315] Step 2:

[1316] The server analyzes natural language

[1317] The server uses a natural language processing (NLP) module to parse the requirements entered by the user. It uses a Python natural language processing library (NLTK, SpaCy, etc.) to extract key keywords and context from the text data. For example, keywords such as "task management," "add," "delete," "edit," and "deadline" are extracted.

[1318] Input: Natural language text data

[1319] Output: Extracted keywords and context data

[1320] Step 3:

[1321] The server identifies the required functionality based on the requirements

[1322] The server's requirements analysis module identifies required functionality based on keywords and contextual data obtained from the NLP module, such as database operations (CRUD operations), deadline setting functionality, and progress updates.

[1323] Input: Extracted keywords and context data

[1324] Output: Required feature set

[1325] Step 4:

[1326] The server generates the application code

[1327] The server's program generation module generates application code based on the identified functionality, using Python, JavaScript, or other programming languages ​​to generate code blocks for each functionality (e.g., task addition, edit, delete, progress display, deadline setting form, etc.).

[1328] Input: desired feature set

[1329] Output: Generated application code

[1330] Step 5:

[1331] The server integrates and deploys the generated code to the application development platform.

[1332] The server's deployment module automatically deploys the generated code to an application development platform (e.g., a platform using Flask or MongoDB), and the code is deployed as a working application.

[1333] Input: Generated application code

[1334] Output: Deployed application

[1335] Through this step-by-step process, a system is realized in which a task management application that supports the operation of a logistics center is automatically generated and deployed based on requirements entered by the user in natural language.

[1336] Furthermore, an emotion engine that estimates the user's emotion may be further combined. That is, the identification processing unit 290 may estimate the user's emotion using the emotion identification model 59, and perform identification processing using the user's emotion.

[1337] The system of the present invention analyzes application requirements entered by the user in natural language, identifies the necessary functions, generates code, and deploys it in conjunction with an application development platform. Furthermore, it combines an emotion engine that recognizes the user's emotions and adjusts the application's functions and interface based on the user's emotional state, providing a more user-friendly experience.

[1338] Specific explanation of program processing

[1339] 1. Enter your requirements

[1340] Users: Enter their application requirements in natural language through a web interface or application, for example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[1341] 2. Natural Language Analysis

[1342] Server: The Natural Language Processing (NLP) module receives and analyzes the input text. This module segments the text and extracts key keywords and context. At the same time, the emotion engine analyzes the text to recognize the user's emotions.

[1343] 3. Emotional Recognition

[1344] Server: The emotion engine analyzes the user's emotional state from natural language input. For example, if the user uses an expression such as "I'm in a hurry," the emotion engine recognizes the emotional state as "urgent."

[1345] 4. Identifying Requirements

[1346] Server: Sends the analysis results of the NLP module and the emotion engine to the requirements analysis module to identify the required features, taking into account the information from the emotion engine to determine the feature set that best suits the user's needs.

[1347] 5. Code Generation

[1348] Server: The program generation module generates the necessary code based on the information provided by the requirements analysis module. This generated code corresponds to specific functions (e.g., CRUD operations, progress management, deadline setting).

[1349] 6. Emotion-Based Regulation

[1350] Server: Based on the information obtained from the emotion engine, the server adjusts the application functions and interface according to the user's emotional state. For example, if the user is in an "urgent" state, the server adjusts the user interface to prioritize important tasks.

[1351] 7. Deploying your code

[1352] Server: The Kony platform integration module integrates the generated code into the application development platform and executes the deployment, making the application ready for production.

[1353] 8. User Usage

[1354] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. Furthermore, the emotion engine provides appropriate feedback and interfaces based on the user's emotional state.

[1355] In this way, the system can provide user-friendly applications by analyzing requirements entered by the user in natural language, combining an emotion engine, generating code, and deploying the application.

[1356] The processing flow will be explained below.

[1357] Step 1:

[1358] User: Accesses a web interface and enters their application requirements in natural language, such as "I want an app that allows employees to share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[1359] Step 2:

[1360] Server: The Natural Language Processing (NLP) module receives the user input and starts text analysis, segmenting the text and extracting key keywords (e.g., "project," "task," "progress," "deadline") and contextual relationships.

[1361] Step 3:

[1362] Server: The emotion engine analyzes the user's input text and recognizes the emotional state. For example, if the text contains the expression "hurrying," the emotion engine recognizes the emotional state as "urgent."

[1363] Step 4:

[1364] Server: Sends the analysis results of the NLP module and emotion engine to the requirements analysis module, which identifies the required function set (CRUD operations, progress management, deadline setting) based on the extracted keywords and emotion information.

[1365] Step 5:

[1366] Server: The program generation module generates the corresponding code blocks based on the information sent from the requirements analysis module. For example, it builds the code including the functions to add, edit, and delete tasks and the deadline setting function.

[1367] Step 6:

[1368] Server: Using the emotional information obtained from the emotion engine, the application's functions and interface are adjusted based on the user's emotional state. For example, if the emotional state is "urgent," important tasks are displayed at the top and the user interface is simplified.

[1369] Step 7:

[1370] Server: The Kony platform integration module uploads the generated code to the application development platform and executes the deployment, while simultaneously configuring and building the necessary runtime environment and dependencies.

[1371] Step 8:

[1372] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. Furthermore, they are provided with feedback and an interface that is tailored to their emotional state.

[1373] In this way, the system can automatically analyze, generate code, and deploy the optimal application based on the requirements entered by the user in natural language and their emotional state at the time.

[1374] Example 2

[1375] Next, a description will be given of Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1376] Conventional application development systems often suffer from misunderstandings when users communicate their specific requirements to engineers, and are unable to respond quickly. Furthermore, they are unable to adjust the application interface or functionality to take the user's emotional state into account, resulting in a suboptimal user experience. Therefore, there is a need for an application development system that is intuitive, easy to use, and customizable according to the user's emotional state.

[1377] The specification process by the specification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes: means for inputting requirements written in natural language by a user; means for extracting requirements by analyzing the natural language; means for recognizing the user's emotional state from the natural language input; means for identifying required functions based on the extracted requirements and the emotional state; means for generating application code based on the identified functions; means for linking the generated code to an application development platform; and means for adjusting the application functions and interface based on the emotional state. This makes it possible to accurately grasp specific user requirements and quickly develop and deploy applications that can be customized to adapt to the emotional state.

[1378] A "user" is a person or entity that utilizes the system to input application requirements in natural language.

[1379] "Natural language" refers to everyday human language that allows users to interact with systems without requiring specific programming languages ​​or coding skills.

[1380] "Requirements" are natural language descriptions of the functions and objectives that a user requires from an application.

[1381] "Emotional state" refers to the user's psychological and emotional state, and is information parsed from the natural language input by the user.

[1382] A "function" refers to a specific operation or set of operations provided by an application, such as adding a task, updating progress, setting a deadline, and so on.

[1383] "Code" is the set of instructions that make up a computer program, written to perform a particular function.

[1384] An "application development platform" is a platform used for software development and deployment that provides the developed code in a working form.

[1385] "Means" refer to the methods or techniques used to achieve a specific function or purpose.

[1386] "Parsing" is the process of breaking down input natural language requirements and emotional states and extracting meaning and information from them.

[1387] "Extraction" is the process of extracting important information and requirements from input natural language or data.

[1388] "Identification" refers to clarifying the required application functionality based on the extracted information and emotional state.

[1389] "Integration" is the process of integrating the generated code into the application development infrastructure so that the functionality can work.

[1390] "Adjustment" refers to optimizing an application's functionality and interface according to the user's emotional state.

[1391] "Customization" refers to changing the settings and functionality of a system or application according to a user's specific requirements or emotional state.

[1392] The present invention relates to a system that allows a user to input application requirements in natural language, analyzes the input, and generates and deploys application code. Furthermore, the system can recognize the user's emotional state and adjust the application's functionality and interface accordingly. Specific embodiments for implementing the present invention are described below.

[1393] Overview of program processing

[1394] Hardware and Software

[1395] Server: A server for managing and executing the entire process.

[1396] Terminal: A device that runs a web interface or application through which a user can enter requirements and access the application.

[1397] Natural language processing module: Uses the Python nltk library.

[1398] Sentiment engine: Uses Microsoft Azure's Text Analytics API.

[1399] Program generation module: Uses OpenAI's Codex API.

[1400] Application development infrastructure: Uses a common CI / CD pipeline.

[1401] User actions

[1402] Requirements input: Users input their requirements in natural language through a web interface or application, for example, "I want an app that allows employees to share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[1403] Processing performed by the server

[1404] Natural language analysis: The server uses a natural language processing module to analyze the input text and extract key keywords and context. Specifically, it divides the text into sentences and identifies requirements such as "project," "add task," "update progress," and "set deadline."

[1405] Emotion recognition: The emotion engine running on the server analyzes the user's emotional state from the input text. For example, if the user writes "I'm in a hurry," the emotion engine will recognize this as "urgent" and tag it.

[1406] Requirements Identification and Code Generation: Based on the identified requirements and emotional state, the server uses a program generation module to generate the necessary application code, including an API that enables CRUD operations and a front-end React component.

[1407] Emotion-based adjustment: The server adjusts the application interface and functionality based on the information from the emotion engine. For example, if the state is "urgent," it changes the user interface to highlight important tasks. This is done using React's state management.

[1408] Code deployment: Finally, the server deploys the generated code to the application development platform. Specifically, the code is pushed to a Git repository and automatically deployed to the production environment through a CI / CD pipeline.

[1409] Specific examples

[1410] The user prompts the system with the following:

[1411] I need an app that allows employees to share project progress. I need the ability to add tasks to projects, update progress, and set deadlines. I'm also in a rush, so something that works quickly is helpful.

[1412] In response to this prompt, the system generates, adapts, and deploys the desired application, making it immediately available to the user.

[1413] Although the specific embodiments for carrying out the present invention have been described above, the present invention is not limited to these, and various modifications and improvements can be made thereto.

[1414] The flow of the identification process in the second embodiment will be described with reference to FIG.

[1415] Step 1: Entering requirements

[1416] User: Enters application requirements in natural language through a web interface or application. For example, "I want an app that lets employees share project progress. I need the ability to add tasks to projects, update their progress, and set deadlines."

[1417] Input: The user's natural language requirements.

[1418] Output: The input natural language text.

[1419] Step 2: Parsing natural language

[1420] Server: Analyzes the user's input text using the Natural Language Processing (NLP) module. It uses the Python nltk library to split the text into sentences and extract key keywords and context.

[1421] Input: Natural language text entered by the user.

[1422] Output: A list of key keywords and feature requirements (e.g. "project management", "add tasks", "update progress", "set deadlines").

[1423] Step 3: Recognize emotions

[1424] Server: Analyzes the user's emotional state from the text input using the emotion engine. It uses Microsoft Azure's Text Analytics API to generate emotion tags (e.g., "urgency," "expectation," "confusion," etc.).

[1425] Input: Natural language text entered by the user.

[1426] Output: User's emotional state (e.g., "urgent").

[1427] Step 4: Identify requirements

[1428] Server: The requirements analysis module receives the functional requirements list from the NLP module and the emotional state information from the emotion engine, and identifies specific application functions. For example, it determines that functions such as "add task," "update progress," and "set deadline" are required.

[1429] Input: Functional requirements list and emotional state information.

[1430] Output: A list of required application features.

[1431] Step 5: Generate Code

[1432] Server: Uses the program generation module to generate code based on the identified application functionality. Uses OpenAI's Codex API to generate APIs and React components with CRUD operations.

[1433] Input: A list of required application features.

[1434] Output: The generated application code.

[1435] Step 6: Emotional Adjustment

[1436] Server: Based on the information from the emotion engine, the interface and functionality of the generated application are adjusted to match the user's emotional state. For example, in an "urgent" state, the interface and functionality are adjusted to prioritize important tasks.

[1437] Input: Generated application code and emotional state information.

[1438] Output: Application code adapted to the user's emotional state.

[1439] Step 7: Deploy your code

[1440] Server: The generated application code is integrated into the application development platform and deployed. The code is pushed to a Git repository and deployed to the production environment through a CI / CD pipeline.

[1441] Input: Application code adapted to the user's emotional state.

[1442] Output: The deployed application.

[1443] Step 8: User Adoption

[1444] Users: Receive notifications when deployment is complete and access the generated application. Users can share project progress, add new tasks, update progress, set deadlines, and more. The emotion engine also provides appropriate feedback and interfaces.

[1445] Input: Access to deployed applications.

[1446] Output: The application usage and user operation results.

[1447] (Application example 2)

[1448] Next, a description will be given of Application Example 2. In the following description, the data processing device 12 will be referred to as a "server" and the robot 414 will be referred to as a "terminal."

[1449] Traditional application development methods require users to define specific requirements and functions in detail and then incorporate them into the code, requiring advanced programming skills. It is also difficult to provide interface adjustments and functions that take into account the user's emotions and urgency. This results in poor usability and makes it difficult for users to quickly obtain applications that meet their needs.

[1450] The specific processing by the specific processing unit 290 of the data processing device 12 in the application example 2 is realized by the following means.

[1451] In this invention, the server includes means for inputting requirements written in natural language by the user, means for extracting requirements by analyzing the natural language, and means for identifying necessary functions based on the extracted requirements, thereby enabling automatic generation of an application based on simple requests input in natural language by the user.

[1452] The server further includes means for generating application code based on the identified functions, means for linking the generated code to an application development platform, means for analyzing the user's emotional state, and means for adjusting the application's functions and interface based on the emotional state, thereby enabling the provision of an optimal application taking into account the user's emotions and urgency, thereby improving the user experience.

[1453] "Natural language" refers to the words and expressions people use in their daily lives, rather than technical or code language.

[1454] "Requirements" are the specific conditions and requirements for the functions and performance that users expect from an application.

[1455] "Analysis" is the process of deciphering input data or information and clarifying its meaning and content.

[1456] "Emotional state" refers to the mental state a user is feeling at a particular moment, and may include, for example, happiness, sadness, impatience, etc.

[1457] "Function" refers to a specific operation or capability of an application, and refers to a series of operations that a user desires.

[1458] "Code" is the set of instructions or statements that make up a program, written in a form that a computer can understand and execute.

[1459] "Application Development Platform" means a combination of software and hardware to support the development, deployment, and operation of applications.

[1460] An "interface" is a point of contact or means through which a user and an application interact with each other, and is also called a user interface (UI).

[1461] "Identifying" means clearly identifying an object and defining its properties and characteristics.

[1462] "Collaboration" means that multiple systems and modules work together, sharing information and data to function.

[1463] "Adjust" means to change the settings or behavior of a system or component to suit specific conditions or circumstances.

[1464] The following system configuration is conceivable as an embodiment for carrying out the present invention: The system is composed of a server, a user terminal, and an application development platform.

[1465] The server first provides a means for users to input their requirements written in natural language, for example through a text input field in a web interface or mobile application, which may include prompts such as "I'm in a hurry and want a smartphone that arrives as quickly as possible."

[1466] Next, the server analyzes the input text using a natural language analysis module. At this stage, key keywords and context are extracted. Natural language processing (NLP) techniques are used for the analysis. Commonly used NLP libraries such as "TensorFlow" and "spaCy" are used for the NLP techniques.

[1467] In parallel, the server uses an emotion engine to recognize the user's emotional state. Suitable emotion engines include Affectiva and IBM Watson Tone Analyzer. For example, it can recognize the emotional state of "urgent" from the expression "I'm in a hurry."

[1468] Based on the analysis results, the server uses the requirements analysis module to identify necessary functions, such as task management, progress display, and deadline setting. Based on this information, the program generation module automatically generates code. Generative AI models such as OpenAI GPT-3 and Codex are used for code generation.

[1469] The server then adjusts the generated code and interface based on the user's emotional state, dynamically changing the user interface depending on the user's emotional state. For example, in an "emergency" situation, the interface adjusts to bring important information and actions to the forefront.

[1470] Finally, the server deploys the generated code using an application development platform such as Kony, and the actual application is put into production, allowing users to access the developed application and use its various functions.

[1471] Specific examples

[1472] For example, if a user inputs "I'm in a hurry, so I want a smartphone that can be delivered as quickly as possible," the server will analyze this input, recognize the emotional state of "urgency" from the expression "in a hurry," search for smartphones that can be delivered as quickly as possible, and display them as a priority.

[1473] Example prompt sentence:

[1474] "I'm in a hurry, so I want the fastest possible smartphone."

[1475] In this way, the system can easily provide applications that accurately reflect the user's requirements and emotional state.

[1476] The flow of the specific processing in the application example 2 will be described with reference to FIG.

[1477] Step 1:

[1478] The user enters requirements written in natural language.

[1479] What it does: A user uses a web interface or a mobile application to enter their desired product and requirements in natural language using a text input field, for example, "I'm in a hurry and want a smartphone that arrives as quickly as possible."

[1480] Input: User's natural language text.

[1481] Output: The requirement text entered.

[1482] Step 2:

[1483] The server analyzes the text using a natural language processing module (NLP).

[1484] How it works: The server uses NLP libraries like TensorFlow and spaCy to analyze the input requirements text and extract key keywords and context. For example, it extracts keywords like "urgent," "fastest," and "smartphone."

[1485] Input: The requirement text entered.

[1486] Output: Extracted keywords and context information.

[1487] Step 3:

[1488] The server uses an emotion engine to recognize the user's emotional state.

[1489] Specific operation: The server uses emotion analysis tools such as "Affectiva" and "IBM Watson Tone Analyzer" to analyze the emotional state of the input text, such as "urgent" or "relaxed." For example, it recognizes the emotional state of "urgent" from the expression "in a hurry."

[1490] Input: The requirement text entered.

[1491] Output: Perceived emotional state (e.g., "urgent").

[1492] Step 4:

[1493] The server uses a requirements analysis module to identify the required functionality.

[1494] Specific operation: Based on the information analyzed by the NLP module and emotion engine, the server's requirements analysis module identifies the functions that meet the user's needs. For example, since the emotional state is urgent, the server selects the function to display products for fastest delivery.

[1495] Input: extracted keywords and recognized emotional states.

[1496] Output: Identified features (e.g., display items with fastest shipping).

[1497] Step 5:

[1498] The server uses a program generation module to generate code for the application based on the identified functionality.

[1499] How it works: The server uses generative AI models such as OpenAI GPT-3 and Codex to automatically generate appropriate code based on the functions identified through requirements analysis. For example, it generates code to display the products that can be delivered the fastest.

[1500] Input: Identified feature information.

[1501] Output: The generated application code.

[1502] Step 6:

[1503] The server adjusts the generated code and interface based on the emotional state.

[1504] Specific behavior: The server adjusts the interface and functions of the generated application according to the recognized emotional state. For example, in an emergency, it adjusts the layout to prioritize important information.

[1505] Input: Generated application code and recognized emotional state.

[1506] Output: Adjusted application code and interfaces.

[1507] Step 7:

[1508] The server ultimately deploys the code to an application development platform.

[1509] What it does: The server uses an application development platform such as Kony to deploy the generated and tailored code and put the application into production.

[1510] Input: The adjusted application code.

[1511] Output: The deployed application.

[1512] Step 8:

[1513] A user accesses the deployed application and utilizes the functionality provided.

[1514] Specific operation: The user accesses the deployed application from a web browser or mobile app and performs operations such as searching and displaying the fastest available smartphone.

[1515] Input: User interaction with deployed application.

[1516] Output: Providing the information or functionality the user requests.

[1517] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

[1518] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (Internet Search<URL: https: / / openai.com / blog / chatgpt> ), Gemini (Internet search <url: https: gemini.google.com ?hl="ja">) and other generation AIs. The data generation model 58 is obtained by performing deep learning on a neural network. A prompt including an instruction is input to the data generation model 58, and inference data such as voice data indicating voice, text data indicating text, and image data indicating an image is also input. The data generation model 58 performs inference on the input inference data in accordance with the instruction indicated by the prompt, and outputs the inference result in a data format such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1519] In the above embodiment, an example was given in which the specific processing is performed by the data processing device 12, but the technology of the present disclosure is not limited to this, and the specific processing may be performed by the robot 414.

[1520] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1521] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1522] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1523] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1524] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1525] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1526] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1527] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1528] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1529] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1530] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1531] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1532] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1533] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1534] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1535] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1536] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1537] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1538] The following is further disclosed regarding the above embodiment.

[1539] (Claim 1)

[1540] a means for a user to input requirements written in natural language;

[1541] means for analyzing the natural language and extracting requirements;

[1542] A means for identifying necessary functions based on the extracted requirements;

[1543] means for generating code for an application based on the identified functions;

[1544] means for associating the generated code with an application development platform;

[1545] A system including:

[1546] (Claim 2)

[1547] 10. The system of claim 1, wherein the means for analyzing natural language performs keyword and context analysis.

[1548] (Claim 3)

[1549] 10. The system of claim 1, wherein the application development platform automatically deploys the application based on the generated code.

[1550] "Example 1"

[1551] (Claim 1)

[1552] a means for a user to input requirements written in natural language;

[1553] means for analyzing the natural language and extracting requirements;

[1554] A means for identifying necessary functions based on the extracted requirements;

[1555] means for generating code for an application based on the identified functions;

[1556] means for linking and deploying the generated code to an application development platform;

[1557] A system including:

[1558] (Claim 2)

[1559] 10. The system of claim 1, wherein the means for analyzing natural language performs keyword and context analysis.

[1560] (Claim 3)

[1561] 10. The system of claim 1, wherein the application development platform automatically deploys the application based on the generated code.

[1562] "Application Example 1"

[1563] (Claim 1)

[1564] a means for a user to input requirements written in natural language;

[1565] means for analyzing the natural language and extracting requirements;

[1566] A means for identifying necessary functions based on the extracted requirements;

[1567] means for generating code for an application based on the identified functions;

[1568] means for associating the generated code with an application development platform;

[1569] a means for identifying a task management application for managing operations of a logistics center;

[1570] A system including:

[1571] (Claim 2)

[1572] 10. The system of claim 1, wherein the means for analyzing natural language performs keyword and context analysis.

[1573] (Claim 3)

[1574] 10. The system of claim 1, wherein the application development platform automatically deploys the application based on the generated code.

[1575] "Example 2: Combining Emotion Engines"

[1576] (Claim 1)

[1577] a means for a user to input requirements written in natural language;

[1578] means for analyzing the natural language and extracting requirements;

[1579] means for recognizing a user's emotional state from said natural language input;

[1580] means for identifying required functions based on the extracted requirements and emotional state;

[1581] means for generating code for an application based on the identified functions;

[1582] means for linking the generated code to an application development platform;

[1583] means for adjusting application functionality or interface based on said emotional state;

[1584] A system including:

[1585] (Claim 2)

[1586] 10. The system of claim 1, wherein the means for analyzing natural language performs keyword and context analysis and analyzes the user's emotional state.

[1587] (Claim 3)

[1588] 10. The system of claim 1, wherein the application development infrastructure automatically deploys the application based on the generated code.

[1589] "Application example 2 when combining emotion engines"

[1590] (Claim 1)

[1591] a means for a user to input requirements written in natural language;

[1592] means for analyzing the natural language and extracting requirements;

[1593] A means for identifying necessary functions based on the extracted requirements;

[1594] means for generating code for an application based on the identified functions;

[1595] means for associating the generated code with an application development platform;

[1596] means for analyzing the emotional state of a user;

[1597] means for adjusting application functionality or interface based on said emotional state;

[1598] A system including:

[1599] (Claim 2)

[1600] 10. The system of claim 1, wherein the means for analyzing natural language performs keyword and context analysis.

[1601] (Claim 3)

[1602] 10. The system of claim 1, wherein the application development platform automatically deploys the application based on the generated code. [Explanation of symbols]

[1603] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. a means for a user to input requirements written in natural language; means for analyzing the natural language and extracting requirements; A means for identifying necessary functions based on the extracted requirements; means for generating code for an application based on the identified functions; means for associating the generated code with an application development platform; A system including:

2. 2. The system of claim 1, wherein the means for analyzing natural language performs keyword and context analysis.

3. The system of claim 1 , wherein the application development platform automatically deploys the application based on the generated code.

Images