System

Abstract

A system is provided.SOLUTION: A system comprising: means for obtaining answers to a plurality of question items from a user; means for analyzing the obtained answers and tokenizing the analysis results; means for using a AI model to automatically generate infrastructure management code based on the tokenized analysis results; and means for providing the generated infrastructure management code to the user.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 infrastructure management, manual code creation and management requires a significant amount of time and effort, and is prone to technical errors and mismatches. Furthermore, existing methods for automating the infrastructure management code generation process rely on limited templates and functions, making it difficult to meet diverse user needs. This hinders rapid and accurate infrastructure construction and reduces operational efficiency, especially when network scaling and configuration changes are required. [Means for solving the problem]

[0005] To solve the above problems, the present invention provides a means for acquiring answers to multiple questions from a user, analyzing the acquired answers, and tokenizing the analysis results. A means for using an AI model to automatically generate infrastructure management codes based on the tokenized analysis results is provided, and a system is constructed in which the generated infrastructure management codes are provided to users. This system allows users to quickly and accurately acquire the necessary infrastructure management codes simply by answering simple questions. Furthermore, by adding a means for sending the generated infrastructure management codes to the user's device and a means for specifying cloud services based on the acquired answers, a flexible system that can meet diverse user needs is realized.

[0006] "User" refers to an entity that utilizes the system and answers questions to generate infrastructure management code.

[0007] "Questionnaire" refers to a set of questions that a user must answer to generate infrastructure management code.

[0008] An "answer" refers to information that a user inputs to a question item.

[0009] "Acquisition" refers to the process by which the system receives answers to questionnaires from the user.

[0010] "Analysis" refers to the process of extracting relevant information from the answers obtained and converting it into an understandable format.

[0011] "Tokenization" refers to the process of converting parsed information into a format suitable for AI models.

[0012] "Infrastructure Management Code" means code used to manage cloud and on-premise infrastructure.

[0013] "AI Model" refers to the artificial intelligence algorithms used to automatically generate infrastructure management code.

[0014] "Delivery" refers to the process of presenting the generated infrastructure management code to the user.

[0015] "Terminal" refers to the computing device where a user enters answers and receives the generated infrastructure management code.

[0016] "Cloud Services" means services that provide computing resources over the Internet that are used to apply infrastructure management code. [Brief explanation of the drawings]

[0017] [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

[0018] 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.

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

[0020] 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).

[0021] 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.

[0022] 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.

[0023] 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.

[0024] 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."

[0025] [First embodiment]

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

[0027] 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.

[0028] 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).

[0029] 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.

[0030] 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.

[0031] 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.

[0032] 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.

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

[0034] 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.

[0035] 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.

[0036] 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.

[0037] 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."

[0038] As an embodiment of the present invention, a system for automatically generating infrastructure management code based on input from a user is constructed as follows.

[0039] The system acquires answers to multiple questions from users, analyzes and tokenizes them, and then uses an AI model to automatically generate infrastructure management codes based on the tokenized analysis results, and provides the generated codes to the user.

[0040] Program processing

[0041] Getting User Input

[0042] The user answers questions displayed on the device interface, such as "Which cloud provider will you use?", and answers "AWS." In this way, the user gradually answers questions about their infrastructure requirements.

[0043] Sending input data

[0044] Once the user has answered all the questions, the device sends the answer data to the server, where it is formatted in a way that makes it easy for the server to analyze.

[0045] Receiving and analyzing response data

[0046] The server analyzes the response data received from the device and maps each response to a corresponding attribute, for example, the response "AWS" is mapped to "Cloud Provider."

[0047] Preprocessing with AI models

[0048] The server tokenizes the parsed data to power the generative AI model, which then generates the infrastructure management code in a suitable format.

[0049] Auto-generation of infrastructure management code

[0050] The server uses generative AI models to generate infrastructure management code based on the user's answers. For example, if you select AWS, Terraform code is automatically generated.

[0051] Providing generated code to users

[0052] The server provides the generated infrastructure management code to the user via a link, email attachment, or copy function, allowing the user to receive the code and modify it as needed.

[0053] Specific examples

[0054] For example, suppose a user answers the following question:

[0055] 1. Which cloud provider will you use? → "AWS"

[0056] 2. What region? → "us-west-2"

[0057] 3. What type of instance is it? → "t2.micro"

[0058] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0059] Based on this answer, the server will generate the following Terraform code:

[0060] HCL

[0061] provider "aws" {

[0062] region = "us-west-2"

[0063] }

[0064] resource "aws_instance" "example" {

[0065] ami = "ami-0c55b159cbfafe1f0"

[0066] instance_type = "t2.micro"

[0067] }

[0068] Users can download this code and use Terraform to run the "terraform apply" command, which will create the specified instance on AWS.

[0069] Thus, the present invention is a system that reduces the burden on the user and can generate infrastructure management codes quickly and accurately.

[0070] The processing flow will be explained below.

[0071] Step 1:

[0072] The user answers questions displayed on the device interface. For example, to the question "Which cloud provider do you want to use?", they answer "AWS," and to the question "Which region?", they enter "us-west-2."

[0073] Step 2:

[0074] The device temporarily stores the user's input and confirms that all questions have been answered. Once this is confirmed, the device prepares to send the input data to the server.

[0075] Step 3:

[0076] The user clicks the send button. This causes the device to send the response data to the server, which converts the data into a format that is easy to analyze, such as JSON.

[0077] Step 4:

[0078] The server receives the response data from the terminal and temporarily stores it, making it easier to access the response data.

[0079] Step 5:

[0080] The server analyzes the received response data and maps the responses to the respective questions. For example, the response "AWS" maps to "cloud provider" and "us-west-2" maps to "region."

[0081] Step 6:

[0082] The server tokenizes the parsed data, which is the process of converting the parsed data into a format that is easy for the generative AI model to use.

[0083] Step 7:

[0084] The server feeds the tokenized analytics data into a generative AI model to generate infrastructure management code, for example, automatically generating Terraform code based on AWS configuration.

[0085] Step 8:

[0086] The server stores the generated infrastructure management code and prepares it for later distribution to the user.

[0087] Step 9:

[0088] The server chooses how to provide the generated code, displaying a download link, email attachment, or a pop-up for copying to the user.

[0089] Step 10:

[0090] Users can view the generated code on their device, download or copy it as needed, and then use infrastructure management tools (e.g., Terraform) to automate the deployment of the infrastructure.

[0091] Example 1

[0092] 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."

[0093] In today's cloud computing environment, manually creating infrastructure management code requires a great deal of effort and specialized knowledge. Furthermore, it is not easy to generate code accurately and quickly based on user responses to multiple questions. It is also difficult to select the optimal cloud service based on the user's requirements. Therefore, there is a need for a system that can automatically generate infrastructure management code more efficiently and accurately and provide it to users.

[0094] 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.

[0095] In this invention, the server includes means for acquiring answers to a plurality of questions from a user, means for transmitting the acquired answers to the server, means for analyzing the answers received by the server and tokenizing the analysis results, means for using an AI model to automatically generate an infrastructure management code based on the tokenized analysis results, and means for providing the generated infrastructure management code to the user, thereby enabling the user to quickly and accurately generate an infrastructure management code without requiring specialized knowledge.

[0096] A "user" is an individual or entity that uses a computer system or service.

[0097] "Questionnaire" refers to a specific question or request for information posed to a user regarding infrastructure requirements.

[0098] "Answer" refers to information or data provided by a user in response to a question.

[0099] A "terminal" is hardware and related software used by a user, such as a computer or mobile device.

[0100] A "server" is a computer system that provides data and services over a network.

[0101] "Analysis" refers to the process of converting or classifying the obtained answers into an understandable form.

[0102] "Tokenization" is the process of converting analyzed data into a form that is understandable to a generative AI model.

[0103] "Infrastructure Management Code" means program code used to configure and manage cloud services and computer infrastructure.

[0104] A "generative AI model" refers to an artificial intelligence algorithm that automates specific tasks based on pre-trained data.

[0105] "Providing" refers to the act of making the generated infrastructure management code available to users.

[0106] A "cloud service" is a service that provides computing resources (e.g., servers, storage, databases) via the Internet.

[0107] This invention is a system that automatically generates infrastructure management codes based on user input. The system acquires answers to multiple questions from the user, analyzes and tokenizes them, and generates infrastructure management codes using a generative AI model.

[0108] First, the user uses the device to answer a series of questions displayed on the interface. For example, to the question, "Which cloud provider do you want to use?", the user answers "AWS." In this way, the user answers questions one by one.

[0109] After the user has answered all the questions, the device sends the answer data to the server, which can then be structured in JSON format, for example, so that the server can easily parse it.

[0110] The server analyzes the received response data and maps each response to a corresponding attribute. For example, the response "AWS" is mapped to the attribute "Cloud Provider." This analysis is performed by an analysis engine running on the server.

[0111] The server tokenizes the parsed data. Tokenization is the process of converting data into a format that is easy for the generative AI model to understand. For example, "Cloud provider: AWS" is converted into "TOKEN_PROVIDER_AWS". A library such as Python can be used for this tokenization process.

[0112] The server then uses a generative AI model to automatically generate infrastructure management code based on the tokenized data. For example, if a user selects "AWS," provides "us-west-2" as the region, "t2.micro" as the instance type, and "ami-0c55b159cbfafe1f0" as the AMI ID, the AI ​​model can use this information to generate Terraform code, etc.

[0113] The generated infrastructure management code is provided to the user from the server via various methods, including a download link, email attachment, or copy to the clipboard. The user can then receive the code via their device and modify it as needed.

[0114] As a concrete example, suppose the user answers the following question:

[0115] 1. Which cloud provider will you use? → "AWS"

[0116] 2. What region? → "us-west-2"

[0117] 3. What type of instance is it? → "t2.micro"

[0118] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0119] Based on this answer, the server can generate the following Terraform code:

[0120] provider "aws" {

[0121] region = "us-west-2"

[0122] }

[0123] resource "aws_instance" "example" {

[0124] ami = "ami-0c55b159cbfafe1f0"

[0125] instance_type = "t2.micro"

[0126] }

[0127] In this way, the present invention utilizes a generative AI model to automatically generate infrastructure management code without requiring users to have specialized knowledge, enabling them to quickly and accurately configure cloud infrastructure.

[0128] Example prompt sentence:

[0129] Please generate an infrastructure management code based on your answers to the following questions about your cloud infrastructure configuration.

[0130] Provider: AWS

[0131] Region: us-west-2

[0132] Instance type: t2.micro

[0133] AMI ID: ami-0c55b159cbfafe1f0

[0134] Using this prompt, the AI ​​model can generate the necessary infrastructure management code.

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

[0136] Step 1:

[0137] The user answers the question. The user enters input into the question displayed on the device interface. For example, the user enters "AWS" in response to the question "Which cloud provider do you want to use?", or "us-west-2" in response to the question "Which region do you want to use?". The data entered by the user is temporarily stored on the device. Example of input data: {"Cloud provider": "AWS", "Region": "us-west-2"}.

[0138] Step 2:

[0139] The device sends the answer data to the server. Once the user has answered all the questions, the device structures the answer data (for example, in JSON format) and sends it to the server. Data is sent using an HTTP POST request. Example of sent data: {"Cloud provider": "AWS", "Region": "us-west-2"}.

[0140] Step 3:

[0141] The server receives and parses the data. The server receives the data sent from the device and parses it. For example, the answer "AWS" is mapped to an attribute called "Cloud Provider", and the answer "us-west-2" is mapped to an attribute called "Region". Once parsed, the data is converted into an internal data structure. Input data: {"Cloud Provider": "AWS", "Region": "us-west-2"}, Output data: {"Attribute 1": "Cloud Provider", "Value 1": "AWS", "Attribute 2": "Region", "Value 2": "us-west-2"}.

[0142] Step 4:

[0143] The server tokenizes the data. The analyzed data is converted into a format that is easy for the generative AI model to understand. For example, "Cloud provider: AWS" is tokenized as "TOKEN_PROVIDER_AWS" and "Region: us-west-2" is tokenized as "TOKEN_REGION_US_WEST_2". This tokenization is performed using a Python library or similar. Input data: {"Attribute 1": "Cloud provider", "Value 1": "AWS", "Attribute 2": "Region", "Value 2": "us-west-2"}, Output data: ["TOKEN_PROVIDER_AWS", "TOKEN_REGION_US_WEST_2"].

[0144] Step 5:

[0145] The server automatically generates infrastructure management code. The server passes the tokenized data to the generation AI model, which then generates the infrastructure management code. For example, if a user selects "AWS," specifies "us-west-2" as the region, selects "t2.micro" as the instance type, and provides "ami-0c55b159cbfafe1f0" as the AMI ID, the AI ​​model generates the following Terraform code:

[0146] HCL

[0147] provider "aws" {

[0148] region = "us-west-2"

[0149] }

[0150] resource "aws_instance" "example" {

[0151] ami = "ami-0c55b159cbfafe1f0"

[0152] instance_type = "t2.micro"

[0153] }

[0154] Input data: ["TOKEN_PROVIDER_AWS", "TOKEN_REGION_US_WEST_2", "TOKEN_INSTANCE_TYPE_T2_MICRO", "TOKEN_AMI_ID_0C55B159CBFAFE1F0"], Output data: Generated Terraform code.

[0155] Step 6:

[0156] The server provides the generated infrastructure management code to the user. The server has various methods for providing the generated code to the user, such as a download link, email attachment, or copy to the clipboard. The user can receive the code using these methods and make modifications as needed. Input data: the generated Terraform code, output data: the method of delivery such as a download link or email.

[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] In modern manufacturing, efficient control settings for factory robots, network configuration, and database management are important challenges. However, conventional methods require these settings to be performed manually, which requires a great deal of time and effort and increases the risk of configuration errors. A method to resolve these issues and efficiently and accurately manage factory automation systems is needed.

[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 acquiring answers to a plurality of questions from a user; means for analyzing the acquired answers and tokenizing the analysis results; means for using a generative AI model to automatically generate an infrastructure management code based on the tokenized analysis results; means for providing the generated infrastructure management code to the user; means for inputting requirements for an automation system in a factory using a smartphone or tablet; and means for automatically generating infrastructure management codes for controlling factory robots based on the input requirements. This eliminates the need for factory operators to manually perform complex settings, enabling efficient and accurate generation of infrastructure management codes and smooth operation of the factory automation system.

[0162] A "user" is a person who uses the system to answer questions and request the generation of an infrastructure management code.

[0163] The "question items" are items that the user answers to obtain information necessary for generating the infrastructure management code.

[0164] An "answer" is information provided by a user in response to a question item.

[0165] "Tokenization" refers to converting parsed data into a format that can be processed by a generative AI model.

[0166] "Infrastructure management code" is code related to the management and configuration of infrastructure structures, and is automatically generated by this system.

[0167] A "generative AI model" is an artificial intelligence model that analyzes user response data and generates infrastructure management code.

[0168] "Server" means the part of the system that analyzes user response data and generates and provides infrastructure management code.

[0169] A "smartphone or tablet" is a mobile device that a user uses to answer questions.

[0170] An "in-factory automation system" is an automated operational system that includes robot control, network configuration, and database management in a factory.

[0171] "Requirements" refer to the specific terms of use and settings for controlling factory robots, network configuration, and database management.

[0172] "Terminal" means a device utilized by a User to receive a generated Infrastructure Management Code.

[0173] The system for implementing this invention is designed to automatically generate infrastructure management code for automation systems in factories. The following describes the programming process that implements this system and how it is implemented in hardware and software.

[0174] Program Overview

[0175] The system allows users to use a smartphone or tablet to input requirements for infrastructure management, and automatically generates code based on that input for controlling factory robots, configuring networks, and managing databases.

[0176] Getting User Input

[0177] Users answer step-by-step questions displayed in an interface on their device, provided by an application installed on their smartphone or tablet. Example questions include:

[0178] "What robot model?"

[0179] "What area?"

[0180] "What's your network setup?"

[0181] "What about the database?"

[0182] For example, a user may answer "Robot A" to the question "What is the robot model?" This answer is similarly obtained for other questions.

[0183] Data transmission

[0184] Once the user has answered all the questions, the device sends the answer data to the server using the Python requests library or similar.

[0185] Receiving and analyzing response data

[0186] The server analyzes the response data received from the device and maps each response to a corresponding attribute. For example, the response "Robot A" is mapped to "Robot Model."

[0187] Preprocessing with AI models

[0188] The server then tokenizes the parsed data to power the generative AI model, using natural language processing (NLP) techniques, and the tokenized data is then formatted in a way that is suitable for generating infrastructure management code.

[0189] Auto-generation of infrastructure management code

[0190] The server uses a generative AI model to generate infrastructure management code based on the user's answers. For example, if "Robot A" is selected, the corresponding control code is automatically generated.

[0191] Providing generated code to users

[0192] The server provides the generated infrastructure management code to the user via a link, email attachment, or copy function, allowing the user to receive the code and modify it as needed.

[0193] Hardware and software used

[0194] Hardware: smartphones, tablets, servers

[0195] software:

[0196] User Interface: Mobile Application

[0197] Sending data: Python's requests library

[0198] Data Analysis and Tokenization: Natural Language Processing (NLP) Techniques

[0199] Generative AI model: An AI model for automatically generating infrastructure management code

[0200] Specific examples

[0201] For example, if a user answers the following questions:

[0202] 1. "What robot model is it?" → "Robot A"

[0203] 2. "What area?" → "Production Line 1"

[0204] 3. "What is your network setting?" → "DHCP"

[0205] 4. "What database?" → "PostgreSQL"

[0206] Based on this, the server generates infrastructure management code such as:

[0207] An example prompt might look like this:

[0208] "What robot model?"

[0209] "What area?"

[0210] "What's your network setup?"

[0211] "What about the database?"

[0212] This system eliminates the need for factory operators to manually configure complex settings, allowing them to efficiently and accurately generate infrastructure management code and ensure the smooth operation of factory automation systems.

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

[0214] Step 1:

[0215] The user uses a smartphone or tablet to input requirements for the factory automation system. They answer questions displayed on the user interface one by one. The information entered includes the robot model, area, network settings, database, etc. The data entered by the user is in text format, and answers are obtained for each question.

[0216] Step 2:

[0217] The device formats the user's answer data and sends it to the server, where it is converted to JSON format and sent to the server using a reliable communication protocol (e.g., HTTPS). The input data includes each of the user's answers, and the output data sent to the server is formatted JSON data.

[0218] Step 3:

[0219] The server analyzes the response data received from the device and maps each response to the corresponding attribute. Specifically, the server parses the received JSON data using an analysis tool, and the response "Robot A" is mapped as the "robot model." The input data is the JSON-formatted response data, and the output data is the data mapped to the attributes.

[0220] Step 4:

[0221] The server tokenizes the parsed data. The parsed attribute data is converted into tokens using natural language processing (NLP) techniques. At this point, the data is in a format that is easy for the generative AI model to process. The input data is data mapped to attributes, and the output data is tokenized data. Specifically, NLP tools (e.g., SpaCy, NLTK) are used to split words and phrases into tokens.

[0222] Step 5:

[0223] The server uses a generative AI model to generate infrastructure management code based on the tokenized data. Specifically, the generative AI model constructs appropriate infrastructure management code based on the tokenized data. Examples of generative AI models that can be used include OpenAI's GPT-3. The input data is the tokenized data, and the output data is the generated code.

[0224] Step 6:

[0225] The server provides the generated infrastructure management code to the user. The server can email the generated code, provide a download link, or send it directly to the terminal. The input data is the generated code, and the output data is the code converted into a format that is provided to the user. For example, the generated Terraform code is attached to an email.

[0226] In this way, each processing step works in conjunction with the others, making it possible to efficiently and accurately generate the infrastructure management code required for a factory automation system.

[0227] 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.

[0228] As an embodiment of the present invention, a system for automatically generating infrastructure management code based on user input is constructed as follows: This system is combined with an emotion engine that recognizes user emotions.

[0229] This system acquires responses to multiple questions from users, analyzes them, and tokenizes them. It then uses an AI model to automatically generate infrastructure management codes based on the tokenized analysis results, and provides the generated codes to the user. It also uses an emotion engine to recognize user emotions, dynamically changing the content and format of questions and adjusting the interface design based on those emotions. Furthermore, the emotion data is saved along with the analysis results and can be used to generate future infrastructure management codes.

[0230] Program processing

[0231] Getting User Input

[0232] The user answers questions displayed on the device interface. For example, to the question "Which cloud provider do you use?", the user answers "AWS," and to the question "What region?", the user enters "us-west-2." The emotion engine recognizes the user's emotions in real time during the conversation, and the interface dynamically adjusts according to changes in emotion.

[0233] Sending input data

[0234] When the user completes the answer, the device sends the answer data to the server, along with the emotion data acquired by the emotion engine.

[0235] Receiving and analyzing response data

[0236] The server receives the response data and emotion data from the device and temporarily stores them, making each piece of data easier to access.

[0237] Emotional Data Processing

[0238] The server analyzes the emotion data acquired by the emotion engine and extracts patterns of the user's emotional changes. This data is used to dynamically adjust the content and format of questions.

[0239] Parsing and tokenizing response data

[0240] The server parses the received response data and maps each response to a corresponding attribute. For example, the response "AWS" maps to "cloud provider" and the response "us-west-2" maps to "region." The parsed results are tokenized and converted into a format that is easy for the AI ​​model to handle.

[0241] Auto-generation of infrastructure management code

[0242] The server uses generative AI models to generate infrastructure management code based on user responses and sentiment data, for example automatically generating Terraform code based on AWS configuration.

[0243] Providing generated code to users

[0244] The server stores the generated infrastructure management code and prepares it for delivery to the user. Specifically, it provides the ability to download it via a link, attach it to an email, or copy it. The user receives the code using their device and can review and modify it as needed.

[0245] Specific examples

[0246] For example, suppose a user answers the following question:

[0247] 1. Which cloud provider will you use? → "AWS"

[0248] 2. What region? → "us-west-2"

[0249] 3. What type of instance is it? → "t2.micro"

[0250] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0251] In addition to this answer, if the sentiment engine recognizes a positive sentiment, the server will generate the following Terraform code:

[0252] HCL

[0253] provider "aws" {

[0254] region = "us-west-2"

[0255] }

[0256] resource "aws_instance" "example" {

[0257] ami = "ami-0c55b159cbfafe1f0"

[0258] instance_type = "t2.micro"

[0259] }

[0260] Users can download this code and use Terraform to run the "terraform apply" command, which will create the specified instance on AWS.

[0261] This system reduces the burden on users, enables rapid and accurate generation of infrastructure management code, and provides a flexible interface that takes user feelings into consideration.

[0262] The processing flow will be explained below.

[0263] Step 1:

[0264] The user answers a number of questions displayed on the device interface. For example, in response to the question "Which cloud provider do you want to use?", the user enters "AWS." In response to the question "Which region?", the user answers "us-west-2."

[0265] Step 2:

[0266] The emotion engine analyzes the user's facial expressions and vocal tone in real time to recognize their emotional state, for example, using the camera and microphone to determine whether the user is smiling or sad.

[0267] Step 3:

[0268] The device temporarily stores the user's response data and the recognized emotion data, and then verifies that all questions have been answered. After verification, this data is compiled into a data packet.

[0269] Step 4:

[0270] When the user clicks the send button, the device sends a data packet containing the user's response data and emotion data to the server.

[0271] Step 5:

[0272] The server receives data packets from the device and stores them temporarily, allowing for quick access and analysis of the data.

[0273] Step 6:

[0274] The server parses the response data in the data packet and maps each response to a corresponding attribute, for example, the response "AWS" maps to "cloud provider" and "us-west-2" maps to "region".

[0275] Step 7:

[0276] The server analyzes the emotion data recognized by the emotion engine and integrates the response data with the emotion data. The recognized emotional state is reflected in the interface design and the content and format of the questions.

[0277] Step 8:

[0278] The server tokenizes the parsed response data and prepares it for input into the generative AI model. Tokenization makes the data more accessible to the AI ​​model.

[0279] Step 9:

[0280] The server uses generative AI models to automatically generate infrastructure management code based on the integrated data, for example, Terraform code if AWS is selected.

[0281] Step 10:

[0282] The server stores the generated infrastructure management code and then prepares it for delivery to the user, either via a link for download, email attachment, or copy function.

[0283] Step 11:

[0284] The user can view the generated code on the terminal, download or copy it as needed, and then use an infrastructure management tool (e.g., Terraform) to automatically deploy the infrastructure. Specifically, they run the "terraform apply" command.

[0285] Example 2

[0286] 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."

[0287] Conventional infrastructure management code generation systems do not take into account the user's emotional state, potentially resulting in a poor user experience. Manual code generation is also time-consuming, labor-intensive, and prone to errors. The present invention aims to address these issues and provide a system that automatically generates infrastructure management codes quickly and accurately, while improving the user experience.

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

[0289] In this invention, the server includes means for acquiring answers to a plurality of questions from a user, means for acquiring the acquired answers and emotional data of the user in the answers, means for analyzing the acquired answers and emotional data and tokenizing the analysis results, means for using an AI model to automatically generate an infrastructure management code based on the tokenized analysis results, means for providing the generated infrastructure management code to the user, means for dynamically adjusting the user's input interface based on the emotional data, and means for saving each processing result and using it for generating future infrastructure management codes. This makes it possible to provide a flexible interface that takes into account the emotional state of the user and to automatically generate infrastructure management codes quickly and accurately.

[0290] "User" refers to a user who answers questions to generate infrastructure management code using the system.

[0291] "Terminal" refers to a device used by a user to answer questions and send the answer data to a server.

[0292] "Emotion data" refers to information that indicates the user's emotional state and is acquired during user input.

[0293] "Server" refers to a device that receives and stores responses and emotion data sent by users, analyzes them, and generates infrastructure management code.

[0294] "Tokenization" refers to the process of analyzing the response data obtained and converting it into a format that is easy for an AI model to handle.

[0295] "Generative AI model" refers to an artificial intelligence model for automatically generating infrastructure management code based on tokenized analysis results.

[0296] "Infrastructure Management Code" means computer code used to automate the configuration and resource management of Cloud Services.

[0297] "Dynamic adjustment" refers to changing the content of the interface and the format of questions in real time based on the user's emotional data.

[0298] "Storage" refers to the server maintaining the acquired response data and emotion data in a state where it can be used for future processing.

[0299] This invention relates to a system that automatically generates infrastructure management codes based on user input and emotional data. The system acquires answers to multiple questions from the user and tokenizes them. It then uses a generative AI model based on the tokenized data to automatically generate infrastructure management codes. Furthermore, it uses an emotional engine to recognize the user's emotional state and utilizes that data for analysis. This improves the user experience and enables faster and more accurate generation of infrastructure management codes.

[0300] This system is implemented in a client-server model. The user answers questions through an interface on the device and sends the data to the server. The device is equipped with an emotion engine that obtains emotional data in real time from the user's facial expressions and tone of voice. The data is then transferred to the server via a secure communication method (e.g., HTTPS protocol).

[0301] The server stores the received response data and sentiment data in a database. The stored data is then analyzed, first parsing the response data and mapping each response to its corresponding attributes. The data is then tokenized and converted into a format that can be easily handled by the AI ​​model, using natural language processing techniques. A generative AI model generates infrastructure management code based on the tokenized data. This model uses a pre-trained model to generate code that corresponds to a specific cloud service (e.g., cloud provider or region configuration).

[0302] The generated code is stored on the server and provided to the user. Delivery methods include downloading via a link, attaching to an email, or copying. The user receives the generated code on their device and can review and modify it as needed. For example, they can run the generated code using Terraform to apply specific settings to a cloud environment.

[0303] Specific examples

[0304] For example, suppose a user answers the following question:

[0305] 1. Which cloud provider will you use? → "AWS"

[0306] 2. What region? → "us-west-2"

[0307] 3. What type of instance is it? → "t2.micro"

[0308] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0309] This response data and the data that the emotion engine recognized as positive emotions are sent to the server, which generates the following Terraform code based on this data.

[0310] HCL

[0311] provider "aws" {

[0312] region = "us-west-2"

[0313] }

[0314] resource "aws_instance" "example" {

[0315] ami = "ami-0c55b159cbfafe1f0"

[0316] instance_type = "t2.micro"

[0317] }

[0318] Users can download this code and use Terraform to create the specified instance on AWS by running the "terraform apply" command.

[0319] The system aims to reduce the burden on users and generate infrastructure management code quickly and accurately. It also provides a better user experience by taking into account the user's emotional state through an emotion engine.

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

[0321] Step 1: Getting User Input

[0322] The user answers multiple questions displayed on the device interface. Specifically, the device displays questions such as "Which cloud provider do you use?" and "Which region?", to which the user answers in text format. The device also uses a built-in emotion engine to analyze the user's facial expressions and tone of voice while they are entering their answers, obtaining emotional data in real time. Input: Text questions, answer data, and emotional data. Output: User's answer data and emotional data.

[0323] Step 2: Submitting input data

[0324] Once the user has answered all the questions, the device sends the answer data and emotion data to the server. Specifically, this data is securely transferred using the HTTPS protocol. Input: Answer data and emotion data entered by the user. Output: Data sent to the server.

[0325] Step 3: Receiving and storing response data

[0326] The server receives the response data and emotion data sent from the device. The server stores this data in a database and prepares it for later analysis. Input: Response data and emotion data sent from the device. Output: Data stored in the server's database.

[0327] Step 4: Analyze the sentiment data

[0328] The server analyzes the stored emotion data. Specifically, it uses the data obtained from the emotion engine to extract patterns of the user's emotion changes. For example, it determines whether the user is feeling stressed while answering questions. Input: Stored emotion data. Output: User's emotion change patterns.

[0329] Step 5: Parse and tokenize response data

[0330] The server parses the stored response data and maps each response to its corresponding attribute. The results of this analysis are then tokenized and converted into a format that the AI ​​model can easily handle. For example, the response "AWS" is mapped to "cloud provider" and the response "us-west-2" is mapped to "region." Input: Response data. Output: Tokenized data.

[0331] Step 6: Auto-generating infrastructure management code

[0332] The server uses a generative AI model to generate infrastructure management codes based on the tokenized analysis results. The generative AI model used here is a pre-trained model that generates appropriate codes based on the response data. Input: Tokenized analysis results. Output: Generated infrastructure management code.

[0333] Step 7: Provide the generated code to users

[0334] The server prepares the generated infrastructure management code for delivery to the user. For example, the generated code may be made available for download via a link or sent via email. The user downloads this code on their device and reviews and modifies it as needed. Input: Generated infrastructure management code. Output: Code provided to the user.

[0335] (Application example 2)

[0336] 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."

[0337] Conventional infrastructure management code generation systems generate codes based on user input data, but provide a uniform question format and interface without considering the user's emotional state, which does not adequately consider the user experience. Furthermore, because personalized content is not generated, it is difficult to provide optimal information to users.

[0338] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for acquiring answers to multiple questions from the user, means for analyzing the acquired answers and tokenizing the analysis results, means for using a model to automatically generate an infrastructure management code based on the tokenized analysis results, means for analyzing the acquired emotion data and dynamically changing the content and format of the question in response to changes in the user's emotion, and means for providing the generated infrastructure management code to the user. This makes it possible to provide a flexible question format and interface based on the user's emotional state, improving the user experience. Furthermore, by generating personalized content using the emotion data, it is possible to provide optimal information to the user.

[0339] "Answers to multiple questions from a user" refers to a collection of individual responses to multiple questions that a user inputs on an interface via a terminal.

[0340] "Analysis" is the process of clarifying the meaning and relationships of information and structuring it in order to convert acquired data into an understandable format.

[0341] "Tokenization" is the process of breaking down parsed data into elements and organizing them according to a prescribed format.

[0342] "Infrastructure management code" is program code for automating infrastructure management such as cloud services and servers.

[0343] A "model" refers to a machine learning algorithm designed to perform a specific task, taking data as input and producing an output.

[0344] "Emotion data" is data that indicates the emotional state of a user, and is usually obtained using techniques such as facial expression recognition and voice analysis.

[0345] "Dynamic change" refers to changes in real time based on the situation or conditions, following certain rules.

[0346] "Personalized content" refers to information and media that are customized to suit the preferences and circumstances of individual users.

[0347] "Terminal" refers to an apparatus or device operated by a user, including smartphones, tablets, and personal computers.

[0348] "Providing" refers to the act of delivering generated infrastructure management code and personalized content to a user.

[0349] MODE FOR CARRYING OUT THE INVENTION

[0350] The following system can be constructed as an embodiment of the present invention. The system uses user input data and emotion data to generate infrastructure management code and personalized content, achieving a flexible interface and optimal information provision.

[0351] System Program Description

[0352] The system mainly consists of the following elements: user device (smartphone or head-mounted display), server, emotion engine, and generative AI model.

[0353] Getting User Input

[0354] The user answers a number of questions displayed on the device, and the answer data is collected. For example, the user enters answers to the following questions:

[0355] 1. What is your favorite genre? → "SF"

[0356] 2. What type of content do you want to watch? → "Movies"

[0357] 3. What device will you be watching on? → "Smartphone"

[0358] Acquiring emotion data

[0359] The emotion engine recognizes the user's real-time emotions using a camera or microphone, for example, by using the emotion analysis API from Microsoft Azure Cognitive Services.

[0360] Sending input data and emotion data

[0361] The user's response data and emotion data are transmitted from the terminal to the server.

[0362] Data Parsing and Tokenization

[0363] The server parses the received data and maps each response to a corresponding attribute, and the results are tokenized and converted into a format that is easy for the generative AI model to understand.

[0364] Infrastructure management code generation

[0365] The server uses generative AI models based on the tokenized data to generate infrastructure management code, for example, automatically generating Terraform code based on cloud configuration.

[0366] Personalized content generation

[0367] The server uses the user's responses and emotion data to generate personalized content, such as a list of movies in the science fiction genre that the user wants to watch on their smartphone.

[0368] Examples:

[0369] Based on the user's response and positive sentiment, the following prompt sentence is fed into the generative AI model:

[0370] The user indicated that they would like to watch movies in the sci-fi genre on their smartphone. This indicates a positive sentiment. Please generate a list of recommendations for the best content.

[0371] Based on this, the generative AI model generates a list of highly rated sci-fi movies such as "Interstellar" and "The Matrix."

[0372] Providing generated code and content

[0373] The generated infrastructure management code and personalized content are sent to the user's device for easy access by the user, either via a download link, email notification, or display of a content list on the device.

[0374] As a result, a system can be constructed that provides flexible question formats and interfaces that correspond to the user's emotional state, improves the user experience, and provides optimal information.

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

[0376] Step 1:

[0377] The user inputs answers to multiple questions displayed on the device. For example, the user answers questions such as "my favorite genre is SF," "the type of content I want to watch is movies," and "the device I want to watch it on is a smartphone." This input data is obtained from the user's interface. The device temporarily stores the user's answers obtained here.

[0378] Step 2:

[0379] The device uses an emotion engine to capture the user's emotional data in real time. It analyzes the user's facial expressions and tone of voice through a camera and microphone to recognize their emotional state, such as positive, negative, or neutral. This emotional data is then prepared for transmission along with the response data.

[0380] Step 3:

[0381] The device sends the acquired response data and emotion data to the server. Data transmission uses an encryption protocol (e.g., HTTPS) to protect the security and privacy of the data.

[0382] Step 4:

[0383] The server receives the response data and emotion data from the device and temporarily stores them. The stored data is structured so that it can be analyzed.

[0384] Step 5:

[0385] The server analyzes the received response data and maps each response to a corresponding attribute. For example, the response "science fiction" is mapped to "genre," "movie" to "content type," and "smartphone" to "device." The analysis results are converted into tokens and organized into a format that is easy for the generative AI model to use.

[0386] Step 6:

[0387] The server analyzes the emotion data. Based on the acquired data, the emotion engine extracts patterns of the user's emotional changes. For example, if the user is expressing positive emotions, the content and format of the questions are dynamically adjusted according to that emotional state.

[0388] Step 7:

[0389] The server uses a generative AI model to generate infrastructure management code based on the tokenized response data and sentiment data. For example, Terraform code can be automatically generated based on cloud service configuration. The generation process uses a trained model to generate code based on the specified prompt.

[0390] Step 8:

[0391] The server generates personalized content based on the user's input and emotional data. For example, if a user responds that they would like to watch science fiction movies on their smartphone, the server generates a list of highly rated science fiction movies. The generated content list includes information based on specific keywords and the user's emotions.

[0392] Step 9:

[0393] The server provides the generated infrastructure management code and personalized content to the user's device. The delivery methods include download links, email attachments, and display on the device. The user can access the generated code and content list using the device and check or use it as needed.

[0394] Through each of the above steps, users can experience flexible question formats and personalized content that adapts to their emotional state, enabling quick and accurate generation of infrastructure management codes.

[0395] 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.

[0396] 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.

[0397] 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.

[0398] [Second embodiment]

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

[0400] 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.

[0401] 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).

[0402] 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.

[0403] 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.

[0404] 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).

[0405] 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.

[0406] 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.

[0407] 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.

[0408] 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.

[0409] 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.

[0410] 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."

[0411] As an embodiment of the present invention, a system for automatically generating infrastructure management code based on input from a user is constructed as follows.

[0412] The system acquires answers to multiple questions from users, analyzes and tokenizes them, and then uses an AI model to automatically generate infrastructure management codes based on the tokenized analysis results, and provides the generated codes to the user.

[0413] Program processing

[0414] Getting User Input

[0415] The user answers questions displayed on the device interface, such as "Which cloud provider will you use?", and answers "AWS." In this way, the user gradually answers questions about their infrastructure requirements.

[0416] Sending input data

[0417] Once the user has answered all the questions, the device sends the answer data to the server, where it is formatted in a way that makes it easy for the server to analyze.

[0418] Receiving and analyzing response data

[0419] The server analyzes the response data received from the device and maps each response to a corresponding attribute, for example, the response "AWS" is mapped to "Cloud Provider."

[0420] Preprocessing with AI models

[0421] The server tokenizes the parsed data to power the generative AI model, which then generates the infrastructure management code in a suitable format.

[0422] Auto-generation of infrastructure management code

[0423] The server uses generative AI models to generate infrastructure management code based on the user's answers. For example, if you select AWS, Terraform code is automatically generated.

[0424] Providing generated code to users

[0425] The server provides the generated infrastructure management code to the user via a link, email attachment, or copy function, allowing the user to receive the code and modify it as needed.

[0426] Specific examples

[0427] For example, suppose a user answers the following question:

[0428] 1. Which cloud provider will you use? → "AWS"

[0429] 2. What region? → "us-west-2"

[0430] 3. What type of instance is it? → "t2.micro"

[0431] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0432] Based on this answer, the server will generate the following Terraform code:

[0433] HCL

[0434] provider "aws" {

[0435] region = "us-west-2"

[0436] }

[0437] resource "aws_instance" "example" {

[0438] ami = "ami-0c55b159cbfafe1f0"

[0439] instance_type = "t2.micro"

[0440] }

[0441] Users can download this code and use Terraform to run the "terraform apply" command, which will create the specified instance on AWS.

[0442] Thus, the present invention is a system that reduces the burden on the user and can generate infrastructure management codes quickly and accurately.

[0443] The processing flow will be explained below.

[0444] Step 1:

[0445] The user answers questions displayed on the device interface. For example, to the question "Which cloud provider do you want to use?", they answer "AWS," and to the question "Which region?", they enter "us-west-2."

[0446] Step 2:

[0447] The device temporarily stores the user's input and confirms that all questions have been answered. Once this is confirmed, the device prepares to send the input data to the server.

[0448] Step 3:

[0449] The user clicks the send button. This causes the device to send the response data to the server, which converts the data into a format that is easy to analyze, such as JSON.

[0450] Step 4:

[0451] The server receives the response data from the terminal and temporarily stores it, making it easier to access the response data.

[0452] Step 5:

[0453] The server analyzes the received response data and maps the responses to the respective questions. For example, the response "AWS" maps to "cloud provider" and "us-west-2" maps to "region."

[0454] Step 6:

[0455] The server tokenizes the parsed data, which is the process of converting the parsed data into a format that is easy for the generative AI model to use.

[0456] Step 7:

[0457] The server feeds the tokenized analytics data into a generative AI model to generate infrastructure management code, for example, automatically generating Terraform code based on AWS configuration.

[0458] Step 8:

[0459] The server stores the generated infrastructure management code and prepares it for later distribution to the user.

[0460] Step 9:

[0461] The server chooses how to provide the generated code, displaying a download link, email attachment, or a pop-up for copying to the user.

[0462] Step 10:

[0463] Users can view the generated code on their device, download or copy it as needed, and then use infrastructure management tools (e.g., Terraform) to automate the deployment of the infrastructure.

[0464] Example 1

[0465] 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."

[0466] In today's cloud computing environment, manually creating infrastructure management code requires a great deal of effort and specialized knowledge. Furthermore, it is not easy to generate code accurately and quickly based on user responses to multiple questions. It is also difficult to select the optimal cloud service based on the user's requirements. Therefore, there is a need for a system that can automatically generate infrastructure management code more efficiently and accurately and provide it to users.

[0467] 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.

[0468] In this invention, the server includes means for acquiring answers to a plurality of questions from a user, means for transmitting the acquired answers to the server, means for analyzing the answers received by the server and tokenizing the analysis results, means for using an AI model to automatically generate an infrastructure management code based on the tokenized analysis results, and means for providing the generated infrastructure management code to the user, thereby enabling the user to quickly and accurately generate an infrastructure management code without requiring specialized knowledge.

[0469] A "user" is an individual or entity that uses a computer system or service.

[0470] "Questionnaire" refers to a specific question or request for information posed to a user regarding infrastructure requirements.

[0471] "Answer" refers to information or data provided by a user in response to a question.

[0472] A "terminal" is hardware and related software used by a user, such as a computer or mobile device.

[0473] A "server" is a computer system that provides data and services over a network.

[0474] "Analysis" refers to the process of converting or classifying the obtained answers into an understandable form.

[0475] "Tokenization" is the process of converting analyzed data into a form that is understandable to a generative AI model.

[0476] "Infrastructure Management Code" means program code used to configure and manage cloud services and computer infrastructure.

[0477] A "generative AI model" refers to an artificial intelligence algorithm that automates specific tasks based on pre-trained data.

[0478] "Providing" refers to the act of making the generated infrastructure management code available to users.

[0479] A "cloud service" is a service that provides computing resources (e.g., servers, storage, databases) via the Internet.

[0480] This invention is a system that automatically generates infrastructure management codes based on user input. The system acquires answers to multiple questions from the user, analyzes and tokenizes them, and generates infrastructure management codes using a generative AI model.

[0481] First, the user uses the device to answer a series of questions displayed on the interface. For example, to the question, "Which cloud provider do you want to use?", the user answers "AWS." In this way, the user answers questions one by one.

[0482] After the user has answered all the questions, the device sends the answer data to the server, which can then be structured in JSON format, for example, so that the server can easily parse it.

[0483] The server analyzes the received response data and maps each response to a corresponding attribute. For example, the response "AWS" is mapped to the attribute "Cloud Provider." This analysis is performed by an analysis engine running on the server.

[0484] The server tokenizes the parsed data. Tokenization is the process of converting data into a format that is easy for the generative AI model to understand. For example, "Cloud provider: AWS" is converted into "TOKEN_PROVIDER_AWS". A library such as Python can be used for this tokenization process.

[0485] The server then uses a generative AI model to automatically generate infrastructure management code based on the tokenized data. For example, if a user selects "AWS," provides "us-west-2" as the region, "t2.micro" as the instance type, and "ami-0c55b159cbfafe1f0" as the AMI ID, the AI ​​model can use this information to generate Terraform code, etc.

[0486] The generated infrastructure management code is provided to the user from the server via various methods, including a download link, email attachment, or copy to the clipboard. The user can then receive the code via their device and modify it as needed.

[0487] As a concrete example, suppose the user answers the following question:

[0488] 1. Which cloud provider will you use? → "AWS"

[0489] 2. What region? → "us-west-2"

[0490] 3. What type of instance is it? → "t2.micro"

[0491] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0492] Based on this answer, the server can generate the following Terraform code:

[0493] provider "aws" {

[0494] region = "us-west-2"

[0495] }

[0496] resource "aws_instance" "example" {

[0497] ami = "ami-0c55b159cbfafe1f0"

[0498] instance_type = "t2.micro"

[0499] }

[0500] In this way, the present invention utilizes a generative AI model to automatically generate infrastructure management code without requiring users to have specialized knowledge, enabling them to quickly and accurately configure cloud infrastructure.

[0501] Example prompt sentence:

[0502] Please generate an infrastructure management code based on your answers to the following questions about your cloud infrastructure configuration.

[0503] Provider: AWS

[0504] Region: us-west-2

[0505] Instance type: t2.micro

[0506] AMI ID: ami-0c55b159cbfafe1f0

[0507] Using this prompt, the AI ​​model can generate the necessary infrastructure management code.

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

[0509] Step 1:

[0510] The user answers the question. The user enters input into the question displayed on the device interface. For example, the user enters "AWS" in response to the question "Which cloud provider do you want to use?", or "us-west-2" in response to the question "Which region do you want to use?". The data entered by the user is temporarily stored on the device. Example of input data: {"Cloud provider": "AWS", "Region": "us-west-2"}.

[0511] Step 2:

[0512] The device sends the answer data to the server. Once the user has answered all the questions, the device structures the answer data (for example, in JSON format) and sends it to the server. Data is sent using an HTTP POST request. Example of sent data: {"Cloud provider": "AWS", "Region": "us-west-2"}.

[0513] Step 3:

[0514] The server receives and parses the data. The server receives the data sent from the device and parses it. For example, the answer "AWS" is mapped to an attribute called "Cloud Provider", and the answer "us-west-2" is mapped to an attribute called "Region". Once parsed, the data is converted into an internal data structure. Input data: {"Cloud Provider": "AWS", "Region": "us-west-2"}, Output data: {"Attribute 1": "Cloud Provider", "Value 1": "AWS", "Attribute 2": "Region", "Value 2": "us-west-2"}.

[0515] Step 4:

[0516] The server tokenizes the data. The analyzed data is converted into a format that is easy for the generative AI model to understand. For example, "Cloud provider: AWS" is tokenized as "TOKEN_PROVIDER_AWS" and "Region: us-west-2" is tokenized as "TOKEN_REGION_US_WEST_2". This tokenization is performed using a Python library or similar. Input data: {"Attribute 1": "Cloud provider", "Value 1": "AWS", "Attribute 2": "Region", "Value 2": "us-west-2"}, Output data: ["TOKEN_PROVIDER_AWS", "TOKEN_REGION_US_WEST_2"].

[0517] Step 5:

[0518] The server automatically generates infrastructure management code. The server passes the tokenized data to the generation AI model, which then generates the infrastructure management code. For example, if a user selects "AWS," specifies "us-west-2" as the region, selects "t2.micro" as the instance type, and provides "ami-0c55b159cbfafe1f0" as the AMI ID, the AI ​​model generates the following Terraform code:

[0519] HCL

[0520] provider "aws" {

[0521] region = "us-west-2"

[0522] }

[0523] resource "aws_instance" "example" {

[0524] ami = "ami-0c55b159cbfafe1f0"

[0525] instance_type = "t2.micro"

[0526] }

[0527] Input data: ["TOKEN_PROVIDER_AWS", "TOKEN_REGION_US_WEST_2", "TOKEN_INSTANCE_TYPE_T2_MICRO", "TOKEN_AMI_ID_0C55B159CBFAFE1F0"], Output data: Generated Terraform code.

[0528] Step 6:

[0529] The server provides the generated infrastructure management code to the user. The server has various methods for providing the generated code to the user, such as a download link, email attachment, or copy to the clipboard. The user can receive the code using these methods and make modifications as needed. Input data: the generated Terraform code, output data: the method of delivery such as a download link or email.

[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] In modern manufacturing, efficient control settings for factory robots, network configuration, and database management are important challenges. However, conventional methods require these settings to be performed manually, which requires a great deal of time and effort and increases the risk of configuration errors. A method to resolve these issues and efficiently and accurately manage factory automation systems is needed.

[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 acquiring answers to a plurality of questions from a user; means for analyzing the acquired answers and tokenizing the analysis results; means for using a generative AI model to automatically generate an infrastructure management code based on the tokenized analysis results; means for providing the generated infrastructure management code to the user; means for inputting requirements for an automation system in a factory using a smartphone or tablet; and means for automatically generating infrastructure management codes for controlling factory robots based on the input requirements. This eliminates the need for factory operators to manually perform complex settings, enabling efficient and accurate generation of infrastructure management codes and smooth operation of the factory automation system.

[0535] A "user" is a person who uses the system to answer questions and request the generation of an infrastructure management code.

[0536] The "question items" are items that the user answers to obtain information necessary for generating the infrastructure management code.

[0537] An "answer" is information provided by a user in response to a question item.

[0538] "Tokenization" refers to converting parsed data into a format that can be processed by a generative AI model.

[0539] "Infrastructure management code" is code related to the management and configuration of infrastructure structures, and is automatically generated by this system.

[0540] A "generative AI model" is an artificial intelligence model that analyzes user response data and generates infrastructure management code.

[0541] "Server" means the part of the system that analyzes user response data and generates and provides infrastructure management code.

[0542] A "smartphone or tablet" is a mobile device that a user uses to answer questions.

[0543] An "in-factory automation system" is an automated operational system that includes robot control, network configuration, and database management in a factory.

[0544] "Requirements" refer to the specific terms of use and settings for controlling factory robots, network configuration, and database management.

[0545] "Terminal" means a device utilized by a User to receive a generated Infrastructure Management Code.

[0546] The system for implementing this invention is designed to automatically generate infrastructure management code for automation systems in factories. The following describes the programming process that implements this system and how it is implemented in hardware and software.

[0547] Program Overview

[0548] The system allows users to use a smartphone or tablet to input requirements for infrastructure management, and automatically generates code based on that input for controlling factory robots, configuring networks, and managing databases.

[0549] Getting User Input

[0550] Users answer step-by-step questions displayed in an interface on their device, provided by an application installed on their smartphone or tablet. Example questions include:

[0551] "What robot model?"

[0552] "What area?"

[0553] "What's your network setup?"

[0554] "What about the database?"

[0555] For example, a user may answer "Robot A" to the question "What is the robot model?" This answer is similarly obtained for other questions.

[0556] Data transmission

[0557] Once the user has answered all the questions, the device sends the answer data to the server using the Python requests library or similar.

[0558] Receiving and analyzing response data

[0559] The server analyzes the response data received from the device and maps each response to a corresponding attribute. For example, the response "Robot A" is mapped to "Robot Model."

[0560] Preprocessing with AI models

[0561] The server then tokenizes the parsed data to power the generative AI model, using natural language processing (NLP) techniques, and the tokenized data is then formatted in a way that is suitable for generating infrastructure management code.

[0562] Auto-generation of infrastructure management code

[0563] The server uses a generative AI model to generate infrastructure management code based on the user's answers. For example, if "Robot A" is selected, the corresponding control code is automatically generated.

[0564] Providing generated code to users

[0565] The server provides the generated infrastructure management code to the user via a link, email attachment, or copy function, allowing the user to receive the code and modify it as needed.

[0566] Hardware and software used

[0567] Hardware: smartphones, tablets, servers

[0568] software:

[0569] User Interface: Mobile Application

[0570] Sending data: Python's requests library

[0571] Data Analysis and Tokenization: Natural Language Processing (NLP) Techniques

[0572] Generative AI model: An AI model for automatically generating infrastructure management code

[0573] Specific examples

[0574] For example, if a user answers the following questions:

[0575] 1. "What robot model is it?" → "Robot A"

[0576] 2. "What area?" → "Production Line 1"

[0577] 3. "What is your network setting?" → "DHCP"

[0578] 4. "What database?" → "PostgreSQL"

[0579] Based on this, the server generates infrastructure management code such as:

[0580] An example prompt might look like this:

[0581] "What robot model?"

[0582] "What area?"

[0583] "What's your network setup?"

[0584] "What about the database?"

[0585] This system eliminates the need for factory operators to manually configure complex settings, allowing them to efficiently and accurately generate infrastructure management code and ensure the smooth operation of factory automation systems.

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

[0587] Step 1:

[0588] The user uses a smartphone or tablet to input requirements for the factory automation system. They answer questions displayed on the user interface one by one. The information entered includes the robot model, area, network settings, database, etc. The data entered by the user is in text format, and answers are obtained for each question.

[0589] Step 2:

[0590] The device formats the user's answer data and sends it to the server, where it is converted to JSON format and sent to the server using a reliable communication protocol (e.g., HTTPS). The input data includes each of the user's answers, and the output data sent to the server is formatted JSON data.

[0591] Step 3:

[0592] The server analyzes the response data received from the device and maps each response to the corresponding attribute. Specifically, the server parses the received JSON data using an analysis tool, and the response "Robot A" is mapped as the "robot model." The input data is the JSON-formatted response data, and the output data is the data mapped to the attributes.

[0593] Step 4:

[0594] The server tokenizes the parsed data. The parsed attribute data is converted into tokens using natural language processing (NLP) techniques. At this point, the data is in a format that is easy for the generative AI model to process. The input data is data mapped to attributes, and the output data is tokenized data. Specifically, NLP tools (e.g., SpaCy, NLTK) are used to split words and phrases into tokens.

[0595] Step 5:

[0596] The server uses a generative AI model to generate infrastructure management code based on the tokenized data. Specifically, the generative AI model constructs appropriate infrastructure management code based on the tokenized data. Examples of generative AI models that can be used include OpenAI's GPT-3. The input data is the tokenized data, and the output data is the generated code.

[0597] Step 6:

[0598] The server provides the generated infrastructure management code to the user. The server can email the generated code, provide a download link, or send it directly to the terminal. The input data is the generated code, and the output data is the code converted into a format that is provided to the user. For example, the generated Terraform code is attached to an email.

[0599] In this way, each processing step works in conjunction with the others, making it possible to efficiently and accurately generate the infrastructure management code required for a factory automation system.

[0600] 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.

[0601] As an embodiment of the present invention, a system for automatically generating infrastructure management code based on user input is constructed as follows: This system is combined with an emotion engine that recognizes user emotions.

[0602] This system acquires responses to multiple questions from users, analyzes them, and tokenizes them. It then uses an AI model to automatically generate infrastructure management codes based on the tokenized analysis results, and provides the generated codes to the user. It also uses an emotion engine to recognize user emotions, dynamically changing the content and format of questions and adjusting the interface design based on those emotions. Furthermore, the emotion data is saved along with the analysis results and can be used to generate future infrastructure management codes.

[0603] Program processing

[0604] Getting User Input

[0605] The user answers questions displayed on the device interface. For example, to the question "Which cloud provider do you use?", the user answers "AWS," and to the question "What region?", the user enters "us-west-2." The emotion engine recognizes the user's emotions in real time during the conversation, and the interface dynamically adjusts according to changes in emotion.

[0606] Sending input data

[0607] When the user completes the answer, the device sends the answer data to the server, along with the emotion data acquired by the emotion engine.

[0608] Receiving and analyzing response data

[0609] The server receives the response data and emotion data from the device and temporarily stores them, making each piece of data easier to access.

[0610] Emotional Data Processing

[0611] The server analyzes the emotion data acquired by the emotion engine and extracts patterns of the user's emotional changes. This data is used to dynamically adjust the content and format of questions.

[0612] Parsing and tokenizing response data

[0613] The server parses the received response data and maps each response to a corresponding attribute. For example, the response "AWS" maps to "cloud provider" and the response "us-west-2" maps to "region." The parsed results are tokenized and converted into a format that is easy for the AI ​​model to handle.

[0614] Auto-generation of infrastructure management code

[0615] The server uses generative AI models to generate infrastructure management code based on user responses and sentiment data, for example automatically generating Terraform code based on AWS configuration.

[0616] Providing generated code to users

[0617] The server stores the generated infrastructure management code and prepares it for delivery to the user. Specifically, it provides the ability to download it via a link, attach it to an email, or copy it. The user receives the code using their device and can review and modify it as needed.

[0618] Specific examples

[0619] For example, suppose a user answers the following question:

[0620] 1. Which cloud provider will you use? → "AWS"

[0621] 2. What region? → "us-west-2"

[0622] 3. What type of instance is it? → "t2.micro"

[0623] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0624] In addition to this answer, if the sentiment engine recognizes a positive sentiment, the server will generate the following Terraform code:

[0625] HCL

[0626] provider "aws" {

[0627] region = "us-west-2"

[0628] }

[0629] resource "aws_instance" "example" {

[0630] ami = "ami-0c55b159cbfafe1f0"

[0631] instance_type = "t2.micro"

[0632] }

[0633] Users can download this code and use Terraform to run the "terraform apply" command, which will create the specified instance on AWS.

[0634] This system reduces the burden on users, enables rapid and accurate generation of infrastructure management code, and provides a flexible interface that takes user feelings into consideration.

[0635] The processing flow will be explained below.

[0636] Step 1:

[0637] The user answers a number of questions displayed on the device interface. For example, in response to the question "Which cloud provider do you want to use?", the user enters "AWS." In response to the question "Which region?", the user answers "us-west-2."

[0638] Step 2:

[0639] The emotion engine analyzes the user's facial expressions and vocal tone in real time to recognize their emotional state, for example, using the camera and microphone to determine whether the user is smiling or sad.

[0640] Step 3:

[0641] The device temporarily stores the user's response data and the recognized emotion data, and then verifies that all questions have been answered. After verification, this data is compiled into a data packet.

[0642] Step 4:

[0643] When the user clicks the send button, the device sends a data packet containing the user's response data and emotion data to the server.

[0644] Step 5:

[0645] The server receives data packets from the device and stores them temporarily, allowing for quick access and analysis of the data.

[0646] Step 6:

[0647] The server parses the response data in the data packet and maps each response to a corresponding attribute, for example, the response "AWS" maps to "cloud provider" and "us-west-2" maps to "region".

[0648] Step 7:

[0649] The server analyzes the emotion data recognized by the emotion engine and integrates the response data with the emotion data. The recognized emotional state is reflected in the interface design and the content and format of the questions.

[0650] Step 8:

[0651] The server tokenizes the parsed response data and prepares it for input into the generative AI model. Tokenization makes the data more accessible to the AI ​​model.

[0652] Step 9:

[0653] The server uses generative AI models to automatically generate infrastructure management code based on the integrated data, for example, Terraform code if AWS is selected.

[0654] Step 10:

[0655] The server stores the generated infrastructure management code and then prepares it for delivery to the user, either via a link for download, email attachment, or copy function.

[0656] Step 11:

[0657] The user can view the generated code on the terminal, download or copy it as needed, and then use an infrastructure management tool (e.g., Terraform) to automatically deploy the infrastructure. Specifically, they run the "terraform apply" command.

[0658] Example 2

[0659] 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."

[0660] Conventional infrastructure management code generation systems do not take into account the user's emotional state, potentially resulting in a poor user experience. Manual code generation is also time-consuming, labor-intensive, and prone to errors. The present invention aims to address these issues and provide a system that automatically generates infrastructure management codes quickly and accurately, while improving the user experience.

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

[0662] In this invention, the server includes means for acquiring answers to a plurality of questions from a user, means for acquiring the acquired answers and emotional data of the user in the answers, means for analyzing the acquired answers and emotional data and tokenizing the analysis results, means for using an AI model to automatically generate an infrastructure management code based on the tokenized analysis results, means for providing the generated infrastructure management code to the user, means for dynamically adjusting the user's input interface based on the emotional data, and means for saving each processing result and using it for generating future infrastructure management codes. This makes it possible to provide a flexible interface that takes into account the emotional state of the user and to automatically generate infrastructure management codes quickly and accurately.

[0663] "User" refers to a user who answers questions to generate infrastructure management code using the system.

[0664] "Terminal" refers to a device used by a user to answer questions and send the answer data to a server.

[0665] "Emotion data" refers to information that indicates the user's emotional state and is acquired during user input.

[0666] "Server" refers to a device that receives and stores responses and emotion data sent by users, analyzes them, and generates infrastructure management code.

[0667] "Tokenization" refers to the process of analyzing the response data obtained and converting it into a format that is easy for an AI model to handle.

[0668] "Generative AI model" refers to an artificial intelligence model for automatically generating infrastructure management code based on tokenized analysis results.

[0669] "Infrastructure Management Code" means computer code used to automate the configuration and resource management of Cloud Services.

[0670] "Dynamic adjustment" refers to changing the content of the interface and the format of questions in real time based on the user's emotional data.

[0671] "Storage" refers to the server maintaining the acquired response data and emotion data in a state where it can be used for future processing.

[0672] This invention relates to a system that automatically generates infrastructure management codes based on user input and emotional data. The system acquires answers to multiple questions from the user and tokenizes them. It then uses a generative AI model based on the tokenized data to automatically generate infrastructure management codes. Furthermore, it uses an emotional engine to recognize the user's emotional state and utilizes that data for analysis. This improves the user experience and enables faster and more accurate generation of infrastructure management codes.

[0673] This system is implemented in a client-server model. The user answers questions through an interface on the device and sends the data to the server. The device is equipped with an emotion engine that obtains emotional data in real time from the user's facial expressions and tone of voice. The data is then transferred to the server via a secure communication method (e.g., HTTPS protocol).

[0674] The server stores the received response data and sentiment data in a database. The stored data is then analyzed, first parsing the response data and mapping each response to its corresponding attributes. The data is then tokenized and converted into a format that can be easily handled by the AI ​​model, using natural language processing techniques. A generative AI model generates infrastructure management code based on the tokenized data. This model uses a pre-trained model to generate code that corresponds to a specific cloud service (e.g., cloud provider or region configuration).

[0675] The generated code is stored on the server and provided to the user. Delivery methods include downloading via a link, attaching to an email, or copying. The user receives the generated code on their device and can review and modify it as needed. For example, they can run the generated code using Terraform to apply specific settings to a cloud environment.

[0676] Specific examples

[0677] For example, suppose a user answers the following question:

[0678] 1. Which cloud provider will you use? → "AWS"

[0679] 2. What region? → "us-west-2"

[0680] 3. What type of instance is it? → "t2.micro"

[0681] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0682] This response data and the data that the emotion engine recognized as positive emotions are sent to the server, which generates the following Terraform code based on this data.

[0683] HCL

[0684] provider "aws" {

[0685] region = "us-west-2"

[0686] }

[0687] resource "aws_instance" "example" {

[0688] ami = "ami-0c55b159cbfafe1f0"

[0689] instance_type = "t2.micro"

[0690] }

[0691] Users can download this code and use Terraform to create the specified instance on AWS by running the "terraform apply" command.

[0692] The system aims to reduce the burden on users and generate infrastructure management code quickly and accurately. It also provides a better user experience by taking into account the user's emotional state through an emotion engine.

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

[0694] Step 1: Getting User Input

[0695] The user answers multiple questions displayed on the device interface. Specifically, the device displays questions such as "Which cloud provider do you use?" and "Which region?", to which the user answers in text format. The device also uses a built-in emotion engine to analyze the user's facial expressions and tone of voice while they are entering their answers, obtaining emotional data in real time. Input: Text questions, answer data, and emotional data. Output: User's answer data and emotional data.

[0696] Step 2: Submitting input data

[0697] Once the user has answered all the questions, the device sends the answer data and emotion data to the server. Specifically, this data is securely transferred using the HTTPS protocol. Input: Answer data and emotion data entered by the user. Output: Data sent to the server.

[0698] Step 3: Receiving and storing response data

[0699] The server receives the response data and emotion data sent from the device. The server stores this data in a database and prepares it for later analysis. Input: Response data and emotion data sent from the device. Output: Data stored in the server's database.

[0700] Step 4: Analyze the sentiment data

[0701] The server analyzes the stored emotion data. Specifically, it uses the data obtained from the emotion engine to extract patterns of the user's emotion changes. For example, it determines whether the user is feeling stressed while answering questions. Input: Stored emotion data. Output: User's emotion change patterns.

[0702] Step 5: Parse and tokenize response data

[0703] The server parses the stored response data and maps each response to its corresponding attribute. The results of this analysis are then tokenized and converted into a format that the AI ​​model can easily handle. For example, the response "AWS" is mapped to "cloud provider" and the response "us-west-2" is mapped to "region." Input: Response data. Output: Tokenized data.

[0704] Step 6: Auto-generating infrastructure management code

[0705] The server uses a generative AI model to generate infrastructure management codes based on the tokenized analysis results. The generative AI model used here is a pre-trained model that generates appropriate codes based on the response data. Input: Tokenized analysis results. Output: Generated infrastructure management code.

[0706] Step 7: Provide the generated code to users

[0707] The server prepares the generated infrastructure management code for delivery to the user. For example, the generated code may be made available for download via a link or sent via email. The user downloads this code on their device and reviews and modifies it as needed. Input: Generated infrastructure management code. Output: Code provided to the user.

[0708] (Application example 2)

[0709] 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."

[0710] Conventional infrastructure management code generation systems generate codes based on user input data, but provide a uniform question format and interface without considering the user's emotional state, which does not adequately consider the user experience. Furthermore, because personalized content is not generated, it is difficult to provide optimal information to users.

[0711] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for acquiring answers to multiple questions from the user, means for analyzing the acquired answers and tokenizing the analysis results, means for using a model to automatically generate an infrastructure management code based on the tokenized analysis results, means for analyzing the acquired emotion data and dynamically changing the content and format of the question in response to changes in the user's emotion, and means for providing the generated infrastructure management code to the user. This makes it possible to provide a flexible question format and interface based on the user's emotional state, improving the user experience. Furthermore, by generating personalized content using the emotion data, it is possible to provide optimal information to the user.

[0712] "Answers to multiple questions from a user" refers to a collection of individual responses to multiple questions that a user inputs on an interface via a terminal.

[0713] "Analysis" is the process of clarifying the meaning and relationships of information and structuring it in order to convert acquired data into an understandable format.

[0714] "Tokenization" is the process of breaking down parsed data into elements and organizing them according to a prescribed format.

[0715] "Infrastructure management code" is program code for automating infrastructure management such as cloud services and servers.

[0716] A "model" refers to a machine learning algorithm designed to perform a specific task, taking data as input and producing an output.

[0717] "Emotion data" is data that indicates the emotional state of a user, and is usually obtained using techniques such as facial expression recognition and voice analysis.

[0718] "Dynamic change" refers to changes in real time based on the situation or conditions, following certain rules.

[0719] "Personalized content" refers to information and media that are customized to suit the preferences and circumstances of individual users.

[0720] "Terminal" refers to an apparatus or device operated by a user, including smartphones, tablets, and personal computers.

[0721] "Providing" refers to the act of delivering generated infrastructure management code and personalized content to a user.

[0722] MODE FOR CARRYING OUT THE INVENTION

[0723] The following system can be constructed as an embodiment of the present invention. The system uses user input data and emotion data to generate infrastructure management code and personalized content, achieving a flexible interface and optimal information provision.

[0724] System Program Description

[0725] The system mainly consists of the following elements: user device (smartphone or head-mounted display), server, emotion engine, and generative AI model.

[0726] Getting User Input

[0727] The user answers a number of questions displayed on the device, and the answer data is collected. For example, the user enters answers to the following questions:

[0728] 1. What is your favorite genre? → "SF"

[0729] 2. What type of content do you want to watch? → "Movies"

[0730] 3. What device will you be watching on? → "Smartphone"

[0731] Acquiring emotion data

[0732] The emotion engine recognizes the user's real-time emotions using a camera or microphone, for example, by using the emotion analysis API from Microsoft Azure Cognitive Services.

[0733] Sending input data and emotion data

[0734] The user's response data and emotion data are transmitted from the terminal to the server.

[0735] Data Parsing and Tokenization

[0736] The server parses the received data and maps each response to a corresponding attribute, and the results are tokenized and converted into a format that is easy for the generative AI model to understand.

[0737] Infrastructure management code generation

[0738] The server uses generative AI models based on the tokenized data to generate infrastructure management code, for example, automatically generating Terraform code based on cloud configuration.

[0739] Personalized content generation

[0740] The server uses the user's responses and emotion data to generate personalized content, such as a list of movies in the science fiction genre that the user wants to watch on their smartphone.

[0741] Examples:

[0742] Based on the user's response and positive sentiment, the following prompt sentence is fed into the generative AI model:

[0743] The user indicated that they would like to watch movies in the sci-fi genre on their smartphone. This indicates a positive sentiment. Please generate a list of recommendations for the best content.

[0744] Based on this, the generative AI model generates a list of highly rated sci-fi movies such as "Interstellar" and "The Matrix."

[0745] Providing generated code and content

[0746] The generated infrastructure management code and personalized content are sent to the user's device for easy access by the user, either via a download link, email notification, or display of a content list on the device.

[0747] As a result, a system can be constructed that provides flexible question formats and interfaces that correspond to the user's emotional state, improves the user experience, and provides optimal information.

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

[0749] Step 1:

[0750] The user inputs answers to multiple questions displayed on the device. For example, the user answers questions such as "my favorite genre is SF," "the type of content I want to watch is movies," and "the device I want to watch it on is a smartphone." This input data is obtained from the user's interface. The device temporarily stores the user's answers obtained here.

[0751] Step 2:

[0752] The device uses an emotion engine to capture the user's emotional data in real time. It analyzes the user's facial expressions and tone of voice through a camera and microphone to recognize their emotional state, such as positive, negative, or neutral. This emotional data is then prepared for transmission along with the response data.

[0753] Step 3:

[0754] The device sends the acquired response data and emotion data to the server. Data transmission uses an encryption protocol (e.g., HTTPS) to protect the security and privacy of the data.

[0755] Step 4:

[0756] The server receives the response data and emotion data from the device and temporarily stores them. The stored data is structured so that it can be analyzed.

[0757] Step 5:

[0758] The server analyzes the received response data and maps each response to a corresponding attribute. For example, the response "science fiction" is mapped to "genre," "movie" to "content type," and "smartphone" to "device." The analysis results are converted into tokens and organized into a format that is easy for the generative AI model to use.

[0759] Step 6:

[0760] The server analyzes the emotion data. Based on the acquired data, the emotion engine extracts patterns of the user's emotional changes. For example, if the user is expressing positive emotions, the content and format of the questions are dynamically adjusted according to that emotional state.

[0761] Step 7:

[0762] The server uses a generative AI model to generate infrastructure management code based on the tokenized response data and sentiment data. For example, Terraform code can be automatically generated based on cloud service configuration. The generation process uses a trained model to generate code based on the specified prompt.

[0763] Step 8:

[0764] The server generates personalized content based on the user's input and emotional data. For example, if a user responds that they would like to watch science fiction movies on their smartphone, the server generates a list of highly rated science fiction movies. The generated content list includes information based on specific keywords and the user's emotions.

[0765] Step 9:

[0766] The server provides the generated infrastructure management code and personalized content to the user's device. The delivery methods include download links, email attachments, and display on the device. The user can access the generated code and content list using the device and check or use it as needed.

[0767] Through each of the above steps, users can experience flexible question formats and personalized content that adapts to their emotional state, enabling quick and accurate generation of infrastructure management codes.

[0768] 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.

[0769] 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.

[0770] 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.

[0771] [Third embodiment]

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

[0773] 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.

[0774] 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).

[0775] 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.

[0776] 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.

[0777] 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).

[0778] 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.

[0779] 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.

[0780] 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.

[0781] 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.

[0782] 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.

[0783] 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."

[0784] As an embodiment of the present invention, a system for automatically generating infrastructure management code based on input from a user is constructed as follows.

[0785] The system acquires answers to multiple questions from users, analyzes and tokenizes them, and then uses an AI model to automatically generate infrastructure management codes based on the tokenized analysis results, and provides the generated codes to the user.

[0786] Program processing

[0787] Getting User Input

[0788] The user answers questions displayed on the device interface, such as "Which cloud provider will you use?", and answers "AWS." In this way, the user gradually answers questions about their infrastructure requirements.

[0789] Sending input data

[0790] Once the user has answered all the questions, the device sends the answer data to the server, where it is formatted in a way that makes it easy for the server to analyze.

[0791] Receiving and analyzing response data

[0792] The server analyzes the response data received from the device and maps each response to a corresponding attribute, for example, the response "AWS" is mapped to "Cloud Provider."

[0793] Preprocessing with AI models

[0794] The server tokenizes the parsed data to power the generative AI model, which then generates the infrastructure management code in a suitable format.

[0795] Auto-generation of infrastructure management code

[0796] The server uses generative AI models to generate infrastructure management code based on the user's answers. For example, if you select AWS, Terraform code is automatically generated.

[0797] Providing generated code to users

[0798] The server provides the generated infrastructure management code to the user via a link, email attachment, or copy function, allowing the user to receive the code and modify it as needed.

[0799] Specific examples

[0800] For example, suppose a user answers the following question:

[0801] 1. Which cloud provider will you use? → "AWS"

[0802] 2. What region? → "us-west-2"

[0803] 3. What type of instance is it? → "t2.micro"

[0804] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0805] Based on this answer, the server will generate the following Terraform code:

[0806] HCL

[0807] provider "aws" {

[0808] region = "us-west-2"

[0809] }

[0810] resource "aws_instance" "example" {

[0811] ami = "ami-0c55b159cbfafe1f0"

[0812] instance_type = "t2.micro"

[0813] }

[0814] Users can download this code and use Terraform to run the "terraform apply" command, which will create the specified instance on AWS.

[0815] Thus, the present invention is a system that reduces the burden on the user and can generate infrastructure management codes quickly and accurately.

[0816] The processing flow will be explained below.

[0817] Step 1:

[0818] The user answers questions displayed on the device interface. For example, to the question "Which cloud provider do you want to use?", they answer "AWS," and to the question "Which region?", they enter "us-west-2."

[0819] Step 2:

[0820] The device temporarily stores the user's input and confirms that all questions have been answered. Once this is confirmed, the device prepares to send the input data to the server.

[0821] Step 3:

[0822] The user clicks the send button. This causes the device to send the response data to the server, which converts the data into a format that is easy to analyze, such as JSON.

[0823] Step 4:

[0824] The server receives the response data from the terminal and temporarily stores it, making it easier to access the response data.

[0825] Step 5:

[0826] The server analyzes the received response data and maps the responses to the respective questions. For example, the response "AWS" maps to "cloud provider" and "us-west-2" maps to "region."

[0827] Step 6:

[0828] The server tokenizes the parsed data, which is the process of converting the parsed data into a format that is easy for the generative AI model to use.

[0829] Step 7:

[0830] The server feeds the tokenized analytics data into a generative AI model to generate infrastructure management code, for example, automatically generating Terraform code based on AWS configuration.

[0831] Step 8:

[0832] The server stores the generated infrastructure management code and prepares it for later distribution to the user.

[0833] Step 9:

[0834] The server chooses how to provide the generated code, displaying a download link, email attachment, or a pop-up for copying to the user.

[0835] Step 10:

[0836] Users can view the generated code on their device, download or copy it as needed, and then use infrastructure management tools (e.g., Terraform) to automate the deployment of the infrastructure.

[0837] Example 1

[0838] 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."

[0839] In today's cloud computing environment, manually creating infrastructure management code requires a great deal of effort and specialized knowledge. Furthermore, it is not easy to generate code accurately and quickly based on user responses to multiple questions. It is also difficult to select the optimal cloud service based on the user's requirements. Therefore, there is a need for a system that can automatically generate infrastructure management code more efficiently and accurately and provide it to users.

[0840] 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.

[0841] In this invention, the server includes means for acquiring answers to a plurality of questions from a user, means for transmitting the acquired answers to the server, means for analyzing the answers received by the server and tokenizing the analysis results, means for using an AI model to automatically generate an infrastructure management code based on the tokenized analysis results, and means for providing the generated infrastructure management code to the user, thereby enabling the user to quickly and accurately generate an infrastructure management code without requiring specialized knowledge.

[0842] A "user" is an individual or entity that uses a computer system or service.

[0843] "Questionnaire" refers to a specific question or request for information posed to a user regarding infrastructure requirements.

[0844] "Answer" refers to information or data provided by a user in response to a question.

[0845] A "terminal" is hardware and related software used by a user, such as a computer or mobile device.

[0846] A "server" is a computer system that provides data and services over a network.

[0847] "Analysis" refers to the process of converting or classifying the obtained answers into an understandable form.

[0848] "Tokenization" is the process of converting analyzed data into a form that is understandable to a generative AI model.

[0849] "Infrastructure Management Code" means program code used to configure and manage cloud services and computer infrastructure.

[0850] A "generative AI model" refers to an artificial intelligence algorithm that automates specific tasks based on pre-trained data.

[0851] "Providing" refers to the act of making the generated infrastructure management code available to users.

[0852] A "cloud service" is a service that provides computing resources (e.g., servers, storage, databases) via the Internet.

[0853] This invention is a system that automatically generates infrastructure management codes based on user input. The system acquires answers to multiple questions from the user, analyzes and tokenizes them, and generates infrastructure management codes using a generative AI model.

[0854] First, the user uses the device to answer a series of questions displayed on the interface. For example, to the question, "Which cloud provider do you want to use?", the user answers "AWS." In this way, the user answers questions one by one.

[0855] After the user has answered all the questions, the device sends the answer data to the server, which can then be structured in JSON format, for example, so that the server can easily parse it.

[0856] The server analyzes the received response data and maps each response to a corresponding attribute. For example, the response "AWS" is mapped to the attribute "Cloud Provider." This analysis is performed by an analysis engine running on the server.

[0857] The server tokenizes the parsed data. Tokenization is the process of converting data into a format that is easy for the generative AI model to understand. For example, "Cloud provider: AWS" is converted into "TOKEN_PROVIDER_AWS". A library such as Python can be used for this tokenization process.

[0858] The server then uses a generative AI model to automatically generate infrastructure management code based on the tokenized data. For example, if a user selects "AWS," provides "us-west-2" as the region, "t2.micro" as the instance type, and "ami-0c55b159cbfafe1f0" as the AMI ID, the AI ​​model can use this information to generate Terraform code, etc.

[0859] The generated infrastructure management code is provided to the user from the server via various methods, including a download link, email attachment, or copy to the clipboard. The user can then receive the code via their device and modify it as needed.

[0860] As a concrete example, suppose the user answers the following question:

[0861] 1. Which cloud provider will you use? → "AWS"

[0862] 2. What region? → "us-west-2"

[0863] 3. What type of instance is it? → "t2.micro"

[0864] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0865] Based on this answer, the server can generate the following Terraform code:

[0866] provider "aws" {

[0867] region = "us-west-2"

[0868] }

[0869] resource "aws_instance" "example" {

[0870] ami = "ami-0c55b159cbfafe1f0"

[0871] instance_type = "t2.micro"

[0872] }

[0873] In this way, the present invention utilizes a generative AI model to automatically generate infrastructure management code without requiring users to have specialized knowledge, enabling them to quickly and accurately configure cloud infrastructure.

[0874] Example prompt sentence:

[0875] Please generate an infrastructure management code based on your answers to the following questions about your cloud infrastructure configuration.

[0876] Provider: AWS

[0877] Region: us-west-2

[0878] Instance type: t2.micro

[0879] AMI ID: ami-0c55b159cbfafe1f0

[0880] Using this prompt, the AI ​​model can generate the necessary infrastructure management code.

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

[0882] Step 1:

[0883] The user answers the question. The user enters input into the question displayed on the device interface. For example, the user enters "AWS" in response to the question "Which cloud provider do you want to use?", or "us-west-2" in response to the question "Which region do you want to use?". The data entered by the user is temporarily stored on the device. Example of input data: {"Cloud provider": "AWS", "Region": "us-west-2"}.

[0884] Step 2:

[0885] The device sends the answer data to the server. Once the user has answered all the questions, the device structures the answer data (for example, in JSON format) and sends it to the server. Data is sent using an HTTP POST request. Example of sent data: {"Cloud provider": "AWS", "Region": "us-west-2"}.

[0886] Step 3:

[0887] The server receives and parses the data. The server receives the data sent from the device and parses it. For example, the answer "AWS" is mapped to an attribute called "Cloud Provider", and the answer "us-west-2" is mapped to an attribute called "Region". Once parsed, the data is converted into an internal data structure. Input data: {"Cloud Provider": "AWS", "Region": "us-west-2"}, Output data: {"Attribute 1": "Cloud Provider", "Value 1": "AWS", "Attribute 2": "Region", "Value 2": "us-west-2"}.

[0888] Step 4:

[0889] The server tokenizes the data. The analyzed data is converted into a format that is easy for the generative AI model to understand. For example, "Cloud provider: AWS" is tokenized as "TOKEN_PROVIDER_AWS" and "Region: us-west-2" is tokenized as "TOKEN_REGION_US_WEST_2". This tokenization is performed using a Python library or similar. Input data: {"Attribute 1": "Cloud provider", "Value 1": "AWS", "Attribute 2": "Region", "Value 2": "us-west-2"}, Output data: ["TOKEN_PROVIDER_AWS", "TOKEN_REGION_US_WEST_2"].

[0890] Step 5:

[0891] The server automatically generates infrastructure management code. The server passes the tokenized data to the generation AI model, which then generates the infrastructure management code. For example, if a user selects "AWS," specifies "us-west-2" as the region, selects "t2.micro" as the instance type, and provides "ami-0c55b159cbfafe1f0" as the AMI ID, the AI ​​model generates the following Terraform code:

[0892] HCL

[0893] provider "aws" {

[0894] region = "us-west-2"

[0895] }

[0896] resource "aws_instance" "example" {

[0897] ami = "ami-0c55b159cbfafe1f0"

[0898] instance_type = "t2.micro"

[0899] }

[0900] Input data: ["TOKEN_PROVIDER_AWS", "TOKEN_REGION_US_WEST_2", "TOKEN_INSTANCE_TYPE_T2_MICRO", "TOKEN_AMI_ID_0C55B159CBFAFE1F0"], Output data: Generated Terraform code.

[0901] Step 6:

[0902] The server provides the generated infrastructure management code to the user. The server has various methods for providing the generated code to the user, such as a download link, email attachment, or copy to the clipboard. The user can receive the code using these methods and make modifications as needed. Input data: the generated Terraform code, output data: the method of delivery such as a download link or email.

[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] In modern manufacturing, efficient control settings for factory robots, network configuration, and database management are important challenges. However, conventional methods require these settings to be performed manually, which requires a great deal of time and effort and increases the risk of configuration errors. A method to resolve these issues and efficiently and accurately manage factory automation systems is needed.

[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 acquiring answers to a plurality of questions from a user; means for analyzing the acquired answers and tokenizing the analysis results; means for using a generative AI model to automatically generate an infrastructure management code based on the tokenized analysis results; means for providing the generated infrastructure management code to the user; means for inputting requirements for an automation system in a factory using a smartphone or tablet; and means for automatically generating infrastructure management codes for controlling factory robots based on the input requirements. This eliminates the need for factory operators to manually perform complex settings, enabling efficient and accurate generation of infrastructure management codes and smooth operation of the factory automation system.

[0908] A "user" is a person who uses the system to answer questions and request the generation of an infrastructure management code.

[0909] The "question items" are items that the user answers to obtain information necessary for generating the infrastructure management code.

[0910] An "answer" is information provided by a user in response to a question item.

[0911] "Tokenization" refers to converting parsed data into a format that can be processed by a generative AI model.

[0912] "Infrastructure management code" is code related to the management and configuration of infrastructure structures, and is automatically generated by this system.

[0913] A "generative AI model" is an artificial intelligence model that analyzes user response data and generates infrastructure management code.

[0914] "Server" means the part of the system that analyzes user response data and generates and provides infrastructure management code.

[0915] A "smartphone or tablet" is a mobile device that a user uses to answer questions.

[0916] An "in-factory automation system" is an automated operational system that includes robot control, network configuration, and database management in a factory.

[0917] "Requirements" refer to the specific terms of use and settings for controlling factory robots, network configuration, and database management.

[0918] "Terminal" means a device utilized by a User to receive a generated Infrastructure Management Code.

[0919] The system for implementing this invention is designed to automatically generate infrastructure management code for automation systems in factories. The following describes the programming process that implements this system and how it is implemented in hardware and software.

[0920] Program Overview

[0921] The system allows users to use a smartphone or tablet to input requirements for infrastructure management, and automatically generates code based on that input for controlling factory robots, configuring networks, and managing databases.

[0922] Getting User Input

[0923] Users answer step-by-step questions displayed in an interface on their device, provided by an application installed on their smartphone or tablet. Example questions include:

[0924] "What robot model?"

[0925] "What area?"

[0926] "What's your network setup?"

[0927] "What about the database?"

[0928] For example, a user may answer "Robot A" to the question "What is the robot model?" This answer is similarly obtained for other questions.

[0929] Data transmission

[0930] Once the user has answered all the questions, the device sends the answer data to the server using the Python requests library or similar.

[0931] Receiving and analyzing response data

[0932] The server analyzes the response data received from the device and maps each response to a corresponding attribute. For example, the response "Robot A" is mapped to "Robot Model."

[0933] Preprocessing with AI models

[0934] The server then tokenizes the parsed data to power the generative AI model, using natural language processing (NLP) techniques, and the tokenized data is then formatted in a way that is suitable for generating infrastructure management code.

[0935] Auto-generation of infrastructure management code

[0936] The server uses a generative AI model to generate infrastructure management code based on the user's answers. For example, if "Robot A" is selected, the corresponding control code is automatically generated.

[0937] Providing generated code to users

[0938] The server provides the generated infrastructure management code to the user via a link, email attachment, or copy function, allowing the user to receive the code and modify it as needed.

[0939] Hardware and software used

[0940] Hardware: smartphones, tablets, servers

[0941] software:

[0942] User Interface: Mobile Application

[0943] Sending data: Python's requests library

[0944] Data Analysis and Tokenization: Natural Language Processing (NLP) Techniques

[0945] Generative AI model: An AI model for automatically generating infrastructure management code

[0946] Specific examples

[0947] For example, if a user answers the following questions:

[0948] 1. "What robot model is it?" → "Robot A"

[0949] 2. "What area?" → "Production Line 1"

[0950] 3. "What is your network setting?" → "DHCP"

[0951] 4. "What database?" → "PostgreSQL"

[0952] Based on this, the server generates infrastructure management code such as:

[0953] An example prompt might look like this:

[0954] "What robot model?"

[0955] "What area?"

[0956] "What's your network setup?"

[0957] "What about the database?"

[0958] This system eliminates the need for factory operators to manually configure complex settings, allowing them to efficiently and accurately generate infrastructure management code and ensure the smooth operation of factory automation systems.

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

[0960] Step 1:

[0961] The user uses a smartphone or tablet to input requirements for the factory automation system. They answer questions displayed on the user interface one by one. The information entered includes the robot model, area, network settings, database, etc. The data entered by the user is in text format, and answers are obtained for each question.

[0962] Step 2:

[0963] The device formats the user's answer data and sends it to the server, where it is converted to JSON format and sent to the server using a reliable communication protocol (e.g., HTTPS). The input data includes each of the user's answers, and the output data sent to the server is formatted JSON data.

[0964] Step 3:

[0965] The server analyzes the response data received from the device and maps each response to the corresponding attribute. Specifically, the server parses the received JSON data using an analysis tool, and the response "Robot A" is mapped as the "robot model." The input data is the JSON-formatted response data, and the output data is the data mapped to the attributes.

[0966] Step 4:

[0967] The server tokenizes the parsed data. The parsed attribute data is converted into tokens using natural language processing (NLP) techniques. At this point, the data is in a format that is easy for the generative AI model to process. The input data is data mapped to attributes, and the output data is tokenized data. Specifically, NLP tools (e.g., SpaCy, NLTK) are used to split words and phrases into tokens.

[0968] Step 5:

[0969] The server uses a generative AI model to generate infrastructure management code based on the tokenized data. Specifically, the generative AI model constructs appropriate infrastructure management code based on the tokenized data. Examples of generative AI models that can be used include OpenAI's GPT-3. The input data is the tokenized data, and the output data is the generated code.

[0970] Step 6:

[0971] The server provides the generated infrastructure management code to the user. The server can email the generated code, provide a download link, or send it directly to the terminal. The input data is the generated code, and the output data is the code converted into a format that is provided to the user. For example, the generated Terraform code is attached to an email.

[0972] In this way, each processing step works in conjunction with the others, making it possible to efficiently and accurately generate the infrastructure management code required for a factory automation system.

[0973] 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.

[0974] As an embodiment of the present invention, a system for automatically generating infrastructure management code based on user input is constructed as follows: This system is combined with an emotion engine that recognizes user emotions.

[0975] This system acquires responses to multiple questions from users, analyzes them, and tokenizes them. It then uses an AI model to automatically generate infrastructure management codes based on the tokenized analysis results, and provides the generated codes to the user. It also uses an emotion engine to recognize user emotions, dynamically changing the content and format of questions and adjusting the interface design based on those emotions. Furthermore, the emotion data is saved along with the analysis results and can be used to generate future infrastructure management codes.

[0976] Program processing

[0977] Getting User Input

[0978] The user answers questions displayed on the device interface. For example, to the question "Which cloud provider do you use?", the user answers "AWS," and to the question "What region?", the user enters "us-west-2." The emotion engine recognizes the user's emotions in real time during the conversation, and the interface dynamically adjusts according to changes in emotion.

[0979] Sending input data

[0980] When the user completes the answer, the device sends the answer data to the server, along with the emotion data acquired by the emotion engine.

[0981] Receiving and analyzing response data

[0982] The server receives the response data and emotion data from the device and temporarily stores them, making each piece of data easier to access.

[0983] Emotional Data Processing

[0984] The server analyzes the emotion data acquired by the emotion engine and extracts patterns of the user's emotional changes. This data is used to dynamically adjust the content and format of questions.

[0985] Parsing and tokenizing response data

[0986] The server parses the received response data and maps each response to a corresponding attribute. For example, the response "AWS" maps to "cloud provider" and the response "us-west-2" maps to "region." The parsed results are tokenized and converted into a format that is easy for the AI ​​model to handle.

[0987] Auto-generation of infrastructure management code

[0988] The server uses generative AI models to generate infrastructure management code based on user responses and sentiment data, for example automatically generating Terraform code based on AWS configuration.

[0989] Providing generated code to users

[0990] The server stores the generated infrastructure management code and prepares it for delivery to the user. Specifically, it provides the ability to download it via a link, attach it to an email, or copy it. The user receives the code using their device and can review and modify it as needed.

[0991] Specific examples

[0992] For example, suppose a user answers the following question:

[0993] 1. Which cloud provider will you use? → "AWS"

[0994] 2. What region? → "us-west-2"

[0995] 3. What type of instance is it? → "t2.micro"

[0996] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[0997] In addition to this answer, if the sentiment engine recognizes a positive sentiment, the server will generate the following Terraform code:

[0998] HCL

[0999] provider "aws" {

[1000] region = "us-west-2"

[1001] }

[1002] resource "aws_instance" "example" {

[1003] ami = "ami-0c55b159cbfafe1f0"

[1004] instance_type = "t2.micro"

[1005] }

[1006] Users can download this code and use Terraform to run the "terraform apply" command, which will create the specified instance on AWS.

[1007] This system reduces the burden on users, enables rapid and accurate generation of infrastructure management code, and provides a flexible interface that takes user feelings into consideration.

[1008] The processing flow will be explained below.

[1009] Step 1:

[1010] The user answers a number of questions displayed on the device interface. For example, in response to the question "Which cloud provider do you want to use?", the user enters "AWS." In response to the question "Which region?", the user answers "us-west-2."

[1011] Step 2:

[1012] The emotion engine analyzes the user's facial expressions and vocal tone in real time to recognize their emotional state, for example, using the camera and microphone to determine whether the user is smiling or sad.

[1013] Step 3:

[1014] The device temporarily stores the user's response data and the recognized emotion data, and then verifies that all questions have been answered. After verification, this data is compiled into a data packet.

[1015] Step 4:

[1016] When the user clicks the send button, the device sends a data packet containing the user's response data and emotion data to the server.

[1017] Step 5:

[1018] The server receives data packets from the device and stores them temporarily, allowing for quick access and analysis of the data.

[1019] Step 6:

[1020] The server parses the response data in the data packet and maps each response to a corresponding attribute, for example, the response "AWS" maps to "cloud provider" and "us-west-2" maps to "region".

[1021] Step 7:

[1022] The server analyzes the emotion data recognized by the emotion engine and integrates the response data with the emotion data. The recognized emotional state is reflected in the interface design and the content and format of the questions.

[1023] Step 8:

[1024] The server tokenizes the parsed response data and prepares it for input into the generative AI model. Tokenization makes the data more accessible to the AI ​​model.

[1025] Step 9:

[1026] The server uses generative AI models to automatically generate infrastructure management code based on the integrated data, for example, Terraform code if AWS is selected.

[1027] Step 10:

[1028] The server stores the generated infrastructure management code and then prepares it for delivery to the user, either via a link for download, email attachment, or copy function.

[1029] Step 11:

[1030] The user can view the generated code on the terminal, download or copy it as needed, and then use an infrastructure management tool (e.g., Terraform) to automatically deploy the infrastructure. Specifically, they run the "terraform apply" command.

[1031] Example 2

[1032] 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."

[1033] Conventional infrastructure management code generation systems do not take into account the user's emotional state, potentially resulting in a poor user experience. Manual code generation is also time-consuming, labor-intensive, and prone to errors. The present invention aims to address these issues and provide a system that automatically generates infrastructure management codes quickly and accurately, while improving the user experience.

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

[1035] In this invention, the server includes means for acquiring answers to a plurality of questions from a user, means for acquiring the acquired answers and emotional data of the user in the answers, means for analyzing the acquired answers and emotional data and tokenizing the analysis results, means for using an AI model to automatically generate an infrastructure management code based on the tokenized analysis results, means for providing the generated infrastructure management code to the user, means for dynamically adjusting the user's input interface based on the emotional data, and means for saving each processing result and using it for generating future infrastructure management codes. This makes it possible to provide a flexible interface that takes into account the emotional state of the user and to automatically generate infrastructure management codes quickly and accurately.

[1036] "User" refers to a user who answers questions to generate infrastructure management code using the system.

[1037] "Terminal" refers to a device used by a user to answer questions and send the answer data to a server.

[1038] "Emotion data" refers to information that indicates the user's emotional state and is acquired during user input.

[1039] "Server" refers to a device that receives and stores responses and emotion data sent by users, analyzes them, and generates infrastructure management code.

[1040] "Tokenization" refers to the process of analyzing the response data obtained and converting it into a format that is easy for an AI model to handle.

[1041] "Generative AI model" refers to an artificial intelligence model for automatically generating infrastructure management code based on tokenized analysis results.

[1042] "Infrastructure Management Code" means computer code used to automate the configuration and resource management of Cloud Services.

[1043] "Dynamic adjustment" refers to changing the content of the interface and the format of questions in real time based on the user's emotional data.

[1044] "Storage" refers to the server maintaining the acquired response data and emotion data in a state where it can be used for future processing.

[1045] This invention relates to a system that automatically generates infrastructure management codes based on user input and emotional data. The system acquires answers to multiple questions from the user and tokenizes them. It then uses a generative AI model based on the tokenized data to automatically generate infrastructure management codes. Furthermore, it uses an emotional engine to recognize the user's emotional state and utilizes that data for analysis. This improves the user experience and enables faster and more accurate generation of infrastructure management codes.

[1046] This system is implemented in a client-server model. The user answers questions through an interface on the device and sends the data to the server. The device is equipped with an emotion engine that obtains emotional data in real time from the user's facial expressions and tone of voice. The data is then transferred to the server via a secure communication method (e.g., HTTPS protocol).

[1047] The server stores the received response data and sentiment data in a database. The stored data is then analyzed, first parsing the response data and mapping each response to its corresponding attributes. The data is then tokenized and converted into a format that can be easily handled by the AI ​​model, using natural language processing techniques. A generative AI model generates infrastructure management code based on the tokenized data. This model uses a pre-trained model to generate code that corresponds to a specific cloud service (e.g., cloud provider or region configuration).

[1048] The generated code is stored on the server and provided to the user. Delivery methods include downloading via a link, attaching to an email, or copying. The user receives the generated code on their device and can review and modify it as needed. For example, they can run the generated code using Terraform to apply specific settings to a cloud environment.

[1049] Specific examples

[1050] For example, suppose a user answers the following question:

[1051] 1. Which cloud provider will you use? → "AWS"

[1052] 2. What region? → "us-west-2"

[1053] 3. What type of instance is it? → "t2.micro"

[1054] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[1055] This response data and the data that the emotion engine recognized as positive emotions are sent to the server, which generates the following Terraform code based on this data.

[1056] HCL

[1057] provider "aws" {

[1058] region = "us-west-2"

[1059] }

[1060] resource "aws_instance" "example" {

[1061] ami = "ami-0c55b159cbfafe1f0"

[1062] instance_type = "t2.micro"

[1063] }

[1064] Users can download this code and use Terraform to create the specified instance on AWS by running the "terraform apply" command.

[1065] The system aims to reduce the burden on users and generate infrastructure management code quickly and accurately. It also provides a better user experience by taking into account the user's emotional state through an emotion engine.

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

[1067] Step 1: Getting User Input

[1068] The user answers multiple questions displayed on the device interface. Specifically, the device displays questions such as "Which cloud provider do you use?" and "Which region?", to which the user answers in text format. The device also uses a built-in emotion engine to analyze the user's facial expressions and tone of voice while they are entering their answers, obtaining emotional data in real time. Input: Text questions, answer data, and emotional data. Output: User's answer data and emotional data.

[1069] Step 2: Submitting input data

[1070] Once the user has answered all the questions, the device sends the answer data and emotion data to the server. Specifically, this data is securely transferred using the HTTPS protocol. Input: Answer data and emotion data entered by the user. Output: Data sent to the server.

[1071] Step 3: Receiving and storing response data

[1072] The server receives the response data and emotion data sent from the device. The server stores this data in a database and prepares it for later analysis. Input: Response data and emotion data sent from the device. Output: Data stored in the server's database.

[1073] Step 4: Analyze the sentiment data

[1074] The server analyzes the stored emotion data. Specifically, it uses the data obtained from the emotion engine to extract patterns of the user's emotion changes. For example, it determines whether the user is feeling stressed while answering questions. Input: Stored emotion data. Output: User's emotion change patterns.

[1075] Step 5: Parse and tokenize response data

[1076] The server parses the stored response data and maps each response to its corresponding attribute. The results of this analysis are then tokenized and converted into a format that the AI ​​model can easily handle. For example, the response "AWS" is mapped to "cloud provider" and the response "us-west-2" is mapped to "region." Input: Response data. Output: Tokenized data.

[1077] Step 6: Auto-generating infrastructure management code

[1078] The server uses a generative AI model to generate infrastructure management codes based on the tokenized analysis results. The generative AI model used here is a pre-trained model that generates appropriate codes based on the response data. Input: Tokenized analysis results. Output: Generated infrastructure management code.

[1079] Step 7: Provide the generated code to users

[1080] The server prepares the generated infrastructure management code for delivery to the user. For example, the generated code may be made available for download via a link or sent via email. The user downloads this code on their device and reviews and modifies it as needed. Input: Generated infrastructure management code. Output: Code provided to the user.

[1081] (Application example 2)

[1082] 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."

[1083] Conventional infrastructure management code generation systems generate codes based on user input data, but provide a uniform question format and interface without considering the user's emotional state, which does not adequately consider the user experience. Furthermore, because personalized content is not generated, it is difficult to provide optimal information to users.

[1084] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for acquiring answers to multiple questions from the user, means for analyzing the acquired answers and tokenizing the analysis results, means for using a model to automatically generate an infrastructure management code based on the tokenized analysis results, means for analyzing the acquired emotion data and dynamically changing the content and format of the question in response to changes in the user's emotion, and means for providing the generated infrastructure management code to the user. This makes it possible to provide a flexible question format and interface based on the user's emotional state, improving the user experience. Furthermore, by generating personalized content using the emotion data, it is possible to provide optimal information to the user.

[1085] "Answers to multiple questions from a user" refers to a collection of individual responses to multiple questions that a user inputs on an interface via a terminal.

[1086] "Analysis" is the process of clarifying the meaning and relationships of information and structuring it in order to convert acquired data into an understandable format.

[1087] "Tokenization" is the process of breaking down parsed data into elements and organizing them according to a prescribed format.

[1088] "Infrastructure management code" is program code for automating infrastructure management such as cloud services and servers.

[1089] A "model" refers to a machine learning algorithm designed to perform a specific task, taking data as input and producing an output.

[1090] "Emotion data" is data that indicates the emotional state of a user, and is usually obtained using techniques such as facial expression recognition and voice analysis.

[1091] "Dynamic change" refers to changes in real time based on the situation or conditions, following certain rules.

[1092] "Personalized content" refers to information and media that are customized to suit the preferences and circumstances of individual users.

[1093] "Terminal" refers to an apparatus or device operated by a user, including smartphones, tablets, and personal computers.

[1094] "Providing" refers to the act of delivering generated infrastructure management code and personalized content to a user.

[1095] MODE FOR CARRYING OUT THE INVENTION

[1096] The following system can be constructed as an embodiment of the present invention. The system uses user input data and emotion data to generate infrastructure management code and personalized content, achieving a flexible interface and optimal information provision.

[1097] System Program Description

[1098] The system mainly consists of the following elements: user device (smartphone or head-mounted display), server, emotion engine, and generative AI model.

[1099] Getting User Input

[1100] The user answers a number of questions displayed on the device, and the answer data is collected. For example, the user enters answers to the following questions:

[1101] 1. What is your favorite genre? → "SF"

[1102] 2. What type of content do you want to watch? → "Movies"

[1103] 3. What device will you be watching on? → "Smartphone"

[1104] Acquiring emotion data

[1105] The emotion engine recognizes the user's real-time emotions using a camera or microphone, for example, by using the emotion analysis API from Microsoft Azure Cognitive Services.

[1106] Sending input data and emotion data

[1107] The user's response data and emotion data are transmitted from the terminal to the server.

[1108] Data Parsing and Tokenization

[1109] The server parses the received data and maps each response to a corresponding attribute, and the results are tokenized and converted into a format that is easy for the generative AI model to understand.

[1110] Infrastructure management code generation

[1111] The server uses generative AI models based on the tokenized data to generate infrastructure management code, for example, automatically generating Terraform code based on cloud configuration.

[1112] Personalized content generation

[1113] The server uses the user's responses and emotion data to generate personalized content, such as a list of movies in the science fiction genre that the user wants to watch on their smartphone.

[1114] Examples:

[1115] Based on the user's response and positive sentiment, the following prompt sentence is fed into the generative AI model:

[1116] The user indicated that they would like to watch movies in the sci-fi genre on their smartphone. This indicates a positive sentiment. Please generate a list of recommendations for the best content.

[1117] Based on this, the generative AI model generates a list of highly rated sci-fi movies such as "Interstellar" and "The Matrix."

[1118] Providing generated code and content

[1119] The generated infrastructure management code and personalized content are sent to the user's device for easy access by the user, either via a download link, email notification, or display of a content list on the device.

[1120] As a result, a system can be constructed that provides flexible question formats and interfaces that correspond to the user's emotional state, improves the user experience, and provides optimal information.

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

[1122] Step 1:

[1123] The user inputs answers to multiple questions displayed on the device. For example, the user answers questions such as "my favorite genre is SF," "the type of content I want to watch is movies," and "the device I want to watch it on is a smartphone." This input data is obtained from the user's interface. The device temporarily stores the user's answers obtained here.

[1124] Step 2:

[1125] The device uses an emotion engine to capture the user's emotional data in real time. It analyzes the user's facial expressions and tone of voice through a camera and microphone to recognize their emotional state, such as positive, negative, or neutral. This emotional data is then prepared for transmission along with the response data.

[1126] Step 3:

[1127] The device sends the acquired response data and emotion data to the server. Data transmission uses an encryption protocol (e.g., HTTPS) to protect the security and privacy of the data.

[1128] Step 4:

[1129] The server receives the response data and emotion data from the device and temporarily stores them. The stored data is structured so that it can be analyzed.

[1130] Step 5:

[1131] The server analyzes the received response data and maps each response to a corresponding attribute. For example, the response "science fiction" is mapped to "genre," "movie" to "content type," and "smartphone" to "device." The analysis results are converted into tokens and organized into a format that is easy for the generative AI model to use.

[1132] Step 6:

[1133] The server analyzes the emotion data. Based on the acquired data, the emotion engine extracts patterns of the user's emotional changes. For example, if the user is expressing positive emotions, the content and format of the questions are dynamically adjusted according to that emotional state.

[1134] Step 7:

[1135] The server uses a generative AI model to generate infrastructure management code based on the tokenized response data and sentiment data. For example, Terraform code can be automatically generated based on cloud service configuration. The generation process uses a trained model to generate code based on the specified prompt.

[1136] Step 8:

[1137] The server generates personalized content based on the user's input and emotional data. For example, if a user responds that they would like to watch science fiction movies on their smartphone, the server generates a list of highly rated science fiction movies. The generated content list includes information based on specific keywords and the user's emotions.

[1138] Step 9:

[1139] The server provides the generated infrastructure management code and personalized content to the user's device. The delivery methods include download links, email attachments, and display on the device. The user can access the generated code and content list using the device and check or use it as needed.

[1140] Through each of the above steps, users can experience flexible question formats and personalized content that adapts to their emotional state, enabling quick and accurate generation of infrastructure management codes.

[1141] 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.

[1142] 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.

[1143] 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.

[1144] [Fourth embodiment]

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

[1146] 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.

[1147] 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).

[1148] 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.

[1149] 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.

[1150] 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).

[1151] 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.

[1152] 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.

[1153] 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.

[1154] 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.

[1155] 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.

[1156] 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.

[1157] 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."

[1158] As an embodiment of the present invention, a system for automatically generating infrastructure management code based on input from a user is constructed as follows.

[1159] The system acquires answers to multiple questions from users, analyzes and tokenizes them, and then uses an AI model to automatically generate infrastructure management codes based on the tokenized analysis results, and provides the generated codes to the user.

[1160] Program processing

[1161] Getting User Input

[1162] The user answers questions displayed on the device interface, such as "Which cloud provider will you use?", and answers "AWS." In this way, the user gradually answers questions about their infrastructure requirements.

[1163] Sending input data

[1164] Once the user has answered all the questions, the device sends the answer data to the server, where it is formatted in a way that makes it easy for the server to analyze.

[1165] Receiving and analyzing response data

[1166] The server analyzes the response data received from the device and maps each response to a corresponding attribute, for example, the response "AWS" is mapped to "Cloud Provider."

[1167] Preprocessing with AI models

[1168] The server tokenizes the parsed data to power the generative AI model, which then generates the infrastructure management code in a suitable format.

[1169] Auto-generation of infrastructure management code

[1170] The server uses generative AI models to generate infrastructure management code based on the user's answers. For example, if you select AWS, Terraform code is automatically generated.

[1171] Providing generated code to users

[1172] The server provides the generated infrastructure management code to the user via a link, email attachment, or copy function, allowing the user to receive the code and modify it as needed.

[1173] Specific examples

[1174] For example, suppose a user answers the following question:

[1175] 1. Which cloud provider will you use? → "AWS"

[1176] 2. What region? → "us-west-2"

[1177] 3. What type of instance is it? → "t2.micro"

[1178] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[1179] Based on this answer, the server will generate the following Terraform code:

[1180] HCL

[1181] provider "aws" {

[1182] region = "us-west-2"

[1183] }

[1184] resource "aws_instance" "example" {

[1185] ami = "ami-0c55b159cbfafe1f0"

[1186] instance_type = "t2.micro"

[1187] }

[1188] Users can download this code and use Terraform to run the "terraform apply" command, which will create the specified instance on AWS.

[1189] Thus, the present invention is a system that reduces the burden on the user and can generate infrastructure management codes quickly and accurately.

[1190] The processing flow will be explained below.

[1191] Step 1:

[1192] The user answers questions displayed on the device interface. For example, to the question "Which cloud provider do you want to use?", they answer "AWS," and to the question "Which region?", they enter "us-west-2."

[1193] Step 2:

[1194] The device temporarily stores the user's input and confirms that all questions have been answered. Once this is confirmed, the device prepares to send the input data to the server.

[1195] Step 3:

[1196] The user clicks the send button. This causes the device to send the response data to the server, which converts the data into a format that is easy to analyze, such as JSON.

[1197] Step 4:

[1198] The server receives the response data from the terminal and temporarily stores it, making it easier to access the response data.

[1199] Step 5:

[1200] The server analyzes the received response data and maps the responses to the respective questions. For example, the response "AWS" maps to "cloud provider" and "us-west-2" maps to "region."

[1201] Step 6:

[1202] The server tokenizes the parsed data, which is the process of converting the parsed data into a format that is easy for the generative AI model to use.

[1203] Step 7:

[1204] The server feeds the tokenized analytics data into a generative AI model to generate infrastructure management code, for example, automatically generating Terraform code based on AWS configuration.

[1205] Step 8:

[1206] The server stores the generated infrastructure management code and prepares it for later distribution to the user.

[1207] Step 9:

[1208] The server chooses how to provide the generated code, displaying a download link, email attachment, or a pop-up for copying to the user.

[1209] Step 10:

[1210] Users can view the generated code on their device, download or copy it as needed, and then use infrastructure management tools (e.g., Terraform) to automate the deployment of the infrastructure.

[1211] Example 1

[1212] 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."

[1213] In today's cloud computing environment, manually creating infrastructure management code requires a great deal of effort and specialized knowledge. Furthermore, it is not easy to generate code accurately and quickly based on user responses to multiple questions. It is also difficult to select the optimal cloud service based on the user's requirements. Therefore, there is a need for a system that can automatically generate infrastructure management code more efficiently and accurately and provide it to users.

[1214] 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.

[1215] In this invention, the server includes means for acquiring answers to a plurality of questions from a user, means for transmitting the acquired answers to the server, means for analyzing the answers received by the server and tokenizing the analysis results, means for using an AI model to automatically generate an infrastructure management code based on the tokenized analysis results, and means for providing the generated infrastructure management code to the user, thereby enabling the user to quickly and accurately generate an infrastructure management code without requiring specialized knowledge.

[1216] A "user" is an individual or entity that uses a computer system or service.

[1217] "Questionnaire" refers to a specific question or request for information posed to a user regarding infrastructure requirements.

[1218] "Answer" refers to information or data provided by a user in response to a question.

[1219] A "terminal" is hardware and related software used by a user, such as a computer or mobile device.

[1220] A "server" is a computer system that provides data and services over a network.

[1221] "Analysis" refers to the process of converting or classifying the obtained answers into an understandable form.

[1222] "Tokenization" is the process of converting analyzed data into a form that is understandable to a generative AI model.

[1223] "Infrastructure Management Code" means program code used to configure and manage cloud services and computer infrastructure.

[1224] A "generative AI model" refers to an artificial intelligence algorithm that automates specific tasks based on pre-trained data.

[1225] "Providing" refers to the act of making the generated infrastructure management code available to users.

[1226] A "cloud service" is a service that provides computing resources (e.g., servers, storage, databases) via the Internet.

[1227] This invention is a system that automatically generates infrastructure management codes based on user input. The system acquires answers to multiple questions from the user, analyzes and tokenizes them, and generates infrastructure management codes using a generative AI model.

[1228] First, the user uses the device to answer a series of questions displayed on the interface. For example, to the question, "Which cloud provider do you want to use?", the user answers "AWS." In this way, the user answers questions one by one.

[1229] After the user has answered all the questions, the device sends the answer data to the server, which can then be structured in JSON format, for example, so that the server can easily parse it.

[1230] The server analyzes the received response data and maps each response to a corresponding attribute. For example, the response "AWS" is mapped to the attribute "Cloud Provider." This analysis is performed by an analysis engine running on the server.

[1231] The server tokenizes the parsed data. Tokenization is the process of converting data into a format that is easy for the generative AI model to understand. For example, "Cloud provider: AWS" is converted into "TOKEN_PROVIDER_AWS". A library such as Python can be used for this tokenization process.

[1232] The server then uses a generative AI model to automatically generate infrastructure management code based on the tokenized data. For example, if a user selects "AWS," provides "us-west-2" as the region, "t2.micro" as the instance type, and "ami-0c55b159cbfafe1f0" as the AMI ID, the AI ​​model can use this information to generate Terraform code, etc.

[1233] The generated infrastructure management code is provided to the user from the server via various methods, including a download link, email attachment, or copy to the clipboard. The user can then receive the code via their device and modify it as needed.

[1234] As a concrete example, suppose the user answers the following question:

[1235] 1. Which cloud provider will you use? → "AWS"

[1236] 2. What region? → "us-west-2"

[1237] 3. What type of instance is it? → "t2.micro"

[1238] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[1239] Based on this answer, the server can generate the following Terraform code:

[1240] provider "aws" {

[1241] region = "us-west-2"

[1242] }

[1243] resource "aws_instance" "example" {

[1244] ami = "ami-0c55b159cbfafe1f0"

[1245] instance_type = "t2.micro"

[1246] }

[1247] In this way, the present invention utilizes a generative AI model to automatically generate infrastructure management code without requiring users to have specialized knowledge, enabling them to quickly and accurately configure cloud infrastructure.

[1248] Example prompt sentence:

[1249] Please generate an infrastructure management code based on your answers to the following questions about your cloud infrastructure configuration.

[1250] Provider: AWS

[1251] Region: us-west-2

[1252] Instance type: t2.micro

[1253] AMI ID: ami-0c55b159cbfafe1f0

[1254] Using this prompt, the AI ​​model can generate the necessary infrastructure management code.

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

[1256] Step 1:

[1257] The user answers the question. The user enters input into the question displayed on the device interface. For example, the user enters "AWS" in response to the question "Which cloud provider do you want to use?", or "us-west-2" in response to the question "Which region do you want to use?". The data entered by the user is temporarily stored on the device. Example of input data: {"Cloud provider": "AWS", "Region": "us-west-2"}.

[1258] Step 2:

[1259] The device sends the answer data to the server. Once the user has answered all the questions, the device structures the answer data (for example, in JSON format) and sends it to the server. Data is sent using an HTTP POST request. Example of sent data: {"Cloud provider": "AWS", "Region": "us-west-2"}.

[1260] Step 3:

[1261] The server receives and parses the data. The server receives the data sent from the device and parses it. For example, the answer "AWS" is mapped to an attribute called "Cloud Provider", and the answer "us-west-2" is mapped to an attribute called "Region". Once parsed, the data is converted into an internal data structure. Input data: {"Cloud Provider": "AWS", "Region": "us-west-2"}, Output data: {"Attribute 1": "Cloud Provider", "Value 1": "AWS", "Attribute 2": "Region", "Value 2": "us-west-2"}.

[1262] Step 4:

[1263] The server tokenizes the data. The analyzed data is converted into a format that is easy for the generative AI model to understand. For example, "Cloud provider: AWS" is tokenized as "TOKEN_PROVIDER_AWS" and "Region: us-west-2" is tokenized as "TOKEN_REGION_US_WEST_2". This tokenization is performed using a Python library or similar. Input data: {"Attribute 1": "Cloud provider", "Value 1": "AWS", "Attribute 2": "Region", "Value 2": "us-west-2"}, Output data: ["TOKEN_PROVIDER_AWS", "TOKEN_REGION_US_WEST_2"].

[1264] Step 5:

[1265] The server automatically generates infrastructure management code. The server passes the tokenized data to the generation AI model, which then generates the infrastructure management code. For example, if a user selects "AWS," specifies "us-west-2" as the region, selects "t2.micro" as the instance type, and provides "ami-0c55b159cbfafe1f0" as the AMI ID, the AI ​​model generates the following Terraform code:

[1266] HCL

[1267] provider "aws" {

[1268] region = "us-west-2"

[1269] }

[1270] resource "aws_instance" "example" {

[1271] ami = "ami-0c55b159cbfafe1f0"

[1272] instance_type = "t2.micro"

[1273] }

[1274] Input data: ["TOKEN_PROVIDER_AWS", "TOKEN_REGION_US_WEST_2", "TOKEN_INSTANCE_TYPE_T2_MICRO", "TOKEN_AMI_ID_0C55B159CBFAFE1F0"], Output data: Generated Terraform code.

[1275] Step 6:

[1276] The server provides the generated infrastructure management code to the user. The server has various methods for providing the generated code to the user, such as a download link, email attachment, or copy to the clipboard. The user can receive the code using these methods and make modifications as needed. Input data: the generated Terraform code, output data: the method of delivery such as a download link or email.

[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] In modern manufacturing, efficient control settings for factory robots, network configuration, and database management are important challenges. However, conventional methods require these settings to be performed manually, which requires a great deal of time and effort and increases the risk of configuration errors. A method to resolve these issues and efficiently and accurately manage factory automation systems is needed.

[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 acquiring answers to a plurality of questions from a user; means for analyzing the acquired answers and tokenizing the analysis results; means for using a generative AI model to automatically generate an infrastructure management code based on the tokenized analysis results; means for providing the generated infrastructure management code to the user; means for inputting requirements for an automation system in a factory using a smartphone or tablet; and means for automatically generating infrastructure management codes for controlling factory robots based on the input requirements. This eliminates the need for factory operators to manually perform complex settings, enabling efficient and accurate generation of infrastructure management codes and smooth operation of the factory automation system.

[1282] A "user" is a person who uses the system to answer questions and request the generation of an infrastructure management code.

[1283] The "question items" are items that the user answers to obtain information necessary for generating the infrastructure management code.

[1284] An "answer" is information provided by a user in response to a question item.

[1285] "Tokenization" refers to converting parsed data into a format that can be processed by a generative AI model.

[1286] "Infrastructure management code" is code related to the management and configuration of infrastructure structures, and is automatically generated by this system.

[1287] A "generative AI model" is an artificial intelligence model that analyzes user response data and generates infrastructure management code.

[1288] "Server" means the part of the system that analyzes user response data and generates and provides infrastructure management code.

[1289] A "smartphone or tablet" is a mobile device that a user uses to answer questions.

[1290] An "in-factory automation system" is an automated operational system that includes robot control, network configuration, and database management in a factory.

[1291] "Requirements" refer to the specific terms of use and settings for controlling factory robots, network configuration, and database management.

[1292] "Terminal" means a device utilized by a User to receive a generated Infrastructure Management Code.

[1293] The system for implementing this invention is designed to automatically generate infrastructure management code for automation systems in factories. The following describes the programming process that implements this system and how it is implemented in hardware and software.

[1294] Program Overview

[1295] The system allows users to use a smartphone or tablet to input requirements for infrastructure management, and automatically generates code based on that input for controlling factory robots, configuring networks, and managing databases.

[1296] Getting User Input

[1297] Users answer step-by-step questions displayed in an interface on their device, provided by an application installed on their smartphone or tablet. Example questions include:

[1298] "What robot model?"

[1299] "What area?"

[1300] "What's your network setup?"

[1301] "What about the database?"

[1302] For example, a user may answer "Robot A" to the question "What is the robot model?" This answer is similarly obtained for other questions.

[1303] Data transmission

[1304] Once the user has answered all the questions, the device sends the answer data to the server using the Python requests library or similar.

[1305] Receiving and analyzing response data

[1306] The server analyzes the response data received from the device and maps each response to a corresponding attribute. For example, the response "Robot A" is mapped to "Robot Model."

[1307] Preprocessing with AI models

[1308] The server then tokenizes the parsed data to power the generative AI model, using natural language processing (NLP) techniques, and the tokenized data is then formatted in a way that is suitable for generating infrastructure management code.

[1309] Auto-generation of infrastructure management code

[1310] The server uses a generative AI model to generate infrastructure management code based on the user's answers. For example, if "Robot A" is selected, the corresponding control code is automatically generated.

[1311] Providing generated code to users

[1312] The server provides the generated infrastructure management code to the user via a link, email attachment, or copy function, allowing the user to receive the code and modify it as needed.

[1313] Hardware and software used

[1314] Hardware: smartphones, tablets, servers

[1315] software:

[1316] User Interface: Mobile Application

[1317] Sending data: Python's requests library

[1318] Data Analysis and Tokenization: Natural Language Processing (NLP) Techniques

[1319] Generative AI model: An AI model for automatically generating infrastructure management code

[1320] Specific examples

[1321] For example, if a user answers the following questions:

[1322] 1. "What robot model is it?" → "Robot A"

[1323] 2. "What area?" → "Production Line 1"

[1324] 3. "What is your network setting?" → "DHCP"

[1325] 4. "What database?" → "PostgreSQL"

[1326] Based on this, the server generates infrastructure management code such as:

[1327] An example prompt might look like this:

[1328] "What robot model?"

[1329] "What area?"

[1330] "What's your network setup?"

[1331] "What about the database?"

[1332] This system eliminates the need for factory operators to manually configure complex settings, allowing them to efficiently and accurately generate infrastructure management code and ensure the smooth operation of factory automation systems.

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

[1334] Step 1:

[1335] The user uses a smartphone or tablet to input requirements for the factory automation system. They answer questions displayed on the user interface one by one. The information entered includes the robot model, area, network settings, database, etc. The data entered by the user is in text format, and answers are obtained for each question.

[1336] Step 2:

[1337] The device formats the user's answer data and sends it to the server, where it is converted to JSON format and sent to the server using a reliable communication protocol (e.g., HTTPS). The input data includes each of the user's answers, and the output data sent to the server is formatted JSON data.

[1338] Step 3:

[1339] The server analyzes the response data received from the device and maps each response to the corresponding attribute. Specifically, the server parses the received JSON data using an analysis tool, and the response "Robot A" is mapped as the "robot model." The input data is the JSON-formatted response data, and the output data is the data mapped to the attributes.

[1340] Step 4:

[1341] The server tokenizes the parsed data. The parsed attribute data is converted into tokens using natural language processing (NLP) techniques. At this point, the data is in a format that is easy for the generative AI model to process. The input data is data mapped to attributes, and the output data is tokenized data. Specifically, NLP tools (e.g., SpaCy, NLTK) are used to split words and phrases into tokens.

[1342] Step 5:

[1343] The server uses a generative AI model to generate infrastructure management code based on the tokenized data. Specifically, the generative AI model constructs appropriate infrastructure management code based on the tokenized data. Examples of generative AI models that can be used include OpenAI's GPT-3. The input data is the tokenized data, and the output data is the generated code.

[1344] Step 6:

[1345] The server provides the generated infrastructure management code to the user. The server can email the generated code, provide a download link, or send it directly to the terminal. The input data is the generated code, and the output data is the code converted into a format that is provided to the user. For example, the generated Terraform code is attached to an email.

[1346] In this way, each processing step works in conjunction with the others, making it possible to efficiently and accurately generate the infrastructure management code required for a factory automation system.

[1347] 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.

[1348] As an embodiment of the present invention, a system for automatically generating infrastructure management code based on user input is constructed as follows: This system is combined with an emotion engine that recognizes user emotions.

[1349] This system acquires responses to multiple questions from users, analyzes them, and tokenizes them. It then uses an AI model to automatically generate infrastructure management codes based on the tokenized analysis results, and provides the generated codes to the user. It also uses an emotion engine to recognize user emotions, dynamically changing the content and format of questions and adjusting the interface design based on those emotions. Furthermore, the emotion data is saved along with the analysis results and can be used to generate future infrastructure management codes.

[1350] Program processing

[1351] Getting User Input

[1352] The user answers questions displayed on the device interface. For example, to the question "Which cloud provider do you use?", the user answers "AWS," and to the question "What region?", the user enters "us-west-2." The emotion engine recognizes the user's emotions in real time during the conversation, and the interface dynamically adjusts according to changes in emotion.

[1353] Sending input data

[1354] When the user completes the answer, the device sends the answer data to the server, along with the emotion data acquired by the emotion engine.

[1355] Receiving and analyzing response data

[1356] The server receives the response data and emotion data from the device and temporarily stores them, making each piece of data easier to access.

[1357] Emotional Data Processing

[1358] The server analyzes the emotion data acquired by the emotion engine and extracts patterns of the user's emotional changes. This data is used to dynamically adjust the content and format of questions.

[1359] Parsing and tokenizing response data

[1360] The server parses the received response data and maps each response to a corresponding attribute. For example, the response "AWS" maps to "cloud provider" and the response "us-west-2" maps to "region." The parsed results are tokenized and converted into a format that is easy for the AI ​​model to handle.

[1361] Auto-generation of infrastructure management code

[1362] The server uses generative AI models to generate infrastructure management code based on user responses and sentiment data, for example automatically generating Terraform code based on AWS configuration.

[1363] Providing generated code to users

[1364] The server stores the generated infrastructure management code and prepares it for delivery to the user. Specifically, it provides the ability to download it via a link, attach it to an email, or copy it. The user receives the code using their device and can review and modify it as needed.

[1365] Specific examples

[1366] For example, suppose a user answers the following question:

[1367] 1. Which cloud provider will you use? → "AWS"

[1368] 2. What region? → "us-west-2"

[1369] 3. What type of instance is it? → "t2.micro"

[1370] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[1371] In addition to this answer, if the sentiment engine recognizes a positive sentiment, the server will generate the following Terraform code:

[1372] HCL

[1373] provider "aws" {

[1374] region = "us-west-2"

[1375] }

[1376] resource "aws_instance" "example" {

[1377] ami = "ami-0c55b159cbfafe1f0"

[1378] instance_type = "t2.micro"

[1379] }

[1380] Users can download this code and use Terraform to run the "terraform apply" command, which will create the specified instance on AWS.

[1381] This system reduces the burden on users, enables rapid and accurate generation of infrastructure management code, and provides a flexible interface that takes user feelings into consideration.

[1382] The processing flow will be explained below.

[1383] Step 1:

[1384] The user answers a number of questions displayed on the device interface. For example, in response to the question "Which cloud provider do you want to use?", the user enters "AWS." In response to the question "Which region?", the user answers "us-west-2."

[1385] Step 2:

[1386] The emotion engine analyzes the user's facial expressions and vocal tone in real time to recognize their emotional state, for example, using the camera and microphone to determine whether the user is smiling or sad.

[1387] Step 3:

[1388] The device temporarily stores the user's response data and the recognized emotion data, and then verifies that all questions have been answered. After verification, this data is compiled into a data packet.

[1389] Step 4:

[1390] When the user clicks the send button, the device sends a data packet containing the user's response data and emotion data to the server.

[1391] Step 5:

[1392] The server receives data packets from the device and stores them temporarily, allowing for quick access and analysis of the data.

[1393] Step 6:

[1394] The server parses the response data in the data packet and maps each response to a corresponding attribute, for example, the response "AWS" maps to "cloud provider" and "us-west-2" maps to "region".

[1395] Step 7:

[1396] The server analyzes the emotion data recognized by the emotion engine and integrates the response data with the emotion data. The recognized emotional state is reflected in the interface design and the content and format of the questions.

[1397] Step 8:

[1398] The server tokenizes the parsed response data and prepares it for input into the generative AI model. Tokenization makes the data more accessible to the AI ​​model.

[1399] Step 9:

[1400] The server uses generative AI models to automatically generate infrastructure management code based on the integrated data, for example, Terraform code if AWS is selected.

[1401] Step 10:

[1402] The server stores the generated infrastructure management code and then prepares it for delivery to the user, either via a link for download, email attachment, or copy function.

[1403] Step 11:

[1404] The user can view the generated code on the terminal, download or copy it as needed, and then use an infrastructure management tool (e.g., Terraform) to automatically deploy the infrastructure. Specifically, they run the "terraform apply" command.

[1405] Example 2

[1406] 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."

[1407] Conventional infrastructure management code generation systems do not take into account the user's emotional state, potentially resulting in a poor user experience. Manual code generation is also time-consuming, labor-intensive, and prone to errors. The present invention aims to address these issues and provide a system that automatically generates infrastructure management codes quickly and accurately, while improving the user experience.

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

[1409] In this invention, the server includes means for acquiring answers to a plurality of questions from a user, means for acquiring the acquired answers and emotional data of the user in the answers, means for analyzing the acquired answers and emotional data and tokenizing the analysis results, means for using an AI model to automatically generate an infrastructure management code based on the tokenized analysis results, means for providing the generated infrastructure management code to the user, means for dynamically adjusting the user's input interface based on the emotional data, and means for saving each processing result and using it for generating future infrastructure management codes. This makes it possible to provide a flexible interface that takes into account the emotional state of the user and to automatically generate infrastructure management codes quickly and accurately.

[1410] "User" refers to a user who answers questions to generate infrastructure management code using the system.

[1411] "Terminal" refers to a device used by a user to answer questions and send the answer data to a server.

[1412] "Emotion data" refers to information that indicates the user's emotional state and is acquired during user input.

[1413] "Server" refers to a device that receives and stores responses and emotion data sent by users, analyzes them, and generates infrastructure management code.

[1414] "Tokenization" refers to the process of analyzing the response data obtained and converting it into a format that is easy for an AI model to handle.

[1415] "Generative AI model" refers to an artificial intelligence model for automatically generating infrastructure management code based on tokenized analysis results.

[1416] "Infrastructure Management Code" means computer code used to automate the configuration and resource management of Cloud Services.

[1417] "Dynamic adjustment" refers to changing the content of the interface and the format of questions in real time based on the user's emotional data.

[1418] "Storage" refers to the server maintaining the acquired response data and emotion data in a state where it can be used for future processing.

[1419] This invention relates to a system that automatically generates infrastructure management codes based on user input and emotional data. The system acquires answers to multiple questions from the user and tokenizes them. It then uses a generative AI model based on the tokenized data to automatically generate infrastructure management codes. Furthermore, it uses an emotional engine to recognize the user's emotional state and utilizes that data for analysis. This improves the user experience and enables faster and more accurate generation of infrastructure management codes.

[1420] This system is implemented in a client-server model. The user answers questions through an interface on the device and sends the data to the server. The device is equipped with an emotion engine that obtains emotional data in real time from the user's facial expressions and tone of voice. The data is then transferred to the server via a secure communication method (e.g., HTTPS protocol).

[1421] The server stores the received response data and sentiment data in a database. The stored data is then analyzed, first parsing the response data and mapping each response to its corresponding attributes. The data is then tokenized and converted into a format that can be easily handled by the AI ​​model, using natural language processing techniques. A generative AI model generates infrastructure management code based on the tokenized data. This model uses a pre-trained model to generate code that corresponds to a specific cloud service (e.g., cloud provider or region configuration).

[1422] The generated code is stored on the server and provided to the user. Delivery methods include downloading via a link, attaching to an email, or copying. The user receives the generated code on their device and can review and modify it as needed. For example, they can run the generated code using Terraform to apply specific settings to a cloud environment.

[1423] Specific examples

[1424] For example, suppose a user answers the following question:

[1425] 1. Which cloud provider will you use? → "AWS"

[1426] 2. What region? → "us-west-2"

[1427] 3. What type of instance is it? → "t2.micro"

[1428] 4. What is the AMI ID? → "ami-0c55b159cbfafe1f0"

[1429] This response data and the data that the emotion engine recognized as positive emotions are sent to the server, which generates the following Terraform code based on this data.

[1430] HCL

[1431] provider "aws" {

[1432] region = "us-west-2"

[1433] }

[1434] resource "aws_instance" "example" {

[1435] ami = "ami-0c55b159cbfafe1f0"

[1436] instance_type = "t2.micro"

[1437] }

[1438] Users can download this code and use Terraform to create the specified instance on AWS by running the "terraform apply" command.

[1439] The system aims to reduce the burden on users and generate infrastructure management code quickly and accurately. It also provides a better user experience by taking into account the user's emotional state through an emotion engine.

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

[1441] Step 1: Getting User Input

[1442] The user answers multiple questions displayed on the device interface. Specifically, the device displays questions such as "Which cloud provider do you use?" and "Which region?", to which the user answers in text format. The device also uses a built-in emotion engine to analyze the user's facial expressions and tone of voice while they are entering their answers, obtaining emotional data in real time. Input: Text questions, answer data, and emotional data. Output: User's answer data and emotional data.

[1443] Step 2: Submitting input data

[1444] Once the user has answered all the questions, the device sends the answer data and emotion data to the server. Specifically, this data is securely transferred using the HTTPS protocol. Input: Answer data and emotion data entered by the user. Output: Data sent to the server.

[1445] Step 3: Receiving and storing response data

[1446] The server receives the response data and emotion data sent from the device. The server stores this data in a database and prepares it for later analysis. Input: Response data and emotion data sent from the device. Output: Data stored in the server's database.

[1447] Step 4: Analyze the sentiment data

[1448] The server analyzes the stored emotion data. Specifically, it uses the data obtained from the emotion engine to extract patterns of the user's emotion changes. For example, it determines whether the user is feeling stressed while answering questions. Input: Stored emotion data. Output: User's emotion change patterns.

[1449] Step 5: Parse and tokenize response data

[1450] The server parses the stored response data and maps each response to its corresponding attribute. The results of this analysis are then tokenized and converted into a format that the AI ​​model can easily handle. For example, the response "AWS" is mapped to "cloud provider" and the response "us-west-2" is mapped to "region." Input: Response data. Output: Tokenized data.

[1451] Step 6: Auto-generating infrastructure management code

[1452] The server uses a generative AI model to generate infrastructure management codes based on the tokenized analysis results. The generative AI model used here is a pre-trained model that generates appropriate codes based on the response data. Input: Tokenized analysis results. Output: Generated infrastructure management code.

[1453] Step 7: Provide the generated code to users

[1454] The server prepares the generated infrastructure management code for delivery to the user. For example, the generated code may be made available for download via a link or sent via email. The user downloads this code on their device and reviews and modifies it as needed. Input: Generated infrastructure management code. Output: Code provided to the user.

[1455] (Application example 2)

[1456] 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."

[1457] Conventional infrastructure management code generation systems generate codes based on user input data, but provide a uniform question format and interface without considering the user's emotional state, which does not adequately consider the user experience. Furthermore, because personalized content is not generated, it is difficult to provide optimal information to users.

[1458] The identification process by the identification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes means for acquiring answers to multiple questions from the user, means for analyzing the acquired answers and tokenizing the analysis results, means for using a model to automatically generate an infrastructure management code based on the tokenized analysis results, means for analyzing the acquired emotion data and dynamically changing the content and format of the question in response to changes in the user's emotion, and means for providing the generated infrastructure management code to the user. This makes it possible to provide a flexible question format and interface based on the user's emotional state, improving the user experience. Furthermore, by generating personalized content using the emotion data, it is possible to provide optimal information to the user.

[1459] "Answers to multiple questions from a user" refers to a collection of individual responses to multiple questions that a user inputs on an interface via a terminal.

[1460] "Analysis" is the process of clarifying the meaning and relationships of information and structuring it in order to convert acquired data into an understandable format.

[1461] "Tokenization" is the process of breaking down parsed data into elements and organizing them according to a prescribed format.

[1462] "Infrastructure management code" is program code for automating infrastructure management such as cloud services and servers.

[1463] A "model" refers to a machine learning algorithm designed to perform a specific task, taking data as input and producing an output.

[1464] "Emotion data" is data that indicates the emotional state of a user, and is usually obtained using techniques such as facial expression recognition and voice analysis.

[1465] "Dynamic change" refers to changes in real time based on the situation or conditions, following certain rules.

[1466] "Personalized content" refers to information and media that are customized to suit the preferences and circumstances of individual users.

[1467] "Terminal" refers to an apparatus or device operated by a user, including smartphones, tablets, and personal computers.

[1468] "Providing" refers to the act of delivering generated infrastructure management code and personalized content to a user.

[1469] MODE FOR CARRYING OUT THE INVENTION

[1470] The following system can be constructed as an embodiment of the present invention. The system uses user input data and emotion data to generate infrastructure management code and personalized content, achieving a flexible interface and optimal information provision.

[1471] System Program Description

[1472] The system mainly consists of the following elements: user device (smartphone or head-mounted display), server, emotion engine, and generative AI model.

[1473] Getting User Input

[1474] The user answers a number of questions displayed on the device, and the answer data is collected. For example, the user enters answers to the following questions:

[1475] 1. What is your favorite genre? → "SF"

[1476] 2. What type of content do you want to watch? → "Movies"

[1477] 3. What device will you be watching on? → "Smartphone"

[1478] Acquiring emotion data

[1479] The emotion engine recognizes the user's real-time emotions using a camera or microphone, for example, by using the emotion analysis API from Microsoft Azure Cognitive Services.

[1480] Sending input data and emotion data

[1481] The user's response data and emotion data are transmitted from the terminal to the server.

[1482] Data Parsing and Tokenization

[1483] The server parses the received data and maps each response to a corresponding attribute, and the results are tokenized and converted into a format that is easy for the generative AI model to understand.

[1484] Infrastructure management code generation

[1485] The server uses generative AI models based on the tokenized data to generate infrastructure management code, for example, automatically generating Terraform code based on cloud configuration.

[1486] Personalized content generation

[1487] The server uses the user's responses and emotion data to generate personalized content, such as a list of movies in the science fiction genre that the user wants to watch on their smartphone.

[1488] Examples:

[1489] Based on the user's response and positive sentiment, the following prompt sentence is fed into the generative AI model:

[1490] The user indicated that they would like to watch movies in the sci-fi genre on their smartphone. This indicates a positive sentiment. Please generate a list of recommendations for the best content.

[1491] Based on this, the generative AI model generates a list of highly rated sci-fi movies such as "Interstellar" and "The Matrix."

[1492] Providing generated code and content

[1493] The generated infrastructure management code and personalized content are sent to the user's device for easy access by the user, either via a download link, email notification, or display of a content list on the device.

[1494] As a result, a system can be constructed that provides flexible question formats and interfaces that correspond to the user's emotional state, improves the user experience, and provides optimal information.

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

[1496] Step 1:

[1497] The user inputs answers to multiple questions displayed on the device. For example, the user answers questions such as "my favorite genre is SF," "the type of content I want to watch is movies," and "the device I want to watch it on is a smartphone." This input data is obtained from the user's interface. The device temporarily stores the user's answers obtained here.

[1498] Step 2:

[1499] The device uses an emotion engine to capture the user's emotional data in real time. It analyzes the user's facial expressions and tone of voice through a camera and microphone to recognize their emotional state, such as positive, negative, or neutral. This emotional data is then prepared for transmission along with the response data.

[1500] Step 3:

[1501] The device sends the acquired response data and emotion data to the server. Data transmission uses an encryption protocol (e.g., HTTPS) to protect the security and privacy of the data.

[1502] Step 4:

[1503] The server receives the response data and emotion data from the device and temporarily stores them. The stored data is structured so that it can be analyzed.

[1504] Step 5:

[1505] The server analyzes the received response data and maps each response to a corresponding attribute. For example, the response "science fiction" is mapped to "genre," "movie" to "content type," and "smartphone" to "device." The analysis results are converted into tokens and organized into a format that is easy for the generative AI model to use.

[1506] Step 6:

[1507] The server analyzes the emotion data. Based on the acquired data, the emotion engine extracts patterns of the user's emotional changes. For example, if the user is expressing positive emotions, the content and format of the questions are dynamically adjusted according to that emotional state.

[1508] Step 7:

[1509] The server uses a generative AI model to generate infrastructure management code based on the tokenized response data and sentiment data. For example, Terraform code can be automatically generated based on cloud service configuration. The generation process uses a trained model to generate code based on the specified prompt.

[1510] Step 8:

[1511] The server generates personalized content based on the user's input and emotional data. For example, if a user responds that they would like to watch science fiction movies on their smartphone, the server generates a list of highly rated science fiction movies. The generated content list includes information based on specific keywords and the user's emotions.

[1512] Step 9:

[1513] The server provides the generated infrastructure management code and personalized content to the user's device. The delivery methods include download links, email attachments, and display on the device. The user can access the generated code and content list using the device and check or use it as needed.

[1514] Through each of the above steps, users can experience flexible question formats and personalized content that adapts to their emotional state, enabling quick and accurate generation of infrastructure management codes.

[1515] 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.

[1516] 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.

[1517] 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.

[1518] 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.

[1519] 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.

[1520] 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.

[1521] 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).

[1522] 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.

[1523] 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."

[1524] 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.

[1525] 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).

[1526] 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.

[1527] 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.

[1528] 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.

[1529] 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.

[1530] 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.

[1531] 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.

[1532] 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.

[1533] 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.

[1534] 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.

[1535] 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.

[1536] The following is further disclosed regarding the above embodiment.

[1537] (Claim 1)

[1538] A means for obtaining answers to a plurality of questions from a user;

[1539] A means for analyzing the obtained answers and tokenizing the analysis results;

[1540] a means for using an AI model to automatically generate infrastructure management code based on the tokenized analysis results;

[1541] means for providing the generated infrastructure management code to a user;

[1542] A system including:

[1543] (Claim 2)

[1544] 10. The system of claim 1, further comprising: means for transmitting the generated infrastructure management code to a user terminal.

[1545] (Claim 3)

[1546] The system of claim 1 , further comprising: means for specifying a cloud service based on the obtained answer.

[1547] "Example 1"

[1548] (Claim 1)

[1549] A means for obtaining answers to a plurality of questions from a user;

[1550] means for transmitting the obtained answer to a server;

[1551] a means for parsing the received response by the server and tokenizing the parsed result;

[1552] a means for using an AI model to automatically generate infrastructure management code based on the tokenized analysis results;

[1553] means for providing the generated infrastructure management code to a user;

[1554] A system including:

[1555] (Claim 2)

[1556] 10. The system of claim 1, further comprising: means for transmitting the generated infrastructure management code to a user terminal.

[1557] (Claim 3)

[1558] The system of claim 1 , further comprising: means for specifying a cloud service based on the obtained answer.

[1559] "Application Example 1"

[1560] (Claim 1)

[1561] A means for obtaining answers to a plurality of questions from a user;

[1562] A means for analyzing the obtained answers and tokenizing the analysis results;

[1563] a means for using a generative AI model to automatically generate infrastructure management code based on the tokenized analysis results;

[1564] means for providing the generated infrastructure management code to a user;

[1565] A means for inputting requirements into an automation system in a factory using a smartphone or tablet;

[1566] means for automatically generating infrastructure management code for controlling factory robots based on input requirements;

[1567] A system including:

[1568] (Claim 2)

[1569] 10. The system of claim 1, further comprising: means for transmitting the generated infrastructure management code to a user terminal.

[1570] (Claim 3)

[1571] 10. The system of claim 1, further comprising means for specifying an information system based on the obtained answers.

[1572] "Example 2: Combining Emotion Engines"

[1573] (Claim 1)

[1574] A means for obtaining answers to a plurality of questions from a user;

[1575] A means for acquiring the acquired answer and emotion data of the user during the answer;

[1576] means for analyzing the obtained answers and sentiment data and tokenizing the analysis results;

[1577] a means for using an AI model to automatically generate infrastructure management code based on the tokenized analysis results;

[1578] means for providing the generated infrastructure management code to a user;

[1579] means for dynamically adjusting a user's input interface based on the emotion data;

[1580] A means of storing the results of each operation to aid in the generation of future infrastructure management code;

[1581] A system including:

[1582] (Claim 2)

[1583] 10. The system of claim 1, further comprising: means for transmitting the generated infrastructure management code to a user terminal.

[1584] (Claim 3)

[1585] The system of claim 1 , further comprising: means for specifying a cloud service based on the obtained answer.

[1586] "Application example 2 when combining emotion engines"

[1587] (Claim 1)

[1588] A means for obtaining answers to a plurality of questions from a user;

[1589] A means for analyzing the obtained answers and tokenizing the analysis results;

[1590] a means for using the model to automatically generate infrastructure management code based on the tokenized analysis results;

[1591] A means for analyzing the acquired emotion data and dynamically changing the content and format of questions according to changes in the user's emotion;

[1592] means for providing the generated infrastructure management code to a user;

[1593] A system including:

[1594] (Claim 2)

[1595] 10. The system of claim 1, further comprising means for generating personalized content using the user's emotional data.

[1596] (Claim 3)

[1597] 10. The system of claim 1, further comprising means for transmitting the generated infrastructure management code and personalized content to the user's terminal. [Explanation of symbols]

[1598] 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 obtaining answers to a plurality of questions from a user; A means for analyzing the obtained answers and tokenizing the analysis results; a means for using an AI model to automatically generate infrastructure management code based on the tokenized analysis results; means for providing the generated infrastructure management code to a user; A system including:

2. The system of claim 1 , further comprising: means for transmitting the generated infrastructure management code to a user terminal.

3. The system of claim 1 , further comprising means for specifying a cloud service based on the obtained answer.

Images