system

Abstract

To provide a system.SOLUTION: The system includes: means for automatically generating data which does not exist and is also real at random; means for providing the data in a test environment database used to test or verify the system; means for making the test environment database unrelated to personal information and closer to a commercial environment; means for recognizing the emotion of a user and adjusting a parameter of data automatically generated on the basis of the recognized emotion; means for importing the generated data into the test environment database; and simulating a business scenario by using the data provided with the test environment database.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] The test environment database must not contain personal information and must be as close to the commercial environment as possible. However, manually creating such data takes time and effort. It is also necessary to verify whether the created data satisfies the actual business scenario. [Means for solving the problem]

[0005] The present invention randomly and automatically creates "possibly real" data that does not actually exist. The relevant data is provided to a test environment database, ensuring that the test environment database is not based on personal information and is as close to a commercial environment as possible. Furthermore, the automatically created data is in a format that contributes to business efficiency and meets specific business scenarios. This streamlines the creation of the test environment database and the verification of business scenarios. [Brief explanation of the drawings]

[0006] [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. 2 is a sequence diagram showing a flow of processing in the data processing system according to the first embodiment of the first form example. [Figure 12] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 1 of Embodiment 1. [Figure 13] FIG. 10 is a sequence diagram showing a processing flow of a data processing system in a second embodiment of the second form example. [Figure 14] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 2 of Embodiment Example 2. [Figure 15]FIG. 10 is a sequence diagram showing the flow of processing in a data processing system according to a third embodiment of the third embodiment. [Figure 16] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 3 of Embodiment 3. [Figure 17] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in the first embodiment of the first form example when an emotion engine is combined. [Figure 18] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 1 of Form Example 1 when an emotion engine is combined. [Figure 19] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in the second embodiment of the second form example when an emotion engine is combined. [Figure 20] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 2 of Form Example 2 when an emotion engine is combined. [Figure 21] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in the third embodiment of the third form example when an emotion engine is combined. [Figure 22] FIG. 10 is a sequence diagram showing the flow of processing in the data processing system in Application Example 3 of Form Example 3 when an emotion engine is combined. DETAILED DESCRIPTION OF THE INVENTION

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

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

[0009] 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, the 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), an APU (Accelerated Processing Unit), or a TPU (TENSOR PROCESSING UNIT (registered trademark)).

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

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

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

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

[0014] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

[0026] Next, the specific processing by the specific processing unit 290 of the data processing device 12 will be described.

[0027] "Example 1"

[0028] The present invention is a system that automatically generates random, potentially real data that does not actually exist and provides that data to a test environment database. Specifically, a data generation module defines a data pattern based on a business scenario and generates random data according to that pattern. The generated data is provided to the test environment database, which then uses the data to simulate business processes.

[0029] "Example 2"

[0030] As a concrete example, consider a business scenario in the financial industry. Data such as customer information, account information, and transaction information is required, but because this data may contain personal information, it is not possible to use actual data. Therefore, the system of the present invention is used to automatically generate this data. The generated data has the same format as the actual data and can be used to execute the same business processes.

[0031] "Example 3"

[0032] Furthermore, the generated data is created to satisfy specific business scenarios. For example, it is possible to generate data that satisfies various scenarios, such as a scenario in which a certain transaction succeeds or a scenario in which a certain transaction fails. This allows the test environment DB to operate in the same way as actual business processing, contributing to business efficiency.

[0033] The processing flow of each embodiment will be described below.

[0034] "Example 1"

[0035] Step 1: The data generation module defines data patterns based on business scenarios.

[0036] Step 2: The data generation module generates random data according to the defined pattern.

[0037] Step 3: The generated data is provided to the test environment DB.

[0038] Step 4: The test environment DB simulates business processing using the provided data.

[0039] "Example 2"

[0040] Step 1: Consider a business scenario in the financial industry and define data patterns such as customer information, account information, and transaction information.

[0041] Step 2: Based on the defined data patterns, the system of the present invention is used to automatically generate these data.

[0042] Step 3: The generated data has the same format as the actual data and can be used to perform the same business processes.

[0043] "Example 3"

[0044] Step 1: Define specific business scenarios (e.g., scenarios in which a transaction succeeds, scenarios in which a transaction fails).

[0045] Step 2: Generate data that satisfies the defined business scenario.

[0046] Step 3: The generated data is provided to the test environment DB, which uses the data to simulate business processes.

[0047] Example 1

[0048] Next, a description will be given of Example 1 of Form 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."

[0049] By randomly and automatically generating data that does not exist in reality but could be real, and providing it to a test environment database, it is necessary to create a test environment that is close to a commercial environment while using data that is not based on personal information.It is also important that the generated data contributes to business efficiency and satisfies specific business scenarios.

[0050] The identification process by the identification processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means. In this invention, the server includes a means for defining a data pattern based on a business scenario, a means for generating random data according to the defined data pattern, and a means for providing the generated data to the test environment database. This makes it possible to build a test environment that is not based on personal information but is close to a commercial environment, generate data that contributes to business efficiency, and provide data that satisfies a specific business scenario.

[0051] A "business scenario" is a plan or scenario that indicates a specific business process or operation procedure, and serves as a basis for data generation.

[0052] A "data pattern" defines the format and structure of the data to be generated, and includes the data type and generation method of each field.

[0053] "Random data" is data that is generated without following any particular rules or patterns and has unpredictable values.

[0054] A "test environment database" is a database used to test and verify a system, which differs from the actual operating environment but has a configuration similar to that of a commercial environment.

[0055] "Business process simulation" refers to simulating actual business processes using data provided in the test environment database, and is used to check system operation and perform performance tests.

[0056] This invention is a system that automatically randomly creates data that does not actually exist but that "might be real" for a test environment database and provides the relevant data. A specific embodiment of this system will be described below.

[0057] System configuration

[0058] Hardware and Software Use

[0059] The server uses programming languages ​​such as Python and Java (registered trademark) to run the data generation module, and data processing libraries such as NumPy and Pandas for data processing. The test environment database uses a database management system such as MySQL (registered trademark) or PostgreSQL.

[0060] Program processing

[0061] Entering business scenarios

[0062] Users enter business scenarios through a web interface, with input forms containing fields such as customer ID, customer name, address, and phone number.

[0063] Data Pattern Definition

[0064] The server defines a data pattern based on the business scenario entered by the user, including the data type and generation method for each field, for example, customer ID is an integer, customer name is a string, address is a string, and phone number is a number.

[0065] Random Data Generation

[0066] The server generates random data according to a defined data pattern, using libraries such as NumPy or Pandas. For example, it uses NumPy's numpy.random module to generate random integers and strings.

[0067] Providing data to the test environment DB

[0068] The server provides the generated data to the test environment database. The generated data is inserted into the test environment database using the Python sqlalchemy library. For example, the data is inserted using the sqlalchemy insert method.

[0069] Business process simulation

[0070] The test environment database uses the provided data to simulate business processes, allowing system operation and performance testing to be performed. For example, operations such as searching and updating customer information are performed.

[0071] Specific examples

[0072] Suppose a user wants to test a new customer management system. In this case, the user enters the following business scenario:

[0073] Customer ID: Random integer

[0074] Customer Name: Random string

[0075] Address: Random string

[0076] Phone Number: Random numbers

[0077] The server generates 1,000 customer data items according to these patterns and provides them to the test environment database, which uses this data to simulate the operation of the customer management system.

[0078] Example prompt sentence:

[0079] "Generate test data for the customer management system. Create 1,000 records with random integers for customer IDs, random strings for customer names, random strings for addresses, and random numbers for phone numbers, and provide them to the test environment database."

[0080] The above is a specific embodiment for carrying out the present invention.

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

[0082] Step 1: Enter the business scenario

[0083] A user inputs a business scenario through a web interface. The input form contains fields such as customer ID, customer name, address, and phone number. As input, the user specifies specific data patterns for these fields. As output, the server receives these input data and stores them for use in the next step.

[0084] Specific behavior:

[0085] A user accesses a web form using a browser and enters a data pattern into each field: for example, an "integer" for a customer ID, a "string" for a customer name, a "string" for an address, and a "number" for a phone number.

[0086] Step 2: Define the data pattern

[0087] The server defines a data pattern based on the business scenario entered by the user. As input, it receives a data pattern specified by the user and generates as output a data pattern including the data type and generation method of each field.

[0088] Specific behavior:

[0089] The server uses a Python dictionary data structure to define the data pattern for each field: for example, customer ID is an integer, customer name is a string, address is a string, and phone number is a number.

[0090] Step 3: Generate random data

[0091] The server generates random data according to a defined data pattern, taking the data pattern as input and obtaining the randomly generated data as output.

[0092] Specific behavior:

[0093] The server uses NumPy's numpy.random module to generate random integers and strings, for example, numpy.random.randint(1000, 9999) to generate a random customer ID, and numpy.random.choice to generate a random string.

[0094] Step 4: Provide data to the test environment database

[0095] The server provides the generated data to the test environment database, taking as input randomly generated data and as output inserting data into the test environment database.

[0096] Specific behavior:

[0097] The server uses the Python sqlalchemy library to insert the generated data into the test environment database, for example by using the sqlalchemy insert method.

[0098] Step 5: Simulating business processes

[0099] The test environment database uses the provided data to simulate business processes, receiving as input the data inserted into the test environment database and obtaining as output the results of the business processes.

[0100] Specific behavior:

[0101] The test environment database executes queries based on the provided data and simulates business processes, such as searching and updating customer information, allowing for system operation confirmation and performance testing.

[0102] (Application example 1)

[0103] Next, a description will be given of Application Example 1 of Embodiment 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."

[0104] In a test environment for autonomous vehicles, it is necessary to randomly generate realistic traffic data and provide it to a test environment database. However, collecting real traffic data is costly and time-consuming, and personal information must be protected, making it difficult to build a test environment efficiently and safely.

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

[0106] In this invention, the server includes a means for automatically and randomly creating potentially real data that does not actually exist, a means for providing the relevant data to the test environment DB, a means for making the test environment DB not based on personal information and as close to a commercial environment as possible, a means for defining traffic data patterns and generating random traffic data according to the patterns, and a means for providing the generated traffic data to the test environment DB. This makes it possible to efficiently and safely generate potentially real traffic data and provide it to the test environment.

[0107] "Possible real data" refers to data that does not actually exist but could occur in a real situation.

[0108] "Random automatic generation means" refers to a device or program that has the function of randomly generating data based on specific algorithms or rules.

[0109] A "test environment DB" is a database used to verify the operation of systems and applications.

[0110] "Non-personal information" means that the data generated does not contain information that identifies a specific individual.

[0111] "Means to approximate a commercial environment" refers to methods and techniques for making the test environment as close as possible to the actual commercial operating environment.

[0112] "Traffic data pattern" refers to a particular format or structure of data relating to traffic conditions and vehicle movements.

[0113] "Means for generating random traffic data" refers to a device or program that has the function of randomly generating traffic data based on traffic data patterns.

[0114] "Means for providing the generated traffic data to the test environment DB" refers to methods or techniques for inputting or storing the generated traffic data in the test environment database.

[0115] The system for carrying out the present invention operates in cooperation with three entities: a server, a terminal, and a user. A specific embodiment of the system will be described below.

[0116] Server Roles

[0117] The server has a means to automatically and randomly create "possibly real" data that does not actually exist. Specifically, the server defines traffic data patterns and generates random traffic data according to those patterns. The generated data is provided to the test environment DB. The server is implemented using a programming language such as Python, and a program containing a data generation algorithm runs on it.

[0118] Device Role

[0119] The terminal receives data provided by the server and saves it in the test environment DB. The terminal manages the data using a database management system (DBMS) and simulates business processing in the test environment. Specifically, the terminal saves data using the MockDatabase class and displays the inserted data.

[0120] User Roles

[0121] Users use the generated data to test autonomous vehicles. Users conduct simulations and tests based on the data stored in the test environment DB. This allows them to simulate realistic traffic situations and evaluate the performance and safety of autonomous vehicles.

[0122] Hardware and software used

[0123] Server: The computer system on which the Python program runs.

[0124] Terminal: A computer system equipped with a database management system (DBMS).

[0125] User: A computer system that can access the test environment database

[0126] Data processing and calculation

[0127] The server generates random traffic data based on traffic data patterns. Specifically, it randomly generates vehicle IDs, speeds, location information (latitude and longitude), and timestamps. The generated data is sent to the terminal and stored in the test environment database. The user uses this data to perform simulations.

[0128] Specific examples

[0129] For example, to generate data based on an urban traffic scenario, you might use a prompt like this:

[0130] Generate random traffic data based on an urban traffic scenario, including vehicle ID, speed, location (latitude and longitude), and timestamp.

[0131] Using this prompt, the generative AI model can generate data suitable for urban traffic scenarios, which is then stored in the test environment database and used for testing autonomous vehicles.

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

[0133] Step 1:

[0134] The server defines the traffic data pattern. Specifically, it sets data items such as vehicle ID, speed, location information (latitude and longitude), and timestamp. This determines the format of the generated data. The input is the traffic data pattern definition, and the output is the defined data pattern.

[0135] Step 2:

[0136] The server generates random traffic data based on a defined traffic data pattern. Specifically, it randomly generates a vehicle ID, randomly sets the speed in the range of 0 to 120, randomly determines location information (latitude and longitude), and randomly generates a timestamp. The input is the defined data pattern, and the output is the generated random traffic data.

[0137] Step 3:

[0138] The server transmits the generated traffic data to the terminal. Specifically, it converts the generated data into a data format such as JSON and transmits it to the terminal via the network. The input is the generated traffic data, and the output is the data transmitted to the terminal.

[0139] Step 4:

[0140] The terminal stores the traffic data received from the server in the test environment DB. Specifically, the received data is inserted into the database management system (DBMS) and saved. The input is the data received from the server, and the output is the data saved in the test environment DB.

[0141] Step 5:

[0142] Users use the data stored in the test environment DB to test autonomous vehicles. Specifically, they perform simulations based on the stored data to evaluate the performance and safety of autonomous vehicles. The input is the data stored in the test environment DB, and the output is the simulation results.

[0143] Step 6:

[0144] The user analyzes the simulation results and identifies areas for improvement in the system as needed. Specifically, the simulation results are evaluated using an analysis tool to extract areas for improvement. The input is the simulation results, and the output is a list of areas for improvement.

[0145] Example 2

[0146] Next, a description will be given of Example 2 of Form 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."

[0147] Conventional data generation systems have difficulty automatically generating data that has the same format as actual data and is suitable for business processing. Furthermore, when generating data for a test environment that does not contain personal information, it is necessary to provide data that is close to the commercial environment, but there has been a lack of efficient ways to achieve this.

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

[0149] In this invention, the server includes means for receiving a prompt sentence entered by a user, means for generating data based on the prompt sentence using a generative AI model, and means for returning the generated data to the user. This makes it possible to automatically generate data that has the same format as actual data and is suitable for business processing based on conditions specified by the user.

[0150] A "user" is an entity that operates the system and inputs prompt sentences.

[0151] A "prompt sentence" is text that describes the type and format of data that the user wants to generate, as well as specific conditions.

[0152] A "generative AI model" is an artificial intelligence model for generating data based on a prompt sentence.

[0153] "Data" is a collection of information generated by a generative AI model, with a particular format and content.

[0154] A "server" is a computer system for running a generative AI model, receiving prompts, and returning generated data.

[0155] A "terminal" is a device through which a user enters prompt sentences and communicates with a server.

[0156] The "means for receiving" is a function that allows the server to receive a prompt sentence from the user.

[0157] "Means for generating" refers to the function by which the server generates data using a generative AI model.

[0158] The "means for returning" is a function that allows the server to return the generated data to the user.

[0159] The "display means" is a function that allows the terminal to show the generated data to the user.

[0160] The present invention relates to a system for automatically generating data based on a prompt sentence entered by a user. A specific embodiment of this system will be described below.

[0161] Using a web browser or a dedicated application, a user inputs a prompt statement that includes the type and format of data they want to generate, as well as specific conditions. For example, they input a prompt statement such as, "Generate customer information in a format that includes name, address, and phone number."

[0162] The device sends the prompt text entered by the user to the server. At this time, the device sends the prompt text to the server using an HTTP request. The server analyzes the received prompt text and executes the generative AI model. Specifically, the server uses a deep learning framework such as TENSORFLOW (registered trademark) or PyTorch to execute the generative AI model on the GPU.

[0163] The generative AI model generates data based on the prompt. This generated data has the same format as the actual data and is suitable for business processing. The server converts the generated data into a standard data format such as JSON and sends it to the terminal as an HTTP response.

[0164] The terminal displays the generated data received from the server to the user. For example, in the case of a web browser, the generated data is displayed on the screen so that the user can check it.

[0165] As a concrete example, consider the case where the following prompt sentence is input to a generative AI model:

[0166] Example prompt sentence:

[0167] "Generate customer information. Format it to include name, address, and phone number."

[0168] When this prompt is sent from the device to the server, the server uses a generative AI model to generate the following data:

[0169] Example of generated data:

[0170] Name: Taro Yamada

[0171] Address: 1-1-1 Nishi-Shinjuku, Shinjuku-ku, Tokyo

[0172] Phone number: 03-1234-5678

[0173] Name: Hanako Sato

[0174] Address: 2-2-2 Umeda, Kita-ku, Osaka City, Osaka Prefecture

[0175] Phone number: 06-8765-4321

[0176] The data generated in this way has the same format as the actual data, and can be used to perform the same business processes in business scenarios in the financial industry.

[0177] This system can automatically generate data suitable for business processing that has the same format as the actual data based on user-specified conditions. This makes it possible to efficiently generate data for a test environment that does not contain personal information and provide data that is close to that of a commercial environment.

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

[0179] Step 1:

[0180] The user enters a prompt statement.

[0181] The user uses a web browser or a dedicated application to input a prompt statement that includes the type and format of the data they want to generate, as well as specific conditions. For example, they input a prompt statement such as, "Please generate customer information in a format that includes name, address, and phone number." The input prompt statement is sent to the terminal.

[0182] Step 2:

[0183] The terminal sends the prompt to the server.

[0184] The terminal sends the prompt text entered by the user to the server as an HTTP POST request. For example, it sends the following request:

[0185] POST / generate-data HTTP / 1.1

[0186] Host: example.com

[0187] Content-Type: application / json

[0188] {

[0189] "prompt": "Generate customer information, including name, address, and phone number."

[0190] }

[0191] The input is a prompt statement, and the output is a request sent to the server.

[0192] Step 3:

[0193] The server receives the prompt and executes the generative AI model.

[0194] The server analyzes the prompt received from the device and executes the generative AI model. Specifically, the server uses a deep learning framework such as TensorFlow or PyTorch to execute the generative AI model on a GPU. The input is the prompt, and the output is the generated data.

[0195] Step 4:

[0196] The server returns the generated data to the terminal.

[0197] The server converts the data generated by the generative AI model into a standard data format such as JSON and sends it to the terminal as an HTTP response. For example, it sends the following response:

[0198] HTTP / 1.1 200 OK

[0199] Content-Type: application / json

[0200] {

[0201] "generated_data": [

[0202] {

[0203] "Name": "Yamada Taro",

[0204] "Address": "1-1-1 Nishi-Shinjuku, Shinjuku-ku, Tokyo",

[0205] "Phone Number": "03-1234-5678"

[0206] },

[0207] {

[0208] "Name": "Hanako Sato",

[0209] "Address": "2-2-2 Umeda, Kita-ku, Osaka City, Osaka Prefecture",

[0210] "Phone Number": "06-8765-4321"

[0211] }

[0212] ]

[0213] }

[0214] The input is the generated data, and the output is the response sent to the terminal.

[0215] Step 5:

[0216] The terminal displays the generated data to the user.

[0217] The terminal displays the generated data received from the server on the screen. For example, in the case of a web browser, the data is displayed using the following HTML code:

[0218] html

[0219]

[0220] Name: Taro Yamada

[0221] Address: 1-1-1 Nishi-Shinjuku, Shinjuku-ku, Tokyo

[0222] Phone number: 03-1234-5678

[0223] Name: Hanako Sato

[0224] Address: 2-2-2 Umeda, Kita-ku, Osaka City, Osaka Prefecture

[0225] Phone number: 06-8765-4321

[0226]

[0227] The input is the generated data received from the server and the output is the display of the data to the user.

[0228] (Application example 2)

[0229] Next, a description will be given of Application Example 2 of Form 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."

[0230] The data required for security testing in financial institutions contains personal information, making it difficult to use actual data. Furthermore, test data must be in a format similar to the actual business environment, but generating such data requires a great deal of effort and time. Therefore, there is a need for a method of generating data that can be used for efficient and safe security testing.

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

[0232] In this invention, the server includes a means for automatically and randomly creating non-existent "possibly real" data, a means for providing the relevant data to a test environment database, a means for making the test environment database not based on personal information and as close to a commercial environment as possible, a data generation means for conducting security tests for financial institutions, and a means for operating as an application to be installed on a smartphone. This makes it possible to efficiently and safely generate the data required for security tests for financial institutions and provide it in a format that is close to an actual business environment.

[0233] "Possibly real data that does not actually exist" is virtual data that does not contain actual personal information or transaction information, but has the same format and content as real data.

[0234] "Random and automated generation means" refers to the ability to generate data in an unpredictable manner using specific algorithms or programs.

[0235] A "test environment database" is a database set up separately from the actual operating environment for testing and verification.

[0236] "Non-personal information" means that the data generated does not contain information about actual individuals.

[0237] "Means to approximate a commercial environment" refers to the function of ensuring that the data generated and its processing are as close as possible to the data and processing used in actual commercial systems.

[0238] "Data generation means for conducting security tests for financial institutions" refers to a function for generating data necessary for financial institutions to conduct security tests.

[0239] "Means that operate as an application installed on a smartphone" refers to the functionality of an application that operates on a smartphone and is provided in a form that the user can use.

[0240] A system for carrying out this invention is configured as follows: A server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment database, means for making the test environment database not based on personal information and as close as possible to a commercial environment, means for generating data for security testing of financial institutions, and means for operating as an application installed on a smartphone.

[0241] Program processing explanation

[0242] The server generates data using Python 3.x. Specifically, it uses a random data generation library to generate data such as customer information, account information, and transaction information. The generated data is provided to a test environment database and stored in a form that does not include personal information. This makes it possible to efficiently and securely generate the data required for security testing at financial institutions and provide it in a format that closely resembles the actual business environment.

[0243] Hardware and software used

[0244] Hardware: Smartphone (iOS or ANDROID (registered trademark))

[0245] Software: Python 3.x, random data generation library

[0246] Specific examples

[0247] For example, when a financial institution conducts security testing, it can input prompt statements like the following into a generative AI model:

[0248] Prompt Sentence Examples

[0249] Generate 100 customer data, 200 account data, and 500 transaction data. Customer data includes customer ID, name, address, and phone number. Account data includes account ID and balance. Transaction data includes transaction ID, source account, destination account, and amount.

[0250] This prompt can be used to request data generation from the generative AI model. The generated data is then provided to a test environment database via an application installed on a smartphone, allowing financial institutions to conduct security tests in a format that closely resembles a real-world business environment.

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

[0252] Step 1:

[0253] A user starts an application on a smartphone and inputs a prompt statement requesting the generation of data required for security testing at a financial institution.

[0254] Input: Prompt statement (e.g., "Generate 100 customer records, 200 account records, and 500 transaction records.")

[0255] Output: The prompt text is sent to the server.

[0256] Step 2:

[0257] The server receives the prompt sentence and inputs the prompt sentence into the generative AI model.

[0258] Input: prompt statement

[0259] Output: A template of the data generated by the generative AI model

[0260] Step 3:

[0261] The server generates actual data using a random data generation library based on the template received from the generative AI model.

[0262] Input: Data template

[0263] Output: Randomly generated customer, account, and transaction data

[0264] Step 4:

[0265] The server stores the generated data in the test environment database.

[0266] Input: Randomly generated data

[0267] Output: Data stored in the test environment database

[0268] Step 5:

[0269] Users can check the generated data through a smartphone application and perform security tests as necessary.

[0270] Input: Data stored in the test environment database

[0271] Output: User-confirmed data and security test results

[0272] Step 6:

[0273] The server analyzes the results of the security test and provides the necessary feedback to the user.

[0274] Input: Security test results

[0275] Output: Feedback report

[0276] Example 3

[0277] Next, a description will be given of a third embodiment of the third embodiment. 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."

[0278] In conventional test environments, data needed to be manually created to replicate actual business scenarios, which was time-consuming and labor-intensive. Furthermore, data containing personal information could not be used, making it difficult to create a test environment that closely resembled a commercial environment. This hindered business efficiency.

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

[0280] In this invention, the server includes means for a user to input a prompt sentence, means for a terminal to send the prompt sentence to the server, means for the server to generate data using a generative AI model, means for the server to save the data generated by the server in a test environment DB, means for a user to check the data in the test environment DB, means for automatically randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to the test environment DB, and means for the test environment DB to be free from personal information and to be as close to a commercial environment as possible. This makes it possible to automatically generate data for reproducing actual business scenarios and provide it to the test environment DB.

[0281] A "user" is an entity that operates the system and inputs prompt sentences.

[0282] A "terminal" is a device through which a user inputs prompt text and sends it to a server.

[0283] The "server" is a device that receives prompt sentences, generates data using a generative AI model, and stores it in the test environment DB.

[0284] A "prompt sentence" is an instruction sentence entered by the user to the generative AI model.

[0285] A "generative AI model" is an artificial intelligence model for generating data based on a prompt sentence.

[0286] "Data" is information generated by a generative AI model to satisfy a specific business scenario.

[0287] The "test environment DB" is a database that stores the generated data and operates in the same way as actual business processing.

[0288] "Possible real data" is data that does not actually exist but is generated based on a real business scenario.

[0289] "Random automated generation" refers to a method that uses a generative AI model to automatically generate data without user intervention.

[0290] "Means to approximate a commercial environment" refers to a method designed to make the test environment DB operate in the same way as an actual commercial environment.

[0291] This invention is a system in which a user inputs a prompt sentence, generates data using a generative AI model, and stores the data in a test environment DB. A specific embodiment of this system will be described below.

[0292] First, the user inputs a prompt sentence using a terminal. The terminal is a device such as a personal computer or smartphone, and must be connected to the Internet. The user opens a browser on the terminal and inputs the prompt sentence into a dedicated input form. Examples of prompt sentences include "Generate data for a scenario in which the transaction is successful" and "Generate data for a scenario in which the transaction fails."

[0293] Next, the terminal sends the entered prompt text to the server. This transmission uses a communication protocol such as an HTTP request. When the submit button on the input form is clicked, the terminal sends an HTTP POST request including the prompt text to the server.

[0294] The server analyzes the received prompt and generates data using a generative AI model. The generative AI model may be an advanced natural language processing model such as OpenAI's GPT-4 (registered trademark). The server generates data that fulfills a specific business scenario based on the prompt. For example, if the prompt is "Generate data for a scenario in which the transaction is successful," the following data will be generated:

[0295] Transaction ID: 12345

[0296] Transaction Status: Success

[0297] Transaction amount: 100,000 yen

[0298] Transaction Date: 2023-10-01 10:00:00

[0299] The generated data is stored in the test environment DB by the server. The test environment DB is a database that operates in the same way as actual business processing, and it is possible to simulate business operations using the generated data. The server inserts the generated data into the test environment DB using an SQL query. For example, execute the following SQL query:

[0300] sql

[0301] INSERT INTO transactions (transaction_id, status, amount, date_time) VALUES (12345, 'success', 100000, '2023-10-01 10:00:00');

[0302] Finally, the user accesses the test environment database via a terminal and checks the generated data. The user can access the test environment database management screen in the terminal browser and verify whether the generated data satisfies the business scenario. For example, the user searches for the record with transaction ID 12345 and checks that the transaction status is "successful."

[0303] In this way, the user can simulate the business using the generated data and improve the business efficiency. This system makes it possible to automatically generate data for reproducing an actual business scenario and provide it to the test environment DB. The flow of the identification process in the third embodiment will be described with reference to FIG. 15.

[0304] Step 1:

[0305] The user enters a prompt statement.

[0306] The user opens a browser on the device and enters the following into a dedicated input form: "Generate data for a scenario in which the transaction is successful." The entered prompt text is saved in the device's memory.

[0307] Step 2:

[0308] The terminal sends the prompt to the server.

[0309] When the submit button of the input form is clicked, the terminal sends an HTTP POST request including a prompt text to the server. The input is the prompt text, and the output is an HTTP request to the server.

[0310] Step 3:

[0311] The server receives and parses the prompt.

[0312] The server parses the received HTTP POST request and extracts the prompt text. The input is the HTTP request and the output is the prompt text.

[0313] Step 4:

[0314] The server generates data using a generative AI model.

[0315] The server inputs the extracted prompt sentences into a generative AI model (e.g., GPT-4) to generate data that meets a specific business scenario. The input is the prompt sentence, and the output is the generated data. For example, the following data is generated:

[0316] Transaction ID: 12345

[0317] Transaction Status: Success

[0318] Transaction amount: 100,000 yen

[0319] Transaction Date: 2023-10-01 10:00:00

[0320] Step 5:

[0321] The data generated by the server is saved in the test environment database.

[0322] The server inserts the generated data into the test environment DB using an SQL query. The input is the generated data, and the output is the data stored in the test environment DB. For example, execute the following SQL query:

[0323] sql

[0324] INSERT INTO transactions (transaction_id, status, amount, date_time) VALUES (12345, 'success', 100000, '2023-10-01 10:00:00');

[0325] Step 6:

[0326] The user checks the data in the test environment database.

[0327] The user accesses the test environment DB management screen using the device's browser and checks the generated data. The input is the test environment DB data, and the output is the data checked by the user. For example, search for the record with transaction ID 12345 and check that the transaction status is "Success."

[0328] (Application example 3)

[0329] Next, a description will be given of Application Example 3 of Form Example 3. 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."

[0330] When simulating business scenarios at logistics centers, it is difficult to create a test environment that operates in the same way as actual business processes. It is also difficult to generate data that is close to a commercial environment while using data that is not based on personal information. This hinders efforts to improve business efficiency and system reliability.

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

[0332] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment DB, means for making the test environment DB not based on personal information and as close to a commercial environment as possible, means for generating data for simulating business scenarios within a logistics center, and means for importing the generated data into the test environment database and verifying whether it operates in the same way as actual business processing. This makes it possible to simulate business scenarios in a logistics center, thereby improving business efficiency and system reliability.

[0333] "Possible realistic data" is data that is generated based on actual business scenarios and mimics realistic situations.

[0334] A "random, automatic generation means" is a device or program that has the function of randomly generating data using a specific algorithm.

[0335] The "test environment DB" is a database used to check and test the system's operation.

[0336] "Non-personally identifiable" means that the data generated does not contain personally identifiable information.

[0337] "Means of approximating a commercial environment" refers to functions and methods for reproducing data and operations that are close to those used in actual commercial systems.

[0338] "Business scenarios within a logistics center" refers to a series of business procedures and situations at a logistics center, such as receiving goods, shipping, inventory management, and returning goods.

[0339] "Data for simulation" is data that imitates a specific business scenario and is generated based on that scenario.

[0340] "Importing into a database in a test environment" means importing the generated data into a database in a test environment and making it operate in the same way as actual business processing.

[0341] "Means for verifying whether the system operates in the same way as actual business processing" refers to a method or device for verifying whether the system operates correctly using the generated data.

[0342] In order to put the present invention into practice, it is necessary to build a system for simulating business scenarios within a logistics center. This system is realized using the following hardware and software.

[0343] Hardware and Software

[0344] Hardware: Smartphone, server, test environment database

[0345] Software: Python environment, data generation algorithms, database management system

[0346] Data processing and calculation

[0347] The server first randomly and automatically creates "possibly real" data that does not actually exist. This data is generated using a data generation algorithm in a Python environment. The generated data is provided to a test environment database. This database uses data that is not based on personal information, but maintains data similar to that of a commercial environment.

[0348] Next, the server generates data to simulate business scenarios within the distribution center. This data is generated based on business scenarios such as product receipt, shipping, inventory management, and return processing. The generated data is imported into a database in a test environment and used to verify whether it behaves in the same way as actual business processes.

[0349] Specific examples

[0350] For example, to simulate a "receiving" scenario at a distribution center, the following prompt statement would be used:

[0351] Prompt Sentence Examples

[0352] python

[0353] Example usage

[0354] scenario = "arrival"

[0355] generated_data = generate_scenario_data(scenario)

[0356] print(generated_data)

[0357] When you run this prompt, you will get the following output:

[0358] json

[0359] {

[0360] "transaction_id": 1234,

[0361] "product_id": 567,

[0362] "quantity": 50,

[0363] "status": "Success"

[0364] }

[0365] The data generated in this way can be imported into a database in a test environment to check whether it operates in the same way as actual business processes. This system makes it possible to simulate business scenarios at logistics centers, thereby improving business efficiency and system reliability.

[0366] The flow of the specific processing in Application Example 3 will be described with reference to FIG.

[0367] Step 1:

[0368] The server receives input from the user about the scenario type (e.g., "receiving," "shipping," "inventory management," "return processing") and determines which business scenario to simulate based on this input.

[0369] Step 2:

[0370] The server uses a Python environment to automatically and randomly create data corresponding to the specified scenario type. For example, for an "Arrival of Goods" scenario, data items such as transaction ID, product ID, quantity, and status are randomly generated. A data generation algorithm is used to generate this data. The input is the scenario type, and the output is the generated data.

[0371] Step 3:

[0372] The server converts the generated data into JSON format and provides it to the test environment database. This database uses data that is not based on personal information and maintains data similar to the production environment. The input is the generated data, and the output is the data imported into the test environment database.

[0373] Step 4:

[0374] The server uses the data imported into the test environment database to simulate business scenarios within the logistics center. For example, in the case of a "receiving" scenario, it checks whether the receiving process for goods is carried out correctly. The input is the data imported into the test environment database, and the output is the simulation results.

[0375] Step 5:

[0376] The server provides the simulation results to the user. The user checks the simulation results and evaluates whether they work in the same way as the actual business process. The input is the simulation results, and the output is feedback to the user.

[0377] In this way, it becomes possible to simulate business scenarios at logistics centers, thereby improving business efficiency and system reliability.

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

[0379] "Example 1"

[0380] In one embodiment of the present invention, the emotion engine recognizes the user's emotion and adjusts parameters for data generation based on the emotion. Specifically, when the user is feeling joy, the emotion engine adjusts parameters to generate data related to joy. This allows the test environment DB to simulate business scenarios related to joy.

[0381] "Example 2"

[0382] In another embodiment of the present invention, the emotion engine selects a specific work scenario based on the user's emotion. For example, when the user feels anxious, the emotion engine selects a work scenario related to anxiety. As a result, the test environment DB contains work scenarios related to anxiety.

[0383] can be simulated.

[0384] "Example 3"

[0385] Furthermore, in another embodiment of the present invention, the emotion engine recognizes the user's emotion, adjusts parameters for data generation based on the emotion, and selects a specific business scenario. For example, when the user is feeling angry, the emotion engine adjusts parameters to generate data related to anger and selects a business scenario related to anger. This allows the test environment DB to simulate a business scenario related to anger.

[0386] The processing flow of each embodiment will be described below.

[0387] "Example 1"

[0388] Step 1: The emotion engine recognizes the user's emotion.

[0389] Step 2: Adjust the parameters of data generation based on the emotions recognized by the emotion engine.

[0390] Step 3: The test environment DB generates data based on the adjusted parameters.

[0391] "Example 2"

[0392] Step 1: The emotion engine recognizes the user's emotion.

[0393] Step 2: Select a specific business scenario based on the emotions recognized by the emotion engine.

[0394] Step 3: Based on the selected business scenario, the test environment DB generates data.

[0395] "Example 3"

[0396] Step 1: The emotion engine recognizes the user's emotion.

[0397] Step 2: Adjust the parameters of data generation based on the emotions recognized by the emotion engine and select a specific business scenario.

[0398] Step 3: The test environment DB generates data based on the adjusted parameters and the selected business scenario.

[0399] Example 1

[0400] Next, a description will be given of Example 1 of Form 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."

[0401] With conventional test environment databases, it was difficult to automatically randomly generate data that did not actually exist but could be considered "realistic," and it was not possible to adjust data generation parameters based on user emotions. As a result, the test environment could not approximate a commercial environment, and business scenarios were not simulated properly. Furthermore, given the demand for data generation that was not based on personal information, an efficient data generation method was needed.

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

[0403] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment database, means for making the test environment database not based on personal information and as close to a commercial environment as possible, means for recognizing user emotions and adjusting parameters for data generation based on the emotions, means for importing the generated data into the test environment database, and means for the test environment database to simulate business scenarios using the provided data. This makes the test environment database closer to a commercial environment, makes it possible to generate data based on user emotions, and enables the simulation of more realistic business scenarios.

[0404] "Potentially real data that does not actually exist" is not real data, but is reliable data that is generated based on real business scenarios and situations.

[0405] "Random, automated generation methods" are techniques that use specific algorithms or programs to automatically generate data in an unpredictable manner.

[0406] A "test environment database" is a database used to test systems and applications, and is intended to simulate conditions close to the actual operating environment.

[0407] "Non-personal information" means that the data generated does not contain information that identifies a specific individual.

[0408] "Means to approximate a commercial environment" refers to techniques and methods for making the test environment database have the same conditions and data structure as an actual commercial operating environment.

[0409] "Means for recognizing user emotions" refers to technology for analyzing the user's emotional state and adjusting the system's behavior based on that.

[0410] "Means for adjusting data generation parameters" refers to technology for changing the characteristics and content of generated data based on the user's emotions and other conditions.

[0411] A "means for importing generated data" is a technique or method for incorporating externally generated data into the test environment database.

[0412] "Means for simulating business scenarios" refers to technology for reproducing actual business processes and scenarios based on a test environment database, and for conducting tests and evaluations.

[0413] This invention is a system that automatically randomly creates "possibly real" data that does not actually exist in a test environment database and provides the relevant data. A specific embodiment of this system will be described below.

[0414] System configuration

[0415] 1. User Emotion Recognition

[0416] A user inputs their emotions into the system using emotion recognition software. For example, if a user is excited about the release of a new product, the user communicates that emotion to the system through the emotion recognition software. The server analyzes the user's emotions using an emotion recognition API (e.g., a general emotion recognition API).

[0417] 2. Defining Data Generation Patterns

[0418] The server defines a data generation pattern based on the user's emotions. For example, if the user is feeling happy, the server defines a data pattern related to a new product release. This pattern includes items such as the product name, release date, and expected sales.

[0419] 3. Generating Random Data

[0420] The server generates random data according to a defined data pattern. For example, it uses Python's random module to generate random data such as product names, release dates, and sales figures. The generated data is saved in JSON or CSV format.

[0421] 4. Providing data to the test environment database

[0422] The server provides the generated data to the test environment database, for example by running an SQL script to import the generated data into a common database management system (DBMS), which adds the new data to the test environment database.

[0423] 5. Business scenario simulation

[0424] The test environment database uses the provided data to simulate business scenarios, such as sales forecasts and marketing strategies related to a new product release. The terminal displays the results of the simulation to the user.

[0425] Specific examples

[0426] For example, if a user is excited about a new product release, they communicate that emotion to the system through emotion recognition software. The server uses the emotion recognition API to analyze the user's emotion as "joy." Next, the server defines a "data pattern related to the new product release" and uses Python's random module to generate data like this:

[0427] Product Name: "ProductX"

[0428] Release Date: "2023-12-01"

[0429] Expected sales: "10000"

[0430] The server runs SQL scripts to import the generated data into popular database management systems, for example by executing SQL statements such as:

[0431] sql

[0432] INSERT INTO test_environment_db (product_name, release_date, expected_sales) VALUES ('ProductX', '2023-12-01', '10000');

[0433] The test environment database uses the imported data to simulate business scenarios related to new product releases. The terminal displays the simulation results to the user, such as sales forecast graphs and marketing strategy simulation results.

[0434] Prompt Sentence Examples

[0435] “If a user is excited about a new product release, how does the emotion engine adjust its parameters for data generation?”

[0436] Using this prompt, the generative AI model can provide detailed explanations of how the emotion engine works and the specific methods used to generate the data.

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

[0438] Step 1:

[0439] User emotion input

[0440] Using emotion recognition software, users input their emotions into the system. For example, if a user is excited about the release of a new product, they input that emotion. The input emotion data is then sent to the server.

[0441] Step 2:

[0442] Emotion Analysis

[0443] The server analyzes the received emotion data using an emotion recognition API. For example, it uses a general emotion recognition API to analyze the user's emotion as "joy." The analysis results are used to adjust the data generation parameters. The input is emotion data, and the output is analyzed emotion information.

[0444] Step 3:

[0445] Defining Data Generation Patterns

[0446] The server defines a data generation pattern based on the analyzed emotional information. For example, if the user is feeling happy, the server defines a "data pattern related to new product release." This pattern includes items such as the product name, release date, and expected sales. The input is the analyzed emotional information, and the output is the data generation pattern.

[0447] Step 4:

[0448] Random Data Generation

[0449] The server generates random data according to a defined data generation pattern. For example, it uses Python's random module to randomly generate data such as product names, release dates, and sales figures. The generated data is saved in JSON or CSV format. The input is the data generation pattern, and the output is the generated random data.

[0450] Step 5:

[0451] Importing Data

[0452] The server imports the generated data into the test environment database. For example, it executes an SQL script to import the generated data into a common database management system. This adds new data to the test environment database. The input is the generated random data, and the output is the data imported into the test environment database.

[0453] Step 6:

[0454] Business scenario simulation

[0455] The test environment database uses the provided data to simulate business scenarios. For example, data related to a new product release is used to simulate sales forecasts and marketing strategies. The terminal displays the simulation results to the user. The input is the data imported into the test environment database, and the output is the simulated results of the business scenario.

[0456] (Application example 1)

[0457] Next, a description will be given of Application Example 1 of Embodiment 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."

[0458] Conventional test environment database systems have difficulty in automatically randomly generating data that does not actually exist but could be considered "realistic," and they are unable to adjust data generation parameters based on user emotions. As a result, the test environment cannot approximate a commercial environment, making it difficult to improve operational efficiency or meet specific business scenarios. Furthermore, it is also impossible to generate and display optimal advertisements based on user emotions.

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

[0460] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the corresponding data to a test environment DB, means for making the test environment DB not based on personal information and as close to a commercial environment as possible, means for recognizing user emotions and adjusting data generation parameters based on those emotions, and means for generating and displaying optimal advertisements based on the user emotions. This makes it possible to make the test environment closer to a commercial environment, improving business efficiency and satisfying specific business scenarios. It also makes it possible to generate and display optimal advertisements based on the user's emotions.

[0461] "Possible real data that does not actually exist" refers to data that does not exist in the real world but could actually occur.

[0462] "Random, automated generation means" refers to devices or programs that have the function of randomly generating data based on specific algorithms or rules.

[0463] "Test environment DB" refers to a database used for testing systems and applications.

[0464] "Means for providing the relevant data" refers to devices or programs that have the function of supplying the generated data to the test environment DB.

[0465] "Not based on personal information" means that the generated data does not contain information that identifies a specific individual.

[0466] "Means to approximate a commercial environment" refers to devices and programs that have the functionality to make the test environment as close as possible to the actual commercial environment.

[0467] "Means for recognizing user's emotions" refers to a device or program that has the function of detecting and identifying the user's emotional state.

[0468] "Means for adjusting data generation parameters" refers to a device or program that has the function of changing the settings and conditions for data generation based on the user's emotions.

[0469] "Means for generating and displaying optimal advertisements" refers to devices or programs that have the function of creating the most appropriate advertisements based on the user's emotions and displaying them to the user.

[0470] The following system configuration will be described as an embodiment of the present invention.

[0471] The server has a means to automatically generate random data that "could be real" but does not actually exist. This means is a device or program that has the function of generating random data based on specific algorithms or rules. For example, a Python program can be used to define a data pattern based on a business scenario and generate random data according to that pattern.

[0472] Next, the server has a means for providing the generated data to the test environment DB. This means is a device or program with the function of supplying the generated data to the test environment DB. The test environment DB is a database used for testing systems and applications, and by using data that is not based on personal information, it can be made closer to a commercial environment while ensuring privacy protection.

[0473] Furthermore, the server has a means for recognizing the user's emotions and adjusting the parameters of data generation based on those emotions. This means is a device or program with the function of detecting and identifying the user's emotional state. For example, if the user inputs the word "happy," the server sets the emotion to "joy" and adjusts the settings and conditions of data generation based on that emotion.

[0474] Finally, the server has a means for generating and displaying the most appropriate advertisement based on the user's emotions. This means is a device or program with the function of creating the most appropriate advertisement based on the user's emotions and displaying it to the user. For example, if the user inputs "I am feeling very happy today!", the emotion engine will recognize "joy" and display an advertisement related to joy.

[0475] For illustrative purposes, consider the following prompt:

[0476] "Design a system that recognizes a user's emotions and generates and displays the most appropriate ads based on those emotions. For example, if a user types 'happy', display ads related to joy."

[0477] In this way, the test environment can be made closer to the commercial environment, improving operational efficiency and meeting specific business scenarios, and generating and displaying optimal ads based on user emotions.

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

[0479] Step 1:

[0480] The server receives input from the user.

[0481] Input: Text that describes the user's feelings (e.g., "I am feeling very happy today!")

[0482] Specific operation: The server receives text data entered by the user.

[0483] Step 2:

[0484] The server uses an emotion engine to recognize the user's emotion.

[0485] Input: Text indicating the user's sentiment

[0486] Data processing: Perform text analysis to identify emotions (e.g., detect the word "happy")

[0487] Output: Recognized emotion (e.g. "joy")

[0488] Specific operation: The server uses a text analysis algorithm to extract sentiment from the user's input text.

[0489] Step 3:

[0490] The server uses a data generation module to adjust parameters of the data generation based on the recognized emotion.

[0491] Input: A recognized emotion (e.g., "joy")

[0492] Data calculation: Select a data generation pattern corresponding to the emotion and set the parameters

[0493] Output: Adjusted data generation parameters

[0494] Specific operation: The server selects a data generation pattern corresponding to the emotion and sets the data generation based on that pattern.

[0495] Step 4:

[0496] The server uses a data generation module to generate random data based on the adjusted parameters.

[0497] Input: Adjusted data generation parameters

[0498] Data manipulation: Generate random data based on parameters

[0499] Output: The generated data

[0500] Specific operation: The server generates random data based on a business scenario according to the set parameters.

[0501] Step 5:

[0502] The server provides the generated data to the test environment DB.

[0503] Input: Generated data

[0504] Data processing: Insert the generated data into the test environment DB

[0505] Output: Data saved in the test environment DB

[0506] Specific operation: The server inserts the generated data into the test environment DB and saves it.

[0507] Step 6:

[0508] The server generates and displays the most appropriate advertisement based on the user's emotions.

[0509] Input: A recognized emotion (e.g., "joy")

[0510] Data Computing: Selecting and generating emotionally relevant ads

[0511] Output: The generated ad

[0512] Specific operation: The server selects an advertisement corresponding to the emotion and generates advertisement data to be displayed to the user.

[0513] In this way, the server can adjust the parameters of data generation based on the user's emotions and generate and display the most appropriate advertisements.

[0514] Example 2

[0515] Next, a description will be given of Example 2 of Form 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."

[0516] There is a demand for building a test environment that is close to a commercial environment without using real-world data. However, it is difficult to automatically create data that is appropriate for business scenarios while generating data that does not contain personal information. Furthermore, there is no system that can select appropriate business scenarios based on user emotions and generate corresponding data. This makes it difficult to build a test environment and hinders business efficiency.

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

[0518] In this invention, the server includes means for automatically randomly generating "possibly real" data that does not actually exist, means for providing the corresponding data to a test environment database, means for making the test environment database not based on personal information and as close to a commercial environment as possible, means for analyzing user emotions, means for selecting specific business scenarios based on the analyzed emotions, means for inputting prompt sentences to a generative AI model based on the selected business scenarios, means for the generative AI model to generate data based on the prompt sentences, and means for saving the generated data in the test environment database. This makes it possible to build a test environment that is similar to a commercial environment and does not contain personal information, and to automatically generate data corresponding to appropriate business scenarios based on user emotions.

[0519] "Potentially real data that does not actually exist" is fictitious data that is generated in a format that mimics real data and can be applied to real business scenarios.

[0520] "Test environment database" means a database used for system testing and simulation, which stores data that does not contain personal information.

[0521] "Non-personally identifiable" means that the data does not contain any personally identifiable information.

[0522] "Bringing it closer to a commercial environment" means creating a test environment by generating data in a format as close as possible to the data formats and business scenarios used in actual commercial systems.

[0523] "Analyzing user sentiment" is the process of reading and identifying sentiment from text and other data entered by a user.

[0524] "Selecting a specific business scenario" means selecting an appropriate business scenario based on the analyzed sentiment.

[0525] A "generative AI model" is a model for generating data using artificial intelligence, such as a model that uses natural language processing technology.

[0526] A "prompt sentence" is an input sentence that gives instructions to the generative AI model to generate data.

[0527] "Generating data" means that the generative AI model creates new data based on the prompt.

[0528] "Saving the data" means storing the generated data in the test environment database.

[0529] This invention is a system that automatically generates data that does not contain personal information based on a business scenario in the financial industry and stores the data in a test environment database. A specific embodiment of this system will be described below.

[0530] First, a user accesses the system using a web browser or dedicated application. The user logs in to the system and enters a request to generate data related to a specific business scenario. For example, the user might enter, "I'm worried about recent market trends."

[0531] The server receives input from the user and analyzes the user's emotions using an emotion engine. This emotion engine uses, for example, an emotion analysis API that uses natural language processing technology. As a result of the analysis, it is detected that the user is feeling "anxiety."

[0532] Next, the server selects an appropriate task scenario based on the analyzed emotion. For example, it selects a task scenario related to "anxiety." Based on this task scenario, the server creates a prompt sentence to be input to the generative AI model. Examples of prompt sentences include:

[0533] Please generate transaction information related to your concerns, including transaction ID, transaction date and time, transaction amount, and transaction details.

[0534] The server sends this prompt sentence to the generative AI model. The generative AI model uses, for example, a model using natural language processing technology (for example, GPT-3 (registered trademark)). Based on the prompt sentence, the generative AI model generates data in the same format as the actual data. An example of the generated data is transaction information such as:

[0535] Transaction ID: 123456

[0536] Transaction Date: 2023-10-01 10:00:00

[0537] Transaction amount: 100,000 yen

[0538] Transaction: Purchase of shares

[0539] The generated data is stored in a test environment database by the server. This allows the test environment database to contain data similar to that of a commercial environment without including personal information. This data can be used to test and simulate the system.

[0540] This system automatically generates data corresponding to appropriate business scenarios based on user emotions and stores it in a test environment database, allowing for the creation of a test environment similar to a commercial environment that does not contain personal information, thereby improving work efficiency.

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

[0542] Step 1:

[0543] A user accesses the system and logs in.

[0544] Specifically, the user accesses the system's login screen using a web browser or a dedicated application, and logs in by entering authentication information.

[0545] Input: User authentication information (user ID, password)

[0546] Output: Login success or failure message

[0547] Step 2:

[0548] A user enters a request related to a particular business scenario.

[0549] Specifically, the user inputs text such as "I'm worried about recent market trends" through the system interface.

[0550] Input: User request text

[0551] Output: The user's request text is sent to the server

[0552] Step 3:

[0553] The server analyzes the user's emotions.

[0554] Specifically, the server sends the request text received from the user to a sentiment analysis API and analyzes the sentiment. For example, it uses a sentiment analysis API that uses natural language processing technology.

[0555] Input: User request text

[0556] Output: Parsed emotion (e.g. "anxiety")

[0557] Step 4:

[0558] The server selects a particular business scenario based on the analyzed emotions.

[0559] Specifically, the server selects an appropriate business scenario based on the emotion analysis results. For example, it selects a business scenario related to "anxiety."

[0560] Input: Parsed sentiment

[0561] Output: Selected business scenario

[0562] Step 5:

[0563] The server creates a prompt to input to the generative AI model.

[0564] Specifically, the server creates a prompt to be input to the generative AI model based on the selected business scenario, such as "Please generate transaction information related to anxiety, including transaction ID, transaction date and time, transaction amount, transaction content, etc."

[0565] Input: Selected business scenario

[0566] Output: Generated prompt statement

[0567] Step 6:

[0568] The server sends a prompt to the generative AI model.

[0569] Specifically, the server sends the generated prompt to a generative AI model, which uses natural language processing technology (e.g., GPT-3).

[0570] Input: Generated prompt text

[0571] Output: The prompt sent to the generative AI model

[0572] Step 7:

[0573] A generative AI model generates data based on the prompt.

[0574] Specifically, the generative AI model generates data in the same format as the actual data based on the prompt, such as generating transaction information.

[0575] Input: prompt statement

[0576] Output: Generated data (e.g., transaction information)

[0577] Step 8:

[0578] The server stores the generated data in the test environment database.

[0579] Specifically, the server stores the data received from the generative AI model in a test environment database, which does not contain personal information but has data similar to that of a commercial environment.

[0580] Input: Generated data

[0581] Output: Data stored in the test environment database

[0582] (Application example 2)

[0583] Next, a description will be given of Application Example 2 of Form 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."

[0584] It is difficult to create a test environment that closely resembles a commercial environment without using real-world data. It is also difficult to select appropriate business scenarios based on user emotions, evaluate security risks, and propose appropriate countermeasures. This can reduce the accuracy and practicality of the test environment, potentially resulting in insufficient security risk assessment and countermeasures.

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

[0586] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment database, means for making the test environment database not based on personal information and as close to a commercial environment as possible, means for recognizing user emotions, means for selecting specific business scenarios based on the recognized emotions, means for evaluating security risks based on the selected business scenarios, and means for proposing appropriate countermeasures based on the evaluated security risks. This makes it possible to build a test environment that is close to a commercial environment without using real data, select appropriate business scenarios based on user emotions, evaluate security risks, and propose appropriate countermeasures.

[0587] "Possible real data" is data that does not actually exist but has the same format and content as real data.

[0588] A "test environment database" is a database used to create a test environment that is close to a commercial environment.

[0589] "Not based on personal information" means not including any information that can identify an individual.

[0590] "Means to approximate a commercial environment" refers to means to reproduce conditions and data similar to those in an actual commercial environment.

[0591] The "means for recognizing a user's emotion" is a means for detecting and identifying the user's emotional state.

[0592] The "means for selecting a specific business scenario" is a means for selecting an appropriate business scenario based on the user's feelings.

[0593] The "means for assessing security risks" is a means for assessing security risks based on a selected business scenario.

[0594] The "means for proposing appropriate measures" is a means for proposing appropriate measures to a user based on the assessed security risk.

[0595] A system for implementing this invention is configured as follows: A server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment database, means for making the test environment database not based on personal information and as close to a commercial environment as possible, means for recognizing a user's emotions, means for selecting a specific business scenario based on the recognized emotions, means for evaluating security risks based on the selected business scenario, and means for proposing appropriate countermeasures based on the evaluated security risks.

[0596] Explanation of program processing

[0597] The server uses a Python program to automatically generate potentially real data that does not actually exist. Specifically, it randomly generates data such as customer information, account information, and transaction information, and provides it to the test environment database. This data is not based on personal information and is in a format similar to that used in a commercial environment.

[0598] To recognize user emotions, we use the EmotionRecognizer library. When a user uses a smartphone, emotional data is collected through the camera and microphone, and the emotion is identified. Based on the recognized emotion, we select a specific business scenario using the SecurityScenarios library.

[0599] Evaluate security risks based on selected business scenarios. Based on the assessed security risks, suggest appropriate measures to users. For example, if there is an increased risk of phishing scams or unauthorized access, recommend setting up two-factor authentication and changing passwords.

[0600] Specific examples

[0601] For example, if a user is feeling anxious, the EmotionRecognizer library detects this from the user's facial expressions and tone of voice. Next, the SecurityScenarios library selects business scenarios related to anxiety and evaluates them as increasing the risk of phishing scams and unauthorized access. Finally, the server suggests the user set up two-factor authentication and change their password.

[0602] Prompt Sentence Examples

[0603] If users are unsure, what are the potential security risks?

[0604] In this way, the server can select an appropriate business scenario based on the user's emotions, evaluate security risks, and propose appropriate countermeasures.

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

[0606] Step 1:

[0607] The server automatically and randomly creates "possibly real" data that does not actually exist. Specifically, it generates data such as customer information, account information, and transaction information. Templates and rules for data generation are required as input, and the generated data is obtained as output. This data is not based on personal information and is in a format similar to that used in a commercial environment.

[0608] Step 2:

[0609] The server provides the generated data to the test environment database. The data generated in step 1 is required as input, and the data stored in the test environment database is obtained as output. This data is used to execute business scenarios in the test environment.

[0610] Step 3:

[0611] The device uses the EmotionRecognizer library to recognize the user's emotions. The input is the user's facial expression and voice data, and the output is the recognized emotion. Specifically, it collects emotion data through the camera and microphone and identifies the emotion.

[0612] Step 4:

[0613] The server selects a specific business scenario based on the recognized emotion. The input is the emotion recognized in step 3, and the output is the selected business scenario. Specifically, it uses the SecurityScenarios library to select a business scenario corresponding to the emotion.

[0614] Step 5:

[0615] The server evaluates the security risk based on the selected business scenario. The business scenario selected in step 4 is required as input, and the evaluated security risk is obtained as output. Specifically, the server analyzes the risk factors related to the business scenario and evaluates the risk level.

[0616] Step 6:

[0617] The server proposes appropriate countermeasures based on the assessed security risk. The input is the security risk assessed in step 5, and the output is the proposed countermeasures. Specifically, the server selects a countermeasure according to the risk level and notifies the user.

[0618] Step 7:

[0619] The user checks the measures proposed by the server and implements them as necessary. The input is the measures proposed in step 6, and the output is the results of the implemented measures. Specific actions include implementing security measures such as setting up two-factor authentication and changing passwords.

[0620] Example 3

[0621] Next, a description will be given of a third embodiment of the third embodiment. 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."

[0622] Conventional test environment databases have difficulty in fully simulating actual business scenarios, making it difficult to generate data that contributes to improving business efficiency. Furthermore, because data generation is not based on user emotions, it is not possible to simulate business scenarios related to specific emotions. This reduces the accuracy and practicality of the test environment, hindering business efficiency.

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

[0624] In this invention, the server includes a means for automatically and randomly generating "possibly real" data that does not actually exist, a means for providing the corresponding data to a test environment database, a means for ensuring that the test environment database is not based on personal information and is as close to a commercial environment as possible, a means for generating data that satisfies a specific business scenario using a generative AI model, and a means for recognizing user emotions and adjusting data generation parameters based on those emotions. This allows the test environment database to accurately simulate actual business scenarios, enabling data generation that contributes to business efficiency. Furthermore, because data is generated based on user emotions, it is possible to simulate business scenarios related to specific emotions.

[0625] "Potentially real data that does not actually exist" is fictitious data that is generated based on a real business scenario but does not actually exist.

[0626] A "test environment database" is a database used to simulate actual business scenarios and operates under conditions close to a commercial environment.

[0627] A "generative AI model" is a model that uses artificial intelligence technology to generate data that satisfies specific business scenarios.

[0628] A "prompt" is a textual instruction entered into a generative AI model that specifies the content and format of the data to be generated.

[0629] "User emotion" refers to the emotional state that the user is feeling, and includes emotions such as joy, anger, and sadness.

[0630] "Data generation parameters" refer to the settings and conditions used by a generative AI model when generating data, which determine the content and format of the generated data.

[0631] A "business scenario" is a scenario for simulating a specific business process or situation, and includes specific business situations such as the success or failure of a transaction.

[0632] This invention is a system that automatically and randomly generates non-existent "possibly real" data and provides it to a test environment database. The system uses a generative AI model to generate data that satisfies specific business scenarios, and includes a function that recognizes user emotions and adjusts the parameters of data generation.

[0633] Hardware and software used

[0634] server

[0635] The server provides the computational resources to run the generative AI model. Specifically, it uses the following software and hardware:

[0636] Generative AI model: OpenAI GPT-4

[0637] Database: MySQL or PostgreSQL

[0638] Emotion Engine: Microsoft® Azure® Cognitive Services

[0639] Terminal

[0640] The terminal provides an interface for users to input prompt sentences and access the emotion engine. The terminal has the following functions:

[0641] Input field: A text box where the user can enter a prompt statement.

[0642] Camera and microphone: Input devices for recognizing user emotions

[0643] User

[0644] The user operates the system, inputs a prompt sentence, and uses the emotion engine to recognize emotions. The system operates as follows according to the user's operation.

[0645] Data processing and calculation

[0646] 1. Enter the prompt:

[0647] The user inputs a prompt statement into an input field on the terminal, for example, "Please generate data for a scenario in which the transaction is successful."

[0648] 2. Send the prompt:

[0649] The terminal sends the entered prompt to the server, using HTTP or HTTPS as the communication protocol.

[0650] 3. Data generation:

[0651] The server inputs the received prompt sentences into a generative AI model (e.g., OpenAI GPT-4) to generate data that satisfies a specific business scenario, such as generating data for a scenario in which a transaction is successful.

[0652] 4. Data storage:

[0653] The server stores the generated data in a test environment database, such as MySQL or PostgreSQL.

[0654] 5. Emotion Recognition:

[0655] Users can access the emotion engine through their devices and have it recognize their own emotions. The emotion engine uses Microsoft Azure Cognitive Services.

[0656] 6. Adjust parameters:

[0657] The server adjusts the parameters for data generation based on the emotion data obtained from the emotion engine. For example, if the user is feeling angry, the parameters are set to generate data related to anger.

[0658] 7. Select a business scenario:

[0659] The server selects a particular business scenario based on the adjusted parameters, for example, a business scenario related to anger.

[0660] 8. Application of Data:

[0661] The server applies the data generated based on the selected business scenario to the test environment database, allowing the test environment database to simulate specific emotions and business scenarios.

[0662] Specific examples

[0663] Prompt Sentence Examples

[0664] "Generate data for scenarios where the trade is successful."

[0665] "Generate data for scenarios where a transaction fails."

[0666] "Generate a business scenario where a user feels angry."

[0667] In this way, the system generates data based on the user's input and emotions, and improves the efficiency of business processing in the test environment database. The flow of the identification processing in the third embodiment will be described with reference to FIG.

[0668] Step 1:

[0669] The user enters a prompt statement.

[0670] The user inputs a prompt into an input field on the terminal, for example, "Please generate data for a scenario in which the transaction is successful." The input prompt is temporarily stored in the terminal's memory.

[0671] Step 2:

[0672] The terminal sends the prompt to the server.

[0673] The terminal sends the entered prompt text to the server as an HTTP POST request, and the sent prompt text is stored in the server's receive buffer.

[0674] Step 3:

[0675] The server generates the data using the generative AI model.

[0676] The server inputs the received prompt sentences into a generative AI model (e.g., OpenAI GPT-4) to generate data that satisfies a specific business scenario. For example, it generates data for a scenario in which a transaction is successful. The generated data is temporarily stored in the server's memory.

[0677] Step 4:

[0678] The server stores the generated data in the test environment database.

[0679] The server saves the generated data in the test environment database using the INSERT statement. The database can be MySQL, PostgreSQL, etc. The saved data is stored in the test environment database.

[0680] Step 5:

[0681] The user uses the emotion engine to recognize emotions.

[0682] Users access the emotion engine through their device and have it recognize their own emotions. The emotion engine uses Microsoft Azure Cognitive Services. The recognized emotion data is temporarily stored in the device's memory.

[0683] Step 6:

[0684] The device transmits the emotion data to the server.

[0685] The device sends the recognized emotion data to the server as an HTTP POST request, which is then stored in the server's receive buffer.

[0686] Step 7:

[0687] The server adjusts the parameters of data generation based on the emotion.

[0688] The server adjusts the parameters for data generation based on the emotion data obtained from the emotion engine. For example, if the user is feeling angry, the parameters are set to generate data related to anger. The adjusted parameters are temporarily stored in the server's memory.

[0689] Step 8:

[0690] The server selects a particular business scenario.

[0691] The server selects a particular business scenario based on the adjusted parameters, for example, a business scenario related to anger, and the selected business scenario is temporarily stored in the server's memory.

[0692] Step 9:

[0693] The server applies the generated data to the test environment database.

[0694] The server applies the data generated based on the selected business scenario to the test environment database, allowing the test environment database to simulate specific emotions and business scenarios. The applied data is stored in the test environment database.

[0695] (Application example 3)

[0696] Next, a description will be given of Application Example 3 of Form Example 3. 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."

[0697] In conventional test environments, it is difficult to generate data to simulate actual business scenarios, and there is a particular problem in that it is not possible to select or adjust scenarios based on user emotions. Furthermore, when issuing security alerts, flexible responses that take user emotions into consideration are required, but current systems are unable to achieve this. This has hindered the realism of the test environment and improvements in business efficiency.

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

[0699] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment DB, means for making the test environment DB not based on personal information and as close to a commercial environment as possible, means for recognizing a user's emotion, means for adjusting parameters for data generation based on the recognized emotion, means for selecting a specific business scenario based on the adjusted parameters, and means for issuing a security alert based on the selected business scenario. This enables data generation and scenario selection according to the user's emotion, improving the realism of the test environment and improving business efficiency.

[0700] "Potentially real data that does not actually exist" is data that is randomly generated to simulate real-world business scenarios, but is not based on actual personal or commercial data.

[0701] The "test environment DB" is a database for simulating actual business scenarios using the generated data.

[0702] "Non-personal information" means that the data generated does not contain information about actual individuals and is in a privacy-preserving format.

[0703] "Approaching a commercial environment" means that the data and scenarios generated are in a format that is as close as possible to situations that may occur in a real commercial environment.

[0704] "Means for recognizing a user's emotions" refers to technology that analyzes a user's facial expressions, voice, and other biometric information to identify their emotional state.

[0705] The "means for adjusting data generation parameters" is a technique for changing the conditions and settings for data generation based on the recognized user emotions.

[0706] The "means for selecting a particular business scenario" is a technique for selecting an appropriate business scenario based on the adjusted parameters.

[0707] The "means for issuing security alerts" is a technique for notifying the user of appropriate security alerts based on the selected business scenario.

[0708] A system for implementing this invention is configured as follows: A server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment DB, means for making the test environment DB not based on personal information and as close as possible to a commercial environment, means for recognizing a user's emotions, means for adjusting parameters for data generation based on the recognized emotions, means for selecting a specific business scenario based on the adjusted parameters, and means for issuing a security alert based on the selected business scenario.

[0709] Hardware and software used

[0710] Hardware: Smartphone (camera, microphone, sensors)

[0711] Software: emotion_recognition library, data_generator library, security_scenarios library

[0712] Data processing and calculation

[0713] 1. Emotion Recognition: Capture the user's facial expressions and voice using the smartphone's camera and microphone, and use the emotion_recognition library to recognize emotions. For example, if the user is feeling angry, detect anger from their facial expressions and tone of voice.

[0714] 2. Parameter adjustment: Based on the recognized emotion, we use the data_generator library to change the conditions and settings for data generation. For example, if the user is feeling angry, we set parameters for generating data related to anger.

[0715] 3. Data generation: Using the tuned parameters, data is generated to meet a specific business scenario, for example, to simulate anger-related security risks.

[0716] 4. Scenario selection: Based on the generated data, select the appropriate business scenario using the security_scenarios library, for example, select the anger-related security risk scenario.

[0717] 5. Alerting: Based on the selected scenario, the system notifies the user with appropriate security alerts, for example, informing the user of countermeasures in the event of an anger-related security risk.

[0718] Specific examples

[0719] For example, if a user feels angry, the system will simulate security risks associated with anger (e.g., unauthorized access or data leakage) and issue appropriate alerts, allowing users to receive flexible security responses according to their emotions.

[0720] Prompt Sentence Examples

[0721] If a user is feeling angry, design a system that simulates the security risks associated with anger and issues appropriate alerts.

[0722] In this way, the emotion-based security alert system realizes flexible security responses according to the user's emotions.

[0723] The flow of the specific processing in Application Example 3 will be described with reference to FIG.

[0724] Step 1:

[0725] The server captures the user's facial expressions and voice using the smartphone's camera and microphone. As input, it receives the user's real-time video and audio data. As output, it passes these data to the emotion_recognition library.

[0726] Step 2:

[0727] The server uses the emotion_recognition library to recognize the user's emotions from the captured video and audio data. As input, it uses the video and audio data acquired in step 1. As output, it obtains the recognized emotion data (e.g., anger, joy, sadness, etc.).

[0728] Step 3:

[0729] The server adjusts the data generation parameters using the data_generator library based on the recognized emotion data. As input, it uses the emotion data obtained in step 2. As output, it obtains the adjusted data generation parameters.

[0730] Step 4:

[0731] The server uses the adjusted parameters to generate data that satisfies a specific business scenario using the data_generator library. As input, it uses the data generation parameters obtained in step 3. As output, it obtains the generated business scenario data.

[0732] Step 5:

[0733] The server selects an appropriate business scenario using the security_scenarios library based on the generated business scenario data. As input, it uses the business scenario data obtained in step 4. As output, it obtains the selected business scenario.

[0734] Step 6:

[0735] The server notifies the user of an appropriate security alert based on the selected business scenario. As input, it uses the business scenario obtained in step 5. As output, it issues a security alert to the user's smartphone.

[0736] In this way, the server can generate data and select scenarios according to the user's emotions and issue appropriate security alerts.

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

[0738] The data generation model 58 is a so-called generative AI (Artificial Intelligence). An example of the data generation model 58 is ChatGPT (registered trademark) (Internet search engine).<URL: https: / / openai.com / blog / chatgpt> ) 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.

[0739] Another example of generative AI is Gemini (registered trademark) (Internet search engine). <url: https: gemini.google.com ?hl="ja">) are listed.

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

[0741] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

[0753] Next, the specific processing by the specific processing unit 290 of the data processing device 12 will be described.

[0754] "Example 1"

[0755] The present invention is a system that automatically generates random, potentially real data that does not actually exist and provides that data to a test environment database. Specifically, a data generation module defines a data pattern based on a business scenario and generates random data according to that pattern. The generated data is provided to the test environment database, which then uses the data to simulate business processes.

[0756] "Example 2"

[0757] As a concrete example, consider a business scenario in the financial industry. Data such as customer information, account information, and transaction information is required, but because this data may contain personal information, it is not possible to use actual data. Therefore, the system of the present invention is used to automatically generate this data. The generated data has the same format as the actual data and can be used to execute the same business processes.

[0758] "Example 3"

[0759] Furthermore, the generated data is created to satisfy specific business scenarios. For example, it is possible to generate data that satisfies various scenarios, such as a scenario in which a certain transaction succeeds or a scenario in which a certain transaction fails. This allows the test environment DB to operate in the same way as actual business processing, contributing to business efficiency.

[0760] The processing flow of each embodiment will be described below.

[0761] "Example 1"

[0762] Step 1: The data generation module defines data patterns based on business scenarios.

[0763] Step 2: The data generation module generates random data according to the defined pattern.

[0764] Step 3: The generated data is provided to the test environment DB.

[0765] Step 4: The test environment DB simulates business processing using the provided data.

[0766] "Example 2"

[0767] Step 1: Consider a business scenario in the financial industry and define data patterns such as customer information, account information, and transaction information.

[0768] Step 2: Based on the defined data patterns, the system of the present invention is used to automatically generate these data.

[0769] Step 3: The generated data has the same format as the actual data and can be used to perform the same business processes.

[0770] "Example 3"

[0771] Step 1: Define specific business scenarios (e.g., scenarios in which a transaction succeeds, scenarios in which a transaction fails).

[0772] Step 2: Generate data that satisfies the defined business scenario.

[0773] Step 3: The generated data is provided to the test environment DB, which uses the data to simulate business processes.

[0774] Example 1

[0775] Next, a description will be given of Example 1 of Form 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."

[0776] By randomly and automatically generating data that does not exist in reality but could be real, and providing it to a test environment database, it is necessary to create a test environment that is close to a commercial environment while using data that is not based on personal information.It is also important that the generated data contributes to business efficiency and satisfies specific business scenarios.

[0777] The identification process by the identification processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means. In this invention, the server includes a means for defining a data pattern based on a business scenario, a means for generating random data according to the defined data pattern, and a means for providing the generated data to the test environment database. This makes it possible to build a test environment that is not based on personal information but is close to a commercial environment, generate data that contributes to business efficiency, and provide data that satisfies a specific business scenario.

[0778] A "business scenario" is a plan or scenario that indicates a specific business process or operation procedure, and serves as a basis for data generation.

[0779] A "data pattern" defines the format and structure of the data to be generated, and includes the data type and generation method of each field.

[0780] "Random data" is data that is generated without following any particular rules or patterns and has unpredictable values.

[0781] A "test environment database" is a database used to test and verify a system, which differs from the actual operating environment but has a configuration similar to that of a commercial environment.

[0782] "Business process simulation" refers to simulating actual business processes using data provided in the test environment database, and is used to check system operation and perform performance tests.

[0783] This invention is a system that automatically randomly creates data that does not actually exist but that "might be real" for a test environment database and provides the relevant data. A specific embodiment of this system will be described below.

[0784] System configuration

[0785] Hardware and Software Use

[0786] The server uses programming languages ​​such as Python and Java to run the data generation module, data processing libraries such as NumPy and Pandas for data processing, and database management systems such as MySQL and PostgreSQL for the test environment database.

[0787] Program processing

[0788] Entering business scenarios

[0789] Users enter business scenarios through a web interface, with input forms containing fields such as customer ID, customer name, address, and phone number.

[0790] Data Pattern Definition

[0791] The server defines a data pattern based on the business scenario entered by the user, including the data type and generation method for each field, for example, customer ID is an integer, customer name is a string, address is a string, and phone number is a number.

[0792] Random Data Generation

[0793] The server generates random data according to a defined data pattern, using libraries such as NumPy or Pandas. For example, it uses NumPy's numpy.random module to generate random integers and strings.

[0794] Providing data to the test environment DB

[0795] The server provides the generated data to the test environment database. The generated data is inserted into the test environment database using the Python sqlalchemy library. For example, the data is inserted using the sqlalchemy insert method.

[0796] Business process simulation

[0797] The test environment database uses the provided data to simulate business processes, allowing system operation and performance testing to be performed. For example, operations such as searching and updating customer information are performed.

[0798] Specific examples

[0799] Suppose a user wants to test a new customer management system. In this case, the user enters the following business scenario:

[0800] Customer ID: Random integer

[0801] Customer Name: Random string

[0802] Address: Random string

[0803] Phone Number: Random numbers

[0804] The server generates 1,000 customer data items according to these patterns and provides them to the test environment database, which uses this data to simulate the operation of the customer management system.

[0805] Example prompt sentence:

[0806] "Generate test data for the customer management system. Create 1,000 records with random integers for customer IDs, random strings for customer names, random strings for addresses, and random numbers for phone numbers, and provide them to the test environment database."

[0807] The above is a specific embodiment for carrying out the present invention.

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

[0809] Step 1: Enter the business scenario

[0810] A user inputs a business scenario through a web interface. The input form contains fields such as customer ID, customer name, address, and phone number. As input, the user specifies specific data patterns for these fields. As output, the server receives these input data and stores them for use in the next step.

[0811] Specific behavior:

[0812] A user accesses a web form using a browser and enters a data pattern into each field: for example, an "integer" for a customer ID, a "string" for a customer name, a "string" for an address, and a "number" for a phone number.

[0813] Step 2: Define the data pattern

[0814] The server defines a data pattern based on the business scenario entered by the user. As input, it receives a data pattern specified by the user and generates as output a data pattern including the data type and generation method of each field.

[0815] Specific behavior:

[0816] The server uses a Python dictionary data structure to define the data pattern for each field: for example, customer ID is an integer, customer name is a string, address is a string, and phone number is a number.

[0817] Step 3: Generate random data

[0818] The server generates random data according to a defined data pattern, taking the data pattern as input and obtaining the randomly generated data as output.

[0819] Specific behavior:

[0820] The server uses NumPy's numpy.random module to generate random integers and strings, for example, numpy.random.randint(1000, 9999) to generate a random customer ID, and numpy.random.choice to generate a random string.

[0821] Step 4: Provide data to the test environment database

[0822] The server provides the generated data to the test environment database, taking as input randomly generated data and as output inserting data into the test environment database.

[0823] Specific behavior:

[0824] The server uses the Python sqlalchemy library to insert the generated data into the test environment database, for example by using the sqlalchemy insert method.

[0825] Step 5: Simulating business processes

[0826] The test environment database uses the provided data to simulate business processes, receiving as input the data inserted into the test environment database and obtaining as output the results of the business processes.

[0827] Specific behavior:

[0828] The test environment database executes queries based on the provided data and simulates business processes, such as searching and updating customer information, allowing for system operation confirmation and performance testing.

[0829] (Application example 1)

[0830] Next, a description will be given of Application Example 1 of Form 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."

[0831] In a test environment for autonomous vehicles, it is necessary to randomly generate realistic traffic data and provide it to a test environment database. However, collecting real traffic data is costly and time-consuming, and personal information must be protected, making it difficult to build a test environment efficiently and safely.

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

[0833] In this invention, the server includes a means for automatically and randomly creating potentially real data that does not actually exist, a means for providing the relevant data to the test environment DB, a means for making the test environment DB not based on personal information and as close to a commercial environment as possible, a means for defining traffic data patterns and generating random traffic data according to the patterns, and a means for providing the generated traffic data to the test environment DB. This makes it possible to efficiently and safely generate potentially real traffic data and provide it to the test environment.

[0834] "Possible real data" refers to data that does not actually exist but could occur in a real situation.

[0835] "Random automatic generation means" refers to a device or program that has the function of randomly generating data based on specific algorithms or rules.

[0836] A "test environment DB" is a database used to verify the operation of systems and applications.

[0837] "Non-personal information" means that the data generated does not contain information that identifies a specific individual.

[0838] "Means to approximate a commercial environment" refers to methods and techniques for making the test environment as close as possible to the actual commercial operating environment.

[0839] "Traffic data pattern" refers to a particular format or structure of data relating to traffic conditions and vehicle movements.

[0840] "Means for generating random traffic data" refers to a device or program that has the function of randomly generating traffic data based on traffic data patterns.

[0841] "Means for providing the generated traffic data to the test environment DB" refers to methods or techniques for inputting or storing the generated traffic data in the test environment database.

[0842] The system for carrying out the present invention operates in cooperation with three entities: a server, a terminal, and a user. A specific embodiment of the system will be described below.

[0843] Server Roles

[0844] The server has a means to automatically and randomly create "possibly real" data that does not actually exist. Specifically, the server defines traffic data patterns and generates random traffic data according to those patterns. The generated data is provided to the test environment DB. The server is implemented using a programming language such as Python, and a program containing a data generation algorithm runs on it.

[0845] Device Role

[0846] The terminal receives data provided by the server and saves it in the test environment DB. The terminal manages the data using a database management system (DBMS) and simulates business processing in the test environment. Specifically, the terminal saves data using the MockDatabase class and displays the inserted data.

[0847] User Roles

[0848] Users use the generated data to test autonomous vehicles. Users conduct simulations and tests based on the data stored in the test environment DB. This allows them to simulate realistic traffic situations and evaluate the performance and safety of autonomous vehicles.

[0849] Hardware and software used

[0850] Server: The computer system on which the Python program runs.

[0851] Terminal: A computer system equipped with a database management system (DBMS).

[0852] User: A computer system that can access the test environment database

[0853] Data processing and calculation

[0854] The server generates random traffic data based on traffic data patterns. Specifically, it randomly generates vehicle IDs, speeds, location information (latitude and longitude), and timestamps. The generated data is sent to the terminal and stored in the test environment database. The user uses this data to perform simulations.

[0855] Specific examples

[0856] For example, to generate data based on an urban traffic scenario, you might use a prompt like this:

[0857] Generate random traffic data based on an urban traffic scenario, including vehicle ID, speed, location (latitude and longitude), and timestamp.

[0858] Using this prompt, the generative AI model can generate data suitable for urban traffic scenarios, which is then stored in the test environment database and used for testing autonomous vehicles.

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

[0860] Step 1:

[0861] The server defines the traffic data pattern. Specifically, it sets data items such as vehicle ID, speed, location information (latitude and longitude), and timestamp. This determines the format of the generated data. The input is the traffic data pattern definition, and the output is the defined data pattern.

[0862] Step 2:

[0863] The server generates random traffic data based on a defined traffic data pattern. Specifically, it randomly generates a vehicle ID, randomly sets the speed in the range of 0 to 120, randomly determines location information (latitude and longitude), and randomly generates a timestamp. The input is the defined data pattern, and the output is the generated random traffic data.

[0864] Step 3:

[0865] The server transmits the generated traffic data to the terminal. Specifically, it converts the generated data into a data format such as JSON and transmits it to the terminal via the network. The input is the generated traffic data, and the output is the data transmitted to the terminal.

[0866] Step 4:

[0867] The terminal stores the traffic data received from the server in the test environment DB. Specifically, the received data is inserted into the database management system (DBMS) and saved. The input is the data received from the server, and the output is the data saved in the test environment DB.

[0868] Step 5:

[0869] Users use the data stored in the test environment DB to test autonomous vehicles. Specifically, they perform simulations based on the stored data to evaluate the performance and safety of autonomous vehicles. The input is the data stored in the test environment DB, and the output is the simulation results.

[0870] Step 6:

[0871] The user analyzes the simulation results and identifies areas for improvement in the system as needed. Specifically, the simulation results are evaluated using an analysis tool to extract areas for improvement. The input is the simulation results, and the output is a list of areas for improvement.

[0872] Example 2

[0873] Next, a description will be given of Example 2 of Form 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."

[0874] Conventional data generation systems have difficulty automatically generating data that has the same format as actual data and is suitable for business processing. Furthermore, when generating data for a test environment that does not contain personal information, it is necessary to provide data that is close to the commercial environment, but there has been a lack of efficient ways to achieve this.

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

[0876] In this invention, the server includes means for receiving a prompt sentence entered by a user, means for generating data based on the prompt sentence using a generative AI model, and means for returning the generated data to the user. This makes it possible to automatically generate data that has the same format as actual data and is suitable for business processing based on conditions specified by the user.

[0877] A "user" is an entity that operates the system and inputs prompt sentences.

[0878] A "prompt sentence" is text that describes the type and format of data that the user wants to generate, as well as specific conditions.

[0879] A "generative AI model" is an artificial intelligence model for generating data based on a prompt sentence.

[0880] "Data" is a collection of information generated by a generative AI model, with a particular format and content.

[0881] A "server" is a computer system for running a generative AI model, receiving prompts, and returning generated data.

[0882] A "terminal" is a device through which a user enters prompt sentences and communicates with a server.

[0883] The "means for receiving" is a function that allows the server to receive a prompt sentence from the user.

[0884] "Means for generating" refers to the function by which the server generates data using a generative AI model.

[0885] The "means for returning" is a function that allows the server to return the generated data to the user.

[0886] The "display means" is a function that allows the terminal to show the generated data to the user.

[0887] The present invention relates to a system for automatically generating data based on a prompt sentence entered by a user. A specific embodiment of this system will be described below.

[0888] Using a web browser or a dedicated application, a user inputs a prompt statement that includes the type and format of data they want to generate, as well as specific conditions. For example, they input a prompt statement such as, "Generate customer information in a format that includes name, address, and phone number."

[0889] The device sends the prompt text entered by the user to the server using an HTTP request. The server then analyzes the received prompt text and executes the generative AI model. Specifically, the server uses a deep learning framework such as TensorFlow or PyTorch to execute the generative AI model on the GPU.

[0890] The generative AI model generates data based on the prompt. This generated data has the same format as the actual data and is suitable for business processing. The server converts the generated data into a standard data format such as JSON and sends it to the terminal as an HTTP response.

[0891] The terminal displays the generated data received from the server to the user. For example, in the case of a web browser, the generated data is displayed on the screen so that the user can check it.

[0892] As a concrete example, consider the case where the following prompt sentence is input to a generative AI model:

[0893] Example prompt sentence:

[0894] "Generate customer information. Format it to include name, address, and phone number."

[0895] When this prompt is sent from the device to the server, the server uses a generative AI model to generate the following data:

[0896] Example of generated data:

[0897] Name: Taro Yamada

[0898] Address: 1-1-1 Nishi-Shinjuku, Shinjuku-ku, Tokyo

[0899] Phone number: 03-1234-5678

[0900] Name: Hanako Sato

[0901] Address: 2-2-2 Umeda, Kita-ku, Osaka City, Osaka Prefecture

[0902] Phone number: 06-8765-4321

[0903] The data generated in this way has the same format as the actual data, and can be used to perform the same business processes in business scenarios in the financial industry.

[0904] This system can automatically generate data suitable for business processing that has the same format as the actual data based on user-specified conditions. This makes it possible to efficiently generate data for a test environment that does not contain personal information and provide data that is close to that of a commercial environment.

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

[0906] Step 1:

[0907] The user enters a prompt statement.

[0908] The user uses a web browser or a dedicated application to input a prompt statement that includes the type and format of the data they want to generate, as well as specific conditions. For example, they input a prompt statement such as, "Please generate customer information in a format that includes name, address, and phone number." The input prompt statement is sent to the terminal.

[0909] Step 2:

[0910] The terminal sends the prompt to the server.

[0911] The terminal sends the prompt text entered by the user to the server as an HTTP POST request. For example, it sends the following request:

[0912] POST / generate-data HTTP / 1.1

[0913] Host: example.com

[0914] Content-Type: application / json

[0915] {

[0916] "prompt": "Generate customer information, including name, address, and phone number."

[0917] }

[0918] The input is a prompt statement, and the output is a request sent to the server.

[0919] Step 3:

[0920] The server receives the prompt and executes the generative AI model.

[0921] The server analyzes the prompt received from the device and executes the generative AI model. Specifically, the server uses a deep learning framework such as TensorFlow or PyTorch to execute the generative AI model on a GPU. The input is the prompt, and the output is the generated data.

[0922] Step 4:

[0923] The server returns the generated data to the terminal.

[0924] The server converts the data generated by the generative AI model into a standard data format such as JSON and sends it to the terminal as an HTTP response. For example, it sends the following response:

[0925] HTTP / 1.1 200 OK

[0926] Content-Type: application / json

[0927] {

[0928] "generated_data": [

[0929] {

[0930] "Name": "Yamada Taro",

[0931] "Address": "1-1-1 Nishi-Shinjuku, Shinjuku-ku, Tokyo",

[0932] "Phone Number": "03-1234-5678"

[0933] },

[0934] {

[0935] "Name": "Hanako Sato",

[0936] "Address": "2-2-2 Umeda, Kita-ku, Osaka City, Osaka Prefecture",

[0937] "Phone Number": "06-8765-4321"

[0938] }

[0939] ]

[0940] }

[0941] The input is the generated data, and the output is the response sent to the terminal.

[0942] Step 5:

[0943] The terminal displays the generated data to the user.

[0944] The terminal displays the generated data received from the server on the screen. For example, in the case of a web browser, the data is displayed using the following HTML code:

[0945] html

[0946]

[0947] Name: Taro Yamada

[0948] Address: 1-1-1 Nishi-Shinjuku, Shinjuku-ku, Tokyo

[0949] Phone number: 03-1234-5678

[0950] Name: Hanako Sato

[0951] Address: 2-2-2 Umeda, Kita-ku, Osaka City, Osaka Prefecture

[0952] Phone number: 06-8765-4321

[0953]

[0954] The input is the generated data received from the server and the output is the display of the data to the user.

[0955] (Application example 2)

[0956] Next, a description will be given of Application Example 2 of Form 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."

[0957] The data required for security testing in financial institutions contains personal information, making it difficult to use actual data. Furthermore, test data must be in a format similar to the actual business environment, but generating such data requires a great deal of effort and time. Therefore, there is a need for a method of generating data that can be used for efficient and safe security testing.

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

[0959] In this invention, the server includes a means for automatically and randomly creating non-existent "possibly real" data, a means for providing the relevant data to a test environment database, a means for making the test environment database not based on personal information and as close to a commercial environment as possible, a data generation means for conducting security tests for financial institutions, and a means for operating as an application to be installed on a smartphone. This makes it possible to efficiently and safely generate the data required for security tests for financial institutions and provide it in a format that is close to an actual business environment.

[0960] "Possibly real data that does not actually exist" is virtual data that does not contain actual personal information or transaction information, but has the same format and content as real data.

[0961] "Random and automated generation means" refers to the ability to generate data in an unpredictable manner using specific algorithms or programs.

[0962] A "test environment database" is a database set up separately from the actual operating environment for testing and verification.

[0963] "Non-personal information" means that the data generated does not contain information about actual individuals.

[0964] "Means to approximate a commercial environment" refers to the function of ensuring that the data generated and its processing are as close as possible to the data and processing used in actual commercial systems.

[0965] "Data generation means for conducting security tests for financial institutions" refers to a function for generating data necessary for financial institutions to conduct security tests.

[0966] "Means that operate as an application installed on a smartphone" refers to the functionality of an application that operates on a smartphone and is provided in a form that the user can use.

[0967] A system for carrying out this invention is configured as follows: A server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment database, means for making the test environment database not based on personal information and as close as possible to a commercial environment, means for generating data for security testing of financial institutions, and means for operating as an application installed on a smartphone.

[0968] Program processing explanation

[0969] The server generates data using Python 3.x. Specifically, it uses a random data generation library to generate data such as customer information, account information, and transaction information. The generated data is provided to a test environment database and stored in a form that does not include personal information. This makes it possible to efficiently and securely generate the data required for security testing at financial institutions and provide it in a format that closely resembles the actual business environment.

[0970] Hardware and software used

[0971] Hardware: Smartphone (iOS or Android)

[0972] Software: Python 3.x, random data generation library

[0973] Specific examples

[0974] For example, when a financial institution conducts security testing, it can input prompt statements like the following into a generative AI model:

[0975] Prompt Sentence Examples

[0976] Generate 100 customer data, 200 account data, and 500 transaction data. Customer data includes customer ID, name, address, and phone number. Account data includes account ID and balance. Transaction data includes transaction ID, source account, destination account, and amount.

[0977] This prompt can be used to request data generation from the generative AI model. The generated data is then provided to a test environment database via an application installed on a smartphone, allowing financial institutions to conduct security tests in a format that closely resembles a real-world business environment.

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

[0979] Step 1:

[0980] A user starts an application on a smartphone and inputs a prompt statement requesting the generation of data required for security testing at a financial institution.

[0981] Input: Prompt statement (e.g., "Generate 100 customer records, 200 account records, and 500 transaction records.")

[0982] Output: The prompt text is sent to the server.

[0983] Step 2:

[0984] The server receives the prompt sentence and inputs the prompt sentence into the generative AI model.

[0985] Input: prompt statement

[0986] Output: A template of the data generated by the generative AI model

[0987] Step 3:

[0988] The server generates actual data using a random data generation library based on the template received from the generative AI model.

[0989] Input: Data template

[0990] Output: Randomly generated customer, account, and transaction data

[0991] Step 4:

[0992] The server stores the generated data in the test environment database.

[0993] Input: Randomly generated data

[0994] Output: Data stored in the test environment database

[0995] Step 5:

[0996] Users can check the generated data through a smartphone application and perform security tests as necessary.

[0997] Input: Data stored in the test environment database

[0998] Output: User-confirmed data and security test results

[0999] Step 6:

[1000] The server analyzes the results of the security test and provides the necessary feedback to the user.

[1001] Input: Security test results

[1002] Output: Feedback report

[1003] Example 3

[1004] Next, a description will be given of Example 3 of Form Example 3. 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."

[1005] In conventional test environments, data needed to be manually created to replicate actual business scenarios, which was time-consuming and labor-intensive. Furthermore, data containing personal information could not be used, making it difficult to create a test environment that closely resembled a commercial environment. This hindered business efficiency.

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

[1007] In this invention, the server includes means for a user to input a prompt sentence, means for a terminal to send the prompt sentence to the server, means for the server to generate data using a generative AI model, means for the server to save the data generated by the server in a test environment DB, means for a user to check the data in the test environment DB, means for automatically randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to the test environment DB, and means for the test environment DB to be free from personal information and to be as close to a commercial environment as possible. This makes it possible to automatically generate data for reproducing actual business scenarios and provide it to the test environment DB.

[1008] A "user" is an entity that operates the system and inputs prompt sentences.

[1009] A "terminal" is a device through which a user inputs prompt text and sends it to a server.

[1010] The "server" is a device that receives prompt sentences, generates data using a generative AI model, and stores it in the test environment DB.

[1011] A "prompt sentence" is an instruction sentence entered by the user to the generative AI model.

[1012] A "generative AI model" is an artificial intelligence model for generating data based on a prompt sentence.

[1013] "Data" is information generated by a generative AI model to satisfy a specific business scenario.

[1014] The "test environment DB" is a database that stores the generated data and operates in the same way as actual business processing.

[1015] "Possible real data" is data that does not actually exist but is generated based on a real business scenario.

[1016] "Random automated generation" refers to a method that uses a generative AI model to automatically generate data without user intervention.

[1017] "Means to approximate a commercial environment" refers to a method designed to make the test environment DB operate in the same way as an actual commercial environment.

[1018] This invention is a system in which a user inputs a prompt sentence, generates data using a generative AI model, and stores the data in a test environment DB. A specific embodiment of this system will be described below.

[1019] First, the user inputs a prompt sentence using a terminal. The terminal is a device such as a personal computer or smartphone, and must be connected to the Internet. The user opens a browser on the terminal and inputs the prompt sentence into a dedicated input form. Examples of prompt sentences include "Generate data for a scenario in which the transaction is successful" and "Generate data for a scenario in which the transaction fails."

[1020] Next, the terminal sends the entered prompt text to the server. This transmission uses a communication protocol such as an HTTP request. When the submit button on the input form is clicked, the terminal sends an HTTP POST request including the prompt text to the server.

[1021] The server analyzes the received prompt and generates data using a generative AI model. The generative AI model can be an advanced natural language processing model such as OpenAI's GPT-4. The server generates data that fulfills a specific business scenario based on the prompt. For example, if the prompt is "Generate data for a scenario in which the transaction is successful," the following data will be generated:

[1022] Transaction ID: 12345

[1023] Transaction Status: Success

[1024] Transaction amount: 100,000 yen

[1025] Transaction Date: 2023-10-01 10:00:00

[1026] The generated data is stored in the test environment DB by the server. The test environment DB is a database that operates in the same way as actual business processing, and it is possible to simulate business operations using the generated data. The server inserts the generated data into the test environment DB using an SQL query. For example, execute the following SQL query:

[1027] sql

[1028] INSERT INTO transactions (transaction_id, status, amount, date_time) VALUES (12345, 'success', 100000, '2023-10-01 10:00:00');

[1029] Finally, the user accesses the test environment database via a terminal and checks the generated data. The user can access the test environment database management screen in the terminal browser and verify whether the generated data satisfies the business scenario. For example, the user searches for the record with transaction ID 12345 and checks that the transaction status is "successful."

[1030] In this way, the user can simulate the business using the generated data and improve the business efficiency. This system makes it possible to automatically generate data for reproducing an actual business scenario and provide it to the test environment DB. The flow of the identification process in the third embodiment will be described with reference to FIG. 15.

[1031] Step 1:

[1032] The user enters a prompt statement.

[1033] The user opens a browser on the device and enters the following into a dedicated input form: "Generate data for a scenario in which the transaction is successful." The entered prompt text is saved in the device's memory.

[1034] Step 2:

[1035] The terminal sends the prompt to the server.

[1036] When the submit button of the input form is clicked, the terminal sends an HTTP POST request including a prompt text to the server. The input is the prompt text, and the output is an HTTP request to the server.

[1037] Step 3:

[1038] The server receives and parses the prompt.

[1039] The server parses the received HTTP POST request and extracts the prompt text. The input is the HTTP request and the output is the prompt text.

[1040] Step 4:

[1041] The server generates data using a generative AI model.

[1042] The server inputs the extracted prompt sentences into a generative AI model (e.g., GPT-4) to generate data that meets a specific business scenario. The input is the prompt sentence, and the output is the generated data. For example, the following data is generated:

[1043] Transaction ID: 12345

[1044] Transaction Status: Success

[1045] Transaction amount: 100,000 yen

[1046] Transaction Date: 2023-10-01 10:00:00

[1047] Step 5:

[1048] The data generated by the server is saved in the test environment database.

[1049] The server inserts the generated data into the test environment DB using an SQL query. The input is the generated data, and the output is the data stored in the test environment DB. For example, execute the following SQL query:

[1050] sql

[1051] INSERT INTO transactions (transaction_id, status, amount, date_time) VALUES (12345, 'success', 100000, '2023-10-01 10:00:00');

[1052] Step 6:

[1053] The user checks the data in the test environment database.

[1054] The user accesses the test environment DB management screen using the device's browser and checks the generated data. The input is the test environment DB data, and the output is the data checked by the user. For example, search for the record with transaction ID 12345 and check that the transaction status is "Success."

[1055] (Application example 3)

[1056] Next, a description will be given of Application Example 3 of Form Example 3. 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."

[1057] When simulating business scenarios at logistics centers, it is difficult to create a test environment that operates in the same way as actual business processes. It is also difficult to generate data that is close to a commercial environment while using data that is not based on personal information. This hinders efforts to improve business efficiency and system reliability.

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

[1059] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment DB, means for making the test environment DB not based on personal information and as close to a commercial environment as possible, means for generating data for simulating business scenarios within a logistics center, and means for importing the generated data into the test environment database and verifying whether it operates in the same way as actual business processing. This makes it possible to simulate business scenarios in a logistics center, thereby improving business efficiency and system reliability.

[1060] "Possible realistic data" is data that is generated based on actual business scenarios and mimics realistic situations.

[1061] A "random, automatic generation means" is a device or program that has the function of randomly generating data using a specific algorithm.

[1062] The "test environment DB" is a database used to check and test the system's operation.

[1063] "Non-personally identifiable" means that the data generated does not contain personally identifiable information.

[1064] "Means of approximating a commercial environment" refers to functions and methods for reproducing data and operations that are close to those used in actual commercial systems.

[1065] "Business scenarios within a logistics center" refers to a series of business procedures and situations at a logistics center, such as receiving goods, shipping, inventory management, and returning goods.

[1066] "Data for simulation" is data that imitates a specific business scenario and is generated based on that scenario.

[1067] "Importing into a database in a test environment" means importing the generated data into a database in a test environment and making it operate in the same way as actual business processing.

[1068] "Means for verifying whether the system operates in the same way as actual business processing" refers to a method or device for verifying whether the system operates correctly using the generated data.

[1069] In order to put the present invention into practice, it is necessary to build a system for simulating business scenarios within a logistics center. This system is realized using the following hardware and software.

[1070] Hardware and Software

[1071] Hardware: Smartphone, server, test environment database

[1072] Software: Python environment, data generation algorithms, database management system

[1073] Data processing and calculation

[1074] The server first randomly and automatically creates "possibly real" data that does not actually exist. This data is generated using a data generation algorithm in a Python environment. The generated data is provided to a test environment database. This database uses data that is not based on personal information, but maintains data similar to that of a commercial environment.

[1075] Next, the server generates data to simulate business scenarios within the distribution center. This data is generated based on business scenarios such as product receipt, shipping, inventory management, and return processing. The generated data is imported into a database in a test environment and used to verify whether it behaves in the same way as actual business processes.

[1076] Specific examples

[1077] For example, to simulate a "receiving" scenario at a distribution center, the following prompt statement would be used:

[1078] Prompt Sentence Examples

[1079] python

[1080] Example usage

[1081] scenario = "arrival"

[1082] generated_data = generate_scenario_data(scenario)

[1083] print(generated_data)

[1084] When you run this prompt, you will get the following output:

[1085] json

[1086] {

[1087] "transaction_id": 1234,

[1088] "product_id": 567,

[1089] "quantity": 50,

[1090] "status": "Success"

[1091] }

[1092] The data generated in this way can be imported into a database in a test environment to check whether it operates in the same way as actual business processes. This system makes it possible to simulate business scenarios at logistics centers, thereby improving business efficiency and system reliability.

[1093] The flow of the specific processing in Application Example 3 will be described with reference to FIG.

[1094] Step 1:

[1095] The server receives input from the user about the scenario type (e.g., "receiving," "shipping," "inventory management," "return processing") and determines which business scenario to simulate based on this input.

[1096] Step 2:

[1097] The server uses a Python environment to automatically and randomly create data corresponding to the specified scenario type. For example, for an "Arrival of Goods" scenario, data items such as transaction ID, product ID, quantity, and status are randomly generated. A data generation algorithm is used to generate this data. The input is the scenario type, and the output is the generated data.

[1098] Step 3:

[1099] The server converts the generated data into JSON format and provides it to the test environment database. This database uses data that is not based on personal information and maintains data similar to the production environment. The input is the generated data, and the output is the data imported into the test environment database.

[1100] Step 4:

[1101] The server uses the data imported into the test environment database to simulate business scenarios within the logistics center. For example, in the case of a "receiving" scenario, it checks whether the receiving process for goods is carried out correctly. The input is the data imported into the test environment database, and the output is the simulation results.

[1102] Step 5:

[1103] The server provides the simulation results to the user. The user checks the simulation results and evaluates whether they work in the same way as the actual business process. The input is the simulation results, and the output is feedback to the user.

[1104] In this way, it becomes possible to simulate business scenarios at logistics centers, thereby improving business efficiency and system reliability.

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

[1106] "Example 1"

[1107] In one embodiment of the present invention, the emotion engine recognizes the user's emotion and adjusts parameters for data generation based on the emotion. Specifically, when the user is feeling joy, the emotion engine adjusts parameters to generate data related to joy. This allows the test environment DB to simulate business scenarios related to joy.

[1108] "Example 2"

[1109] In another embodiment of the present invention, the emotion engine selects a specific work scenario based on the user's emotion. For example, when the user feels anxious, the emotion engine selects a work scenario related to anxiety. This allows the test environment DB to simulate a work scenario related to anxiety.

[1110] "Example 3"

[1111] Furthermore, in another embodiment of the present invention, the emotion engine recognizes the user's emotion, adjusts parameters for data generation based on the emotion, and selects a specific business scenario. For example, when the user is feeling angry, the emotion engine adjusts parameters to generate data related to anger and selects a business scenario related to anger. This allows the test environment DB to simulate a business scenario related to anger.

[1112] The processing flow of each embodiment will be described below.

[1113] "Example 1"

[1114] Step 1: The emotion engine recognizes the user's emotion.

[1115] Step 2: Adjust the parameters of data generation based on the emotions recognized by the emotion engine.

[1116] Step 3: The test environment DB generates data based on the adjusted parameters.

[1117] "Example 2"

[1118] Step 1: The emotion engine recognizes the user's emotion.

[1119] Step 2: Select a specific business scenario based on the emotions recognized by the emotion engine.

[1120] Step 3: Based on the selected business scenario, the test environment DB generates data.

[1121] "Example 3"

[1122] Step 1: The emotion engine recognizes the user's emotion.

[1123] Step 2: Adjust the parameters of data generation based on the emotions recognized by the emotion engine and select a specific business scenario.

[1124] Step 3: The test environment DB generates data based on the adjusted parameters and the selected business scenario.

[1125] Example 1

[1126] Next, a description will be given of Example 1 of Form 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."

[1127] With conventional test environment databases, it was difficult to automatically randomly generate data that did not actually exist but could be considered "realistic," and it was not possible to adjust data generation parameters based on user emotions. As a result, the test environment could not approximate a commercial environment, and business scenarios were not simulated properly. Furthermore, given the demand for data generation that was not based on personal information, an efficient data generation method was needed.

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

[1129] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment database, means for making the test environment database not based on personal information and as close to a commercial environment as possible, means for recognizing user emotions and adjusting parameters for data generation based on the emotions, means for importing the generated data into the test environment database, and means for the test environment database to simulate business scenarios using the provided data. This makes the test environment database closer to a commercial environment, makes it possible to generate data based on user emotions, and enables the simulation of more realistic business scenarios.

[1130] "Potentially real data that does not actually exist" is not real data, but is reliable data that is generated based on real business scenarios and situations.

[1131] "Random, automated generation methods" are techniques that use specific algorithms or programs to automatically generate data in an unpredictable manner.

[1132] A "test environment database" is a database used to test systems and applications, and is intended to simulate conditions close to the actual operating environment.

[1133] "Non-personal information" means that the data generated does not contain information that identifies a specific individual.

[1134] "Means to approximate a commercial environment" refers to techniques and methods for making the test environment database have the same conditions and data structure as an actual commercial operating environment.

[1135] "Means for recognizing user emotions" refers to technology for analyzing the user's emotional state and adjusting the system's behavior based on that.

[1136] "Means for adjusting data generation parameters" refers to technology for changing the characteristics and content of generated data based on the user's emotions and other conditions.

[1137] A "means for importing generated data" is a technique or method for incorporating externally generated data into the test environment database.

[1138] "Means for simulating business scenarios" refers to technology for reproducing actual business processes and scenarios based on a test environment database, and for conducting tests and evaluations.

[1139] This invention is a system that automatically randomly creates "possibly real" data that does not actually exist in a test environment database and provides the relevant data. A specific embodiment of this system will be described below.

[1140] System configuration

[1141] 1. User Emotion Recognition

[1142] A user inputs their emotions into the system using emotion recognition software. For example, if a user is excited about the release of a new product, the user communicates that emotion to the system through the emotion recognition software. The server analyzes the user's emotions using an emotion recognition API (e.g., a general emotion recognition API).

[1143] 2. Defining Data Generation Patterns

[1144] The server defines a data generation pattern based on the user's emotions. For example, if the user is feeling happy, the server defines a data pattern related to a new product release. This pattern includes items such as the product name, release date, and expected sales.

[1145] 3. Generating Random Data

[1146] The server generates random data according to a defined data pattern. For example, it uses Python's random module to generate random data such as product names, release dates, and sales figures. The generated data is saved in JSON or CSV format.

[1147] 4. Providing data to the test environment database

[1148] The server provides the generated data to the test environment database, for example by running an SQL script to import the generated data into a common database management system (DBMS), which adds the new data to the test environment database.

[1149] 5. Business scenario simulation

[1150] The test environment database uses the provided data to simulate business scenarios, such as sales forecasts and marketing strategies related to a new product release. The terminal displays the results of the simulation to the user.

[1151] Specific examples

[1152] For example, if a user is excited about a new product release, they communicate that emotion to the system through emotion recognition software. The server uses the emotion recognition API to analyze the user's emotion as "joy." Next, the server defines a "data pattern related to the new product release" and uses Python's random module to generate data like this:

[1153] Product Name: "ProductX"

[1154] Release Date: "2023-12-01"

[1155] Expected sales: "10000"

[1156] The server runs SQL scripts to import the generated data into popular database management systems, for example by executing SQL statements such as:

[1157] sql

[1158] INSERT INTO test_environment_db (product_name, release_date, expected_sales) VALUES ('ProductX', '2023-12-01', '10000');

[1159] The test environment database uses the imported data to simulate business scenarios related to new product releases. The terminal displays the simulation results to the user, such as sales forecast graphs and marketing strategy simulation results.

[1160] Prompt Sentence Examples

[1161] “If a user is excited about a new product release, how does the emotion engine adjust its parameters for data generation?”

[1162] Using this prompt, the generative AI model can provide detailed explanations of how the emotion engine works and the specific methods used to generate the data.

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

[1164] Step 1:

[1165] User emotion input

[1166] Using emotion recognition software, users input their emotions into the system. For example, if a user is excited about the release of a new product, they input that emotion. The input emotion data is then sent to the server.

[1167] Step 2:

[1168] Emotion Analysis

[1169] The server analyzes the received emotion data using an emotion recognition API. For example, it uses a general emotion recognition API to analyze the user's emotion as "joy." The analysis results are used to adjust the data generation parameters. The input is emotion data, and the output is analyzed emotion information.

[1170] Step 3:

[1171] Defining Data Generation Patterns

[1172] The server defines a data generation pattern based on the analyzed emotional information. For example, if the user is feeling happy, the server defines a "data pattern related to new product release." This pattern includes items such as the product name, release date, and expected sales. The input is the analyzed emotional information, and the output is the data generation pattern.

[1173] Step 4:

[1174] Random Data Generation

[1175] The server generates random data according to a defined data generation pattern. For example, it uses Python's random module to randomly generate data such as product names, release dates, and sales figures. The generated data is saved in JSON or CSV format. The input is the data generation pattern, and the output is the generated random data.

[1176] Step 5:

[1177] Importing Data

[1178] The server imports the generated data into the test environment database. For example, it executes an SQL script to import the generated data into a common database management system. This adds new data to the test environment database. The input is the generated random data, and the output is the data imported into the test environment database.

[1179] Step 6:

[1180] Business scenario simulation

[1181] The test environment database uses the provided data to simulate business scenarios. For example, data related to a new product release is used to simulate sales forecasts and marketing strategies. The terminal displays the simulation results to the user. The input is the data imported into the test environment database, and the output is the simulated results of the business scenario.

[1182] (Application example 1)

[1183] Next, a description will be given of Application Example 1 of Form 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."

[1184] Conventional test environment database systems have difficulty in automatically randomly generating data that does not actually exist but could be considered "realistic," and they are unable to adjust data generation parameters based on user emotions. As a result, the test environment cannot approximate a commercial environment, making it difficult to improve operational efficiency or meet specific business scenarios. Furthermore, it is also impossible to generate and display optimal advertisements based on user emotions.

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

[1186] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the corresponding data to a test environment DB, means for making the test environment DB not based on personal information and as close to a commercial environment as possible, means for recognizing user emotions and adjusting data generation parameters based on those emotions, and means for generating and displaying optimal advertisements based on the user emotions. This makes it possible to make the test environment closer to a commercial environment, improving business efficiency and satisfying specific business scenarios. It also makes it possible to generate and display optimal advertisements based on the user's emotions.

[1187] "Possible real data that does not actually exist" refers to data that does not exist in the real world but could actually occur.

[1188] "Random, automated generation means" refers to devices or programs that have the function of randomly generating data based on specific algorithms or rules.

[1189] "Test environment DB" refers to a database used for testing systems and applications.

[1190] "Means for providing the relevant data" refers to devices or programs that have the function of supplying the generated data to the test environment DB.

[1191] "Not based on personal information" means that the generated data does not contain information that identifies a specific individual.

[1192] "Means to approximate a commercial environment" refers to devices and programs that have the functionality to make the test environment as close as possible to the actual commercial environment.

[1193] "Means for recognizing user's emotions" refers to a device or program that has the function of detecting and identifying the user's emotional state.

[1194] "Means for adjusting data generation parameters" refers to a device or program that has the function of changing the settings and conditions for data generation based on the user's emotions.

[1195] "Means for generating and displaying optimal advertisements" refers to devices or programs that have the function of creating the most appropriate advertisements based on the user's emotions and displaying them to the user.

[1196] The following system configuration will be described as an embodiment of the present invention.

[1197] The server has a means to automatically generate random data that "could be real" but does not actually exist. This means is a device or program that has the function of generating random data based on specific algorithms or rules. For example, a Python program can be used to define a data pattern based on a business scenario and generate random data according to that pattern.

[1198] Next, the server has a means for providing the generated data to the test environment DB. This means is a device or program with the function of supplying the generated data to the test environment DB. The test environment DB is a database used for testing systems and applications, and by using data that is not based on personal information, it can be made closer to a commercial environment while ensuring privacy protection.

[1199] Furthermore, the server has a means for recognizing the user's emotions and adjusting the parameters of data generation based on those emotions. This means is a device or program with the function of detecting and identifying the user's emotional state. For example, if the user inputs the word "happy," the server sets the emotion to "joy" and adjusts the settings and conditions of data generation based on that emotion.

[1200] Finally, the server has a means for generating and displaying the most appropriate advertisement based on the user's emotions. This means is a device or program with the function of creating the most appropriate advertisement based on the user's emotions and displaying it to the user. For example, if the user inputs "I am feeling very happy today!", the emotion engine will recognize "joy" and display an advertisement related to joy.

[1201] For illustrative purposes, consider the following prompt:

[1202] "Design a system that recognizes a user's emotions and generates and displays the most appropriate ads based on those emotions. For example, if a user types 'happy', display ads related to joy."

[1203] In this way, the test environment can be made closer to the commercial environment, improving operational efficiency and meeting specific business scenarios, and generating and displaying optimal ads based on user emotions.

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

[1205] Step 1:

[1206] The server receives input from the user.

[1207] Input: Text that describes the user's feelings (e.g., "I am feeling very happy today!")

[1208] Specific operation: The server receives text data entered by the user.

[1209] Step 2:

[1210] The server uses an emotion engine to recognize the user's emotion.

[1211] Input: Text indicating the user's sentiment

[1212] Data processing: Perform text analysis to identify emotions (e.g., detect the word "happy")

[1213] Output: Recognized emotion (e.g. "joy")

[1214] Specific operation: The server uses a text analysis algorithm to extract sentiment from the user's input text.

[1215] Step 3:

[1216] The server uses a data generation module to adjust parameters of the data generation based on the recognized emotion.

[1217] Input: A recognized emotion (e.g., "joy")

[1218] Data calculation: Select a data generation pattern corresponding to the emotion and set the parameters

[1219] Output: Adjusted data generation parameters

[1220] Specific operation: The server selects a data generation pattern corresponding to the emotion and sets the data generation based on that pattern.

[1221] Step 4:

[1222] The server uses a data generation module to generate random data based on the adjusted parameters.

[1223] Input: Adjusted data generation parameters

[1224] Data manipulation: Generate random data based on parameters

[1225] Output: The generated data

[1226] Specific operation: The server generates random data based on a business scenario according to the set parameters.

[1227] Step 5:

[1228] The server provides the generated data to the test environment DB.

[1229] Input: Generated data

[1230] Data processing: Insert the generated data into the test environment DB

[1231] Output: Data saved in the test environment DB

[1232] Specific operation: The server inserts the generated data into the test environment DB and saves it.

[1233] Step 6:

[1234] The server generates and displays the most appropriate advertisement based on the user's emotions.

[1235] Input: A recognized emotion (e.g., "joy")

[1236] Data Computing: Selecting and generating emotionally relevant ads

[1237] Output: The generated ad

[1238] Specific operation: The server selects an advertisement corresponding to the emotion and generates advertisement data to be displayed to the user.

[1239] In this way, the server can adjust the parameters of data generation based on the user's emotions and generate and display the most appropriate advertisements.

[1240] Example 2

[1241] Next, a description will be given of Example 2 of Form 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."

[1242] There is a demand for building a test environment that is close to a commercial environment without using real-world data. However, it is difficult to automatically create data that is appropriate for business scenarios while generating data that does not contain personal information. Furthermore, there is no system that can select appropriate business scenarios based on user emotions and generate corresponding data. This makes it difficult to build a test environment and hinders business efficiency.

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

[1244] In this invention, the server includes means for automatically randomly generating "possibly real" data that does not actually exist, means for providing the corresponding data to a test environment database, means for making the test environment database not based on personal information and as close to a commercial environment as possible, means for analyzing user emotions, means for selecting specific business scenarios based on the analyzed emotions, means for inputting prompt sentences to a generative AI model based on the selected business scenarios, means for the generative AI model to generate data based on the prompt sentences, and means for saving the generated data in the test environment database. This makes it possible to build a test environment that is similar to a commercial environment and does not contain personal information, and to automatically generate data corresponding to appropriate business scenarios based on user emotions.

[1245] "Potentially real data that does not actually exist" is fictitious data that is generated in a format that mimics real data and can be applied to real business scenarios.

[1246] "Test environment database" means a database used for system testing and simulation, which stores data that does not contain personal information.

[1247] "Non-personally identifiable" means that the data does not contain any personally identifiable information.

[1248] "Bringing it closer to a commercial environment" means creating a test environment by generating data in a format as close as possible to the data formats and business scenarios used in actual commercial systems.

[1249] "Analyzing user sentiment" is the process of reading and identifying sentiment from text and other data entered by a user.

[1250] "Selecting a specific business scenario" means selecting an appropriate business scenario based on the analyzed sentiment.

[1251] A "generative AI model" is a model for generating data using artificial intelligence, such as a model that uses natural language processing technology.

[1252] A "prompt sentence" is an input sentence that gives instructions to the generative AI model to generate data.

[1253] "Generating data" means that the generative AI model creates new data based on the prompt.

[1254] "Saving the data" means storing the generated data in the test environment database.

[1255] This invention is a system that automatically generates data that does not contain personal information based on a business scenario in the financial industry and stores the data in a test environment database. A specific embodiment of this system will be described below.

[1256] First, a user accesses the system using a web browser or dedicated application. The user logs in to the system and enters a request to generate data related to a specific business scenario. For example, the user might enter, "I'm worried about recent market trends."

[1257] The server receives input from the user and analyzes the user's emotions using an emotion engine. This emotion engine uses, for example, an emotion analysis API that uses natural language processing technology. As a result of the analysis, it is detected that the user is feeling "anxiety."

[1258] Next, the server selects an appropriate task scenario based on the analyzed emotion. For example, it selects a task scenario related to "anxiety." Based on this task scenario, the server creates a prompt sentence to be input to the generative AI model. Examples of prompt sentences include:

[1259] Please generate transaction information related to your concerns, including transaction ID, transaction date and time, transaction amount, and transaction details.

[1260] The server sends this prompt to a generative AI model. The generative AI model uses a model that uses natural language processing technology (e.g., GPT-3). Based on the prompt, the generative AI model generates data in the same format as the actual data. An example of generated data is transaction information such as the following:

[1261] Transaction ID: 123456

[1262] Transaction Date: 2023-10-01 10:00:00

[1263] Transaction amount: 100,000 yen

[1264] Transaction: Purchase of shares

[1265] The generated data is stored in a test environment database by the server. This allows the test environment database to contain data similar to that of a commercial environment without including personal information. This data can be used to test and simulate the system.

[1266] This system automatically generates data corresponding to appropriate business scenarios based on user emotions and stores it in a test environment database, allowing for the creation of a test environment similar to a commercial environment that does not contain personal information, thereby improving work efficiency.

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

[1268] Step 1:

[1269] A user accesses the system and logs in.

[1270] Specifically, the user accesses the system's login screen using a web browser or a dedicated application, and logs in by entering authentication information.

[1271] Input: User authentication information (user ID, password)

[1272] Output: Login success or failure message

[1273] Step 2:

[1274] A user enters a request related to a particular business scenario.

[1275] Specifically, the user inputs text such as "I'm worried about recent market trends" through the system interface.

[1276] Input: User request text

[1277] Output: The user's request text is sent to the server

[1278] Step 3:

[1279] The server analyzes the user's emotions.

[1280] Specifically, the server sends the request text received from the user to a sentiment analysis API and analyzes the sentiment. For example, it uses a sentiment analysis API that uses natural language processing technology.

[1281] Input: User request text

[1282] Output: Parsed emotion (e.g. "anxiety")

[1283] Step 4:

[1284] The server selects a particular business scenario based on the analyzed emotions.

[1285] Specifically, the server selects an appropriate business scenario based on the emotion analysis results. For example, it selects a business scenario related to "anxiety."

[1286] Input: Parsed sentiment

[1287] Output: Selected business scenario

[1288] Step 5:

[1289] The server creates a prompt to input to the generative AI model.

[1290] Specifically, the server creates a prompt to be input to the generative AI model based on the selected business scenario, such as "Please generate transaction information related to anxiety, including transaction ID, transaction date and time, transaction amount, transaction content, etc."

[1291] Input: Selected business scenario

[1292] Output: Generated prompt statement

[1293] Step 6:

[1294] The server sends a prompt to the generative AI model.

[1295] Specifically, the server sends the generated prompt to a generative AI model, which uses natural language processing technology (e.g., GPT-3).

[1296] Input: Generated prompt text

[1297] Output: The prompt sent to the generative AI model

[1298] Step 7:

[1299] A generative AI model generates data based on the prompt.

[1300] Specifically, the generative AI model generates data in the same format as the actual data based on the prompt, such as generating transaction information.

[1301] Input: prompt statement

[1302] Output: Generated data (e.g., transaction information)

[1303] Step 8:

[1304] The server stores the generated data in the test environment database.

[1305] Specifically, the server stores the data received from the generative AI model in a test environment database, which does not contain personal information but has data similar to that of a commercial environment.

[1306] Input: Generated data

[1307] Output: Data stored in the test environment database

[1308] (Application example 2)

[1309] Next, a description will be given of Application Example 2 of Form 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."

[1310] It is difficult to create a test environment that closely resembles a commercial environment without using real-world data. It is also difficult to select appropriate business scenarios based on user emotions, evaluate security risks, and propose appropriate countermeasures. This can reduce the accuracy and practicality of the test environment, potentially resulting in insufficient security risk assessment and countermeasures.

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

[1312] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment database, means for making the test environment database not based on personal information and as close to a commercial environment as possible, means for recognizing user emotions, means for selecting specific business scenarios based on the recognized emotions, means for evaluating security risks based on the selected business scenarios, and means for proposing appropriate countermeasures based on the evaluated security risks. This makes it possible to build a test environment that is close to a commercial environment without using real data, select appropriate business scenarios based on user emotions, evaluate security risks, and propose appropriate countermeasures.

[1313] "Possible real data" is data that does not actually exist but has the same format and content as real data.

[1314] A "test environment database" is a database used to create a test environment that is close to a commercial environment.

[1315] "Not based on personal information" means not including any information that can identify an individual.

[1316] "Means to approximate a commercial environment" refers to means to reproduce conditions and data similar to those in an actual commercial environment.

[1317] The "means for recognizing a user's emotion" is a means for detecting and identifying the user's emotional state.

[1318] The "means for selecting a specific business scenario" is a means for selecting an appropriate business scenario based on the user's feelings.

[1319] The "means for assessing security risks" is a means for assessing security risks based on a selected business scenario.

[1320] The "means for proposing appropriate measures" is a means for proposing appropriate measures to a user based on the assessed security risk.

[1321] A system for implementing this invention is configured as follows: A server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment database, means for making the test environment database not based on personal information and as close to a commercial environment as possible, means for recognizing a user's emotions, means for selecting a specific business scenario based on the recognized emotions, means for evaluating security risks based on the selected business scenario, and means for proposing appropriate countermeasures based on the evaluated security risks.

[1322] Explanation of program processing

[1323] The server uses a Python program to automatically generate potentially real data that does not actually exist. Specifically, it randomly generates data such as customer information, account information, and transaction information, and provides it to the test environment database. This data is not based on personal information and is in a format similar to that used in a commercial environment.

[1324] To recognize user emotions, we use the EmotionRecognizer library. When a user uses a smartphone, emotional data is collected through the camera and microphone, and the emotion is identified. Based on the recognized emotion, we select a specific business scenario using the SecurityScenarios library.

[1325] Evaluate security risks based on selected business scenarios. Based on the assessed security risks, suggest appropriate measures to users. For example, if there is an increased risk of phishing scams or unauthorized access, recommend setting up two-factor authentication and changing passwords.

[1326] Specific examples

[1327] For example, if a user is feeling anxious, the EmotionRecognizer library detects this from the user's facial expressions and tone of voice. Next, the SecurityScenarios library selects business scenarios related to anxiety and evaluates them as increasing the risk of phishing scams and unauthorized access. Finally, the server suggests the user set up two-factor authentication and change their password.

[1328] Prompt Sentence Examples

[1329] If users are unsure, what are the potential security risks?

[1330] In this way, the server can select an appropriate business scenario based on the user's emotions, evaluate security risks, and propose appropriate countermeasures.

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

[1332] Step 1:

[1333] The server automatically and randomly creates "possibly real" data that does not actually exist. Specifically, it generates data such as customer information, account information, and transaction information. Templates and rules for data generation are required as input, and the generated data is obtained as output. This data is not based on personal information and is in a format similar to that used in a commercial environment.

[1334] Step 2:

[1335] The server provides the generated data to the test environment database. The data generated in step 1 is required as input, and the data stored in the test environment database is obtained as output. This data is used to execute business scenarios in the test environment.

[1336] Step 3:

[1337] The device uses the EmotionRecognizer library to recognize the user's emotions. The input is the user's facial expression and voice data, and the output is the recognized emotion. Specifically, it collects emotion data through the camera and microphone and identifies the emotion.

[1338] Step 4:

[1339] The server selects a specific business scenario based on the recognized emotion. The input is the emotion recognized in step 3, and the output is the selected business scenario. Specifically, it uses the SecurityScenarios library to select a business scenario corresponding to the emotion.

[1340] Step 5:

[1341] The server evaluates the security risk based on the selected business scenario. The business scenario selected in step 4 is required as input, and the evaluated security risk is obtained as output. Specifically, the server analyzes the risk factors related to the business scenario and evaluates the risk level.

[1342] Step 6:

[1343] The server proposes appropriate countermeasures based on the assessed security risk. The input is the security risk assessed in step 5, and the output is the proposed countermeasures. Specifically, the server selects a countermeasure according to the risk level and notifies the user.

[1344] Step 7:

[1345] The user checks the measures proposed by the server and implements them as necessary. The input is the measures proposed in step 6, and the output is the results of the implemented measures. Specific actions include implementing security measures such as setting up two-factor authentication and changing passwords.

[1346] Example 3

[1347] Next, a description will be given of Example 3 of Form Example 3. 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."

[1348] Conventional test environment databases have difficulty in fully simulating actual business scenarios, making it difficult to generate data that contributes to improving business efficiency. Furthermore, because data generation is not based on user emotions, it is not possible to simulate business scenarios related to specific emotions. This reduces the accuracy and practicality of the test environment, hindering business efficiency.

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

[1350] In this invention, the server includes a means for automatically and randomly generating "possibly real" data that does not actually exist, a means for providing the corresponding data to a test environment database, a means for ensuring that the test environment database is not based on personal information and is as close to a commercial environment as possible, a means for generating data that satisfies a specific business scenario using a generative AI model, and a means for recognizing user emotions and adjusting data generation parameters based on those emotions. This allows the test environment database to accurately simulate actual business scenarios, enabling data generation that contributes to business efficiency. Furthermore, because data is generated based on user emotions, it is possible to simulate business scenarios related to specific emotions.

[1351] "Potentially real data that does not actually exist" is fictitious data that is generated based on a real business scenario but does not actually exist.

[1352] A "test environment database" is a database used to simulate actual business scenarios and operates under conditions close to a commercial environment.

[1353] A "generative AI model" is a model that uses artificial intelligence technology to generate data that satisfies specific business scenarios.

[1354] A "prompt" is a textual instruction entered into a generative AI model that specifies the content and format of the data to be generated.

[1355] "User emotion" refers to the emotional state that the user is feeling, and includes emotions such as joy, anger, and sadness.

[1356] "Data generation parameters" refer to the settings and conditions used by a generative AI model when generating data, which determine the content and format of the generated data.

[1357] A "business scenario" is a scenario for simulating a specific business process or situation, and includes specific business situations such as the success or failure of a transaction.

[1358] This invention is a system that automatically and randomly generates non-existent "possibly real" data and provides it to a test environment database. The system uses a generative AI model to generate data that satisfies specific business scenarios, and includes a function that recognizes user emotions and adjusts the parameters of data generation.

[1359] Hardware and software used

[1360] server

[1361] The server provides the computational resources to run the generative AI model. Specifically, it uses the following software and hardware:

[1362] Generative AI model: OpenAI GPT-4

[1363] Database: MySQL or PostgreSQL

[1364] Emotion Engine: Microsoft Azure Cognitive Services

[1365] Terminal

[1366] The terminal provides an interface for users to input prompt sentences and access the emotion engine. The terminal has the following functions:

[1367] Input field: A text box where the user can enter a prompt statement.

[1368] Camera and microphone: Input devices for recognizing user emotions

[1369] User

[1370] The user operates the system, inputs a prompt sentence, and uses the emotion engine to recognize emotions. The system operates as follows according to the user's operation.

[1371] Data processing and calculation

[1372] 1. Enter the prompt:

[1373] The user inputs a prompt statement into an input field on the terminal, for example, "Please generate data for a scenario in which the transaction is successful."

[1374] 2. Send the prompt:

[1375] The terminal sends the entered prompt to the server, using HTTP or HTTPS as the communication protocol.

[1376] 3. Data generation:

[1377] The server inputs the received prompt sentences into a generative AI model (e.g., OpenAI GPT-4) to generate data that satisfies a specific business scenario, such as generating data for a scenario in which a transaction is successful.

[1378] 4. Data storage:

[1379] The server stores the generated data in a test environment database, such as MySQL or PostgreSQL.

[1380] 5. Emotion Recognition:

[1381] Users can access the emotion engine through their devices and have it recognize their own emotions. The emotion engine uses Microsoft Azure Cognitive Services.

[1382] 6. Adjust parameters:

[1383] The server adjusts the parameters for data generation based on the emotion data obtained from the emotion engine. For example, if the user is feeling angry, the parameters are set to generate data related to anger.

[1384] 7. Select a business scenario:

[1385] The server selects a particular business scenario based on the adjusted parameters, for example, a business scenario related to anger.

[1386] 8. Application of Data:

[1387] The server applies the data generated based on the selected business scenario to the test environment database, allowing the test environment database to simulate specific emotions and business scenarios.

[1388] Specific examples

[1389] Prompt Sentence Examples

[1390] "Generate data for scenarios where the trade is successful."

[1391] "Generate data for scenarios where a transaction fails."

[1392] "Generate a business scenario where a user feels angry."

[1393] In this way, the system generates data based on the user's input and emotions, and improves the efficiency of business processing in the test environment database. The flow of the identification processing in the third embodiment will be described with reference to FIG.

[1394] Step 1:

[1395] The user enters a prompt statement.

[1396] The user inputs a prompt into an input field on the terminal, for example, "Please generate data for a scenario in which the transaction is successful." The input prompt is temporarily stored in the terminal's memory.

[1397] Step 2:

[1398] The terminal sends the prompt to the server.

[1399] The terminal sends the entered prompt text to the server as an HTTP POST request, and the sent prompt text is stored in the server's receive buffer.

[1400] Step 3:

[1401] The server generates the data using the generative AI model.

[1402] The server inputs the received prompt sentences into a generative AI model (e.g., OpenAI GPT-4) to generate data that satisfies a specific business scenario. For example, it generates data for a scenario in which a transaction is successful. The generated data is temporarily stored in the server's memory.

[1403] Step 4:

[1404] The server stores the generated data in the test environment database.

[1405] The server saves the generated data in the test environment database using the INSERT statement. The database can be MySQL, PostgreSQL, etc. The saved data is stored in the test environment database.

[1406] Step 5:

[1407] The user uses the emotion engine to recognize emotions.

[1408] Users access the emotion engine through their device and have it recognize their own emotions. The emotion engine uses Microsoft Azure Cognitive Services. The recognized emotion data is temporarily stored in the device's memory.

[1409] Step 6:

[1410] The device transmits the emotion data to the server.

[1411] The device sends the recognized emotion data to the server as an HTTP POST request, which is then stored in the server's receive buffer.

[1412] Step 7:

[1413] The server adjusts the parameters of data generation based on the emotion.

[1414] The server adjusts the parameters for data generation based on the emotion data obtained from the emotion engine. For example, if the user is feeling angry, the parameters are set to generate data related to anger. The adjusted parameters are temporarily stored in the server's memory.

[1415] Step 8:

[1416] The server selects a particular business scenario.

[1417] The server selects a particular business scenario based on the adjusted parameters, for example, a business scenario related to anger, and the selected business scenario is temporarily stored in the server's memory.

[1418] Step 9:

[1419] The server applies the generated data to the test environment database.

[1420] The server applies the data generated based on the selected business scenario to the test environment database, allowing the test environment database to simulate specific emotions and business scenarios. The applied data is stored in the test environment database.

[1421] (Application example 3)

[1422] Next, a description will be given of Application Example 3 of Form Example 3. 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."

[1423] In conventional test environments, it is difficult to generate data to simulate actual business scenarios, and there is a particular problem in that it is not possible to select or adjust scenarios based on user emotions. Furthermore, when issuing security alerts, flexible responses that take user emotions into consideration are required, but current systems are unable to achieve this. This has hindered the realism of the test environment and improvements in business efficiency.

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

[1425] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment DB, means for making the test environment DB not based on personal information and as close to a commercial environment as possible, means for recognizing a user's emotion, means for adjusting parameters for data generation based on the recognized emotion, means for selecting a specific business scenario based on the adjusted parameters, and means for issuing a security alert based on the selected business scenario. This enables data generation and scenario selection according to the user's emotion, improving the realism of the test environment and improving business efficiency.

[1426] "Potentially real data that does not actually exist" is data that is randomly generated to simulate real-world business scenarios, but is not based on actual personal or commercial data.

[1427] The "test environment DB" is a database for simulating actual business scenarios using the generated data.

[1428] "Non-personal information" means that the data generated does not contain information about actual individuals and is in a privacy-preserving format.

[1429] "Approaching a commercial environment" means that the data and scenarios generated are in a format that is as close as possible to situations that may occur in a real commercial environment.

[1430] "Means for recognizing a user's emotions" refers to technology that analyzes a user's facial expressions, voice, and other biometric information to identify their emotional state.

[1431] The "means for adjusting data generation parameters" is a technique for changing the conditions and settings for data generation based on the recognized user emotions.

[1432] The "means for selecting a particular business scenario" is a technique for selecting an appropriate business scenario based on the adjusted parameters.

[1433] The "means for issuing security alerts" is a technique for notifying the user of appropriate security alerts based on the selected business scenario.

[1434] A system for implementing this invention is configured as follows: A server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment DB, means for making the test environment DB not based on personal information and as close as possible to a commercial environment, means for recognizing a user's emotions, means for adjusting parameters for data generation based on the recognized emotions, means for selecting a specific business scenario based on the adjusted parameters, and means for issuing a security alert based on the selected business scenario.

[1435] Hardware and software used

[1436] Hardware: Smartphone (camera, microphone, sensors)

[1437] Software: emotion_recognition library, data_generator library, security_scenarios library

[1438] Data processing and calculation

[1439] 1. Emotion Recognition: Capture the user's facial expressions and voice using the smartphone's camera and microphone, and use the emotion_recognition library to recognize emotions. For example, if the user is feeling angry, detect anger from their facial expressions and tone of voice.

[1440] 2. Parameter adjustment: Based on the recognized emotion, we use the data_generator library to change the conditions and settings for data generation. For example, if the user is feeling angry, we set parameters for generating data related to anger.

[1441] 3. Data generation: Using the tuned parameters, data is generated to meet a specific business scenario, for example, to simulate anger-related security risks.

[1442] 4. Scenario selection: Based on the generated data, select the appropriate business scenario using the security_scenarios library, for example, select the anger-related security risk scenario.

[1443] 5. Alerting: Based on the selected scenario, the system notifies the user with appropriate security alerts, for example, informing the user of countermeasures in the event of an anger-related security risk.

[1444] Specific examples

[1445] For example, if a user feels angry, the system will simulate security risks associated with anger (e.g., unauthorized access or data leakage) and issue appropriate alerts, allowing users to receive flexible security responses according to their emotions.

[1446] Prompt Sentence Examples

[1447] If a user is feeling angry, design a system that simulates the security risks associated with anger and issues appropriate alerts.

[1448] In this way, the emotion-based security alert system realizes flexible security responses according to the user's emotions.

[1449] The flow of the specific processing in Application Example 3 will be described with reference to FIG.

[1450] Step 1:

[1451] The server captures the user's facial expressions and voice using the smartphone's camera and microphone. As input, it receives the user's real-time video and audio data. As output, it passes these data to the emotion_recognition library.

[1452] Step 2:

[1453] The server uses the emotion_recognition library to recognize the user's emotions from the captured video and audio data. As input, it uses the video and audio data acquired in step 1. As output, it obtains the recognized emotion data (e.g., anger, joy, sadness, etc.).

[1454] Step 3:

[1455] The server adjusts the data generation parameters using the data_generator library based on the recognized emotion data. As input, it uses the emotion data obtained in step 2. As output, it obtains the adjusted data generation parameters.

[1456] Step 4:

[1457] The server uses the adjusted parameters to generate data that satisfies a specific business scenario using the data_generator library. As input, it uses the data generation parameters obtained in step 3. As output, it obtains the generated business scenario data.

[1458] Step 5:

[1459] The server selects an appropriate business scenario using the security_scenarios library based on the generated business scenario data. As input, it uses the business scenario data obtained in step 4. As output, it obtains the selected business scenario.

[1460] Step 6:

[1461] The server notifies the user of an appropriate security alert based on the selected business scenario. As input, it uses the business scenario obtained in step 5. As output, it issues a security alert to the user's smartphone.

[1462] In this way, the server can generate data and select scenarios according to the user's emotions and issue appropriate security alerts.

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

[1464] 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> ) 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 a voice, text data indicating a text, and image data indicating an image are also input.

[1465] The data generation model 58 performs inference on the input inference data according to the instructions given by the prompts, and outputs the inference results in the form of data such as voice data and text data. Here, inference refers to, for example, analysis, classification, prediction, and / or summarization.

[1466] Another example of generative AI is Gemini (internet search engine). <url: https: gemini.google.com ?hl="ja">) are listed.

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

[1468] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

[1480] Next, the specific processing by the specific processing unit 290 of the data processing device 12 will be described.

[1481] "Example 1"

[1482] The present invention is a system that automatically generates random, potentially real data that does not actually exist and provides that data to a test environment database. Specifically, a data generation module defines a data pattern based on a business scenario and generates random data according to that pattern. The generated data is provided to the test environment database, which then uses the data to simulate business processes.

[1483] "Example 2"

[1484] As a concrete example, consider a business scenario in the financial industry. Data such as customer information, account information, and transaction information is required, but because this data may contain personal information, it is not possible to use actual data. Therefore, the system of the present invention is used to automatically generate this data. The generated data has the same format as the actual data and can be used to execute the same business processes.

[1485] "Example 3"

[1486] Furthermore, the generated data is created to satisfy specific business scenarios. For example, it is possible to generate data that satisfies various scenarios, such as a scenario in which a certain transaction succeeds or a scenario in which a certain transaction fails. This allows the test environment DB to operate in the same way as actual business processing, contributing to business efficiency.

[1487] The processing flow of each embodiment will be described below.

[1488] "Example 1"

[1489] Step 1: The data generation module defines data patterns based on business scenarios.

[1490] Step 2: The data generation module generates random data according to the defined pattern.

[1491] Step 3: The generated data is provided to the test environment DB.

[1492] Step 4: The test environment DB simulates business processing using the provided data.

[1493] "Example 2"

[1494] Step 1: Consider a business scenario in the financial industry and create data such as customer information, account information, and transaction information.

[1495] Define the data pattern.

[1496] Step 2: Based on the defined data patterns, the system of the present invention is used to automatically generate these data.

[1497] Step 3: The generated data has the same format as the actual data and can be used to perform the same business processes.

[1498] "Example 3"

[1499] Step 1: Define specific business scenarios (e.g., scenarios in which a transaction succeeds, scenarios in which a transaction fails).

[1500] Step 2: Generate data that satisfies the defined business scenario.

[1501] Step 3: The generated data is provided to the test environment DB, which uses the data to simulate business processes.

[1502] Example 1

[1503] Next, a description will be given of Example 1 of Form 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."

[1504] By randomly and automatically generating data that does not exist in reality but could be real, and providing it to a test environment database, it is necessary to create a test environment that is close to a commercial environment while using data that is not based on personal information.It is also important that the generated data contributes to business efficiency and satisfies specific business scenarios.

[1505] The identification process by the identification processing unit 290 of the data processing device 12 in the first embodiment is realized by the following means. In this invention, the server includes a means for defining a data pattern based on a business scenario, a means for generating random data according to the defined data pattern, and a means for providing the generated data to the test environment database. This makes it possible to build a test environment that is not based on personal information but is close to a commercial environment, generate data that contributes to business efficiency, and provide data that satisfies a specific business scenario.

[1506] A "business scenario" is a plan or scenario that indicates a specific business process or operation procedure, and serves as a basis for data generation.

[1507] A "data pattern" defines the format and structure of the data to be generated, and includes the data type and generation method of each field.

[1508] "Random data" is data that is generated without following any particular rules or patterns and has unpredictable values.

[1509] A "test environment database" is a database used to test and verify a system, which differs from the actual operating environment but has a configuration similar to that of a commercial environment.

[1510] "Business process simulation" refers to simulating actual business processes using data provided in the test environment database, and is used to check system operation and perform performance tests.

[1511] This invention is a system that automatically randomly creates data that does not actually exist but that "might be real" for a test environment database and provides the relevant data. A specific embodiment of this system will be described below.

[1512] System configuration

[1513] Hardware and Software Use

[1514] The server uses programming languages ​​such as Python and Java to run the data generation module, data processing libraries such as NumPy and Pandas for data processing, and database management systems such as MySQL and PostgreSQL for the test environment database.

[1515] Program processing

[1516] Entering business scenarios

[1517] Users enter business scenarios through a web interface, with input forms containing fields such as customer ID, customer name, address, and phone number.

[1518] Data Pattern Definition

[1519] The server defines a data pattern based on the business scenario entered by the user, including the data type and generation method for each field, for example, customer ID is an integer, customer name is a string, address is a string, and phone number is a number.

[1520] Random Data Generation

[1521] The server generates random data according to a defined data pattern, using libraries such as NumPy or Pandas. For example, it uses NumPy's numpy.random module to generate random integers and strings.

[1522] Providing data to the test environment DB

[1523] The server provides the generated data to the test environment database. The generated data is inserted into the test environment database using the Python sqlalchemy library. For example, the data is inserted using the sqlalchemy insert method.

[1524] Business process simulation

[1525] The test environment database uses the provided data to simulate business processes, allowing system operation and performance testing to be performed. For example, operations such as searching and updating customer information are performed.

[1526] Specific examples

[1527] Suppose a user wants to test a new customer management system. In this case, the user enters the following business scenario:

[1528] Customer ID: Random integer

[1529] Customer Name: Random string

[1530] Address: Random string

[1531] Phone Number: Random numbers

[1532] The server generates 1,000 customer data items according to these patterns and provides them to the test environment database, which uses this data to simulate the operation of the customer management system.

[1533] Example prompt sentence:

[1534] "Generate test data for the customer management system. Create 1,000 records with random integers for customer IDs, random strings for customer names, random strings for addresses, and random numbers for phone numbers, and provide them to the test environment database."

[1535] The above is a specific embodiment for carrying out the present invention.

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

[1537] Step 1: Enter the business scenario

[1538] A user inputs a business scenario through a web interface. The input form contains fields such as customer ID, customer name, address, and phone number. As input, the user specifies specific data patterns for these fields. As output, the server receives these input data and stores them for use in the next step.

[1539] Specific behavior:

[1540] A user accesses a web form using a browser and enters a data pattern into each field: for example, an "integer" for a customer ID, a "string" for a customer name, a "string" for an address, and a "number" for a phone number.

[1541] Step 2: Define the data pattern

[1542] The server defines a data pattern based on the business scenario entered by the user. As input, it receives a data pattern specified by the user and generates as output a data pattern including the data type and generation method of each field.

[1543] Specific behavior:

[1544] The server uses a Python dictionary data structure to define the data pattern for each field: for example, customer ID is an integer, customer name is a string, address is a string, and phone number is a number.

[1545] Step 3: Generate random data

[1546] The server generates random data according to a defined data pattern, taking the data pattern as input and obtaining the randomly generated data as output.

[1547] Specific behavior:

[1548] The server uses NumPy's numpy.random module to generate random integers and strings, for example, numpy.random.randint(1000, 9999) to generate a random customer ID, and numpy.random.choice to generate a random string.

[1549] Step 4: Provide data to the test environment database

[1550] The server provides the generated data to the test environment database, taking as input randomly generated data and as output inserting data into the test environment database.

[1551] Specific behavior:

[1552] The server uses the Python sqlalchemy library to insert the generated data into the test environment database, for example by using the sqlalchemy insert method.

[1553] Step 5: Simulating business processes

[1554] The test environment database uses the provided data to simulate business processes, receiving as input the data inserted into the test environment database and obtaining as output the results of the business processes.

[1555] Specific behavior:

[1556] The test environment database executes queries based on the provided data and simulates business processes, such as searching and updating customer information, allowing for system operation confirmation and performance testing.

[1557] (Application example 1)

[1558] Next, a description will be given of Application Example 1 of Form 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."

[1559] In a test environment for autonomous vehicles, it is necessary to randomly generate realistic traffic data and provide it to a test environment database. However, collecting real traffic data is costly and time-consuming, and personal information must be protected, making it difficult to build a test environment efficiently and safely.

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

[1561] In this invention, the server includes a means for automatically and randomly creating potentially real data that does not actually exist, a means for providing the relevant data to the test environment DB, a means for making the test environment DB not based on personal information and as close to a commercial environment as possible, a means for defining traffic data patterns and generating random traffic data according to the patterns, and a means for providing the generated traffic data to the test environment DB. This makes it possible to efficiently and safely generate potentially real traffic data and provide it to the test environment.

[1562] "Possible real data" refers to data that does not actually exist but could occur in a real situation.

[1563] "Random automatic generation means" refers to a device or program that has the function of randomly generating data based on specific algorithms or rules.

[1564] A "test environment DB" is a database used to verify the operation of systems and applications.

[1565] "Non-personal information" means that the data generated does not contain information that identifies a specific individual.

[1566] "Means to approximate a commercial environment" refers to methods and techniques for making the test environment as close as possible to the actual commercial operating environment.

[1567] "Traffic data pattern" refers to a particular format or structure of data relating to traffic conditions and vehicle movements.

[1568] "Means for generating random traffic data" refers to a device or program that has the function of randomly generating traffic data based on traffic data patterns.

[1569] "Means for providing the generated traffic data to the test environment DB" refers to methods or techniques for inputting or storing the generated traffic data in the test environment database.

[1570] The system for carrying out the present invention operates in cooperation with three entities: a server, a terminal, and a user. A specific embodiment of the system will be described below.

[1571] Server Roles

[1572] The server has a means to automatically and randomly create "possibly real" data that does not actually exist. Specifically, the server defines traffic data patterns and generates random traffic data according to those patterns. The generated data is provided to the test environment DB. The server is implemented using a programming language such as Python, and a program containing a data generation algorithm runs on it.

[1573] Device Role

[1574] The terminal receives data provided by the server and saves it in the test environment DB. The terminal manages the data using a database management system (DBMS) and simulates business processing in the test environment. Specifically, the terminal saves data using the MockDatabase class and displays the inserted data.

[1575] User Roles

[1576] Users use the generated data to test autonomous vehicles. Users conduct simulations and tests based on the data stored in the test environment DB. This allows them to simulate realistic traffic situations and evaluate the performance and safety of autonomous vehicles.

[1577] Hardware and software used

[1578] Server: The computer system on which the Python program runs.

[1579] Terminal: A computer system equipped with a database management system (DBMS).

[1580] User: A computer system that can access the test environment database

[1581] Data processing and calculation

[1582] The server generates random traffic data based on traffic data patterns. Specifically, it randomly generates vehicle IDs, speeds, location information (latitude and longitude), and timestamps. The generated data is sent to the terminal and stored in the test environment database. The user uses this data to perform simulations.

[1583] Specific examples

[1584] For example, to generate data based on an urban traffic scenario, you might use a prompt like this:

[1585] Generate random traffic data based on an urban traffic scenario, including vehicle ID, speed, location (latitude and longitude), and timestamp.

[1586] Using this prompt, the generative AI model can generate data suitable for urban traffic scenarios, which is then stored in the test environment database and used for testing autonomous vehicles.

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

[1588] Step 1:

[1589] The server defines the traffic data pattern. Specifically, it sets data items such as vehicle ID, speed, location information (latitude and longitude), and timestamp. This determines the format of the generated data. The input is the traffic data pattern definition, and the output is the defined data pattern.

[1590] Step 2:

[1591] The server generates random traffic data based on a defined traffic data pattern. Specifically, it randomly generates a vehicle ID, randomly sets the speed in the range of 0 to 120, randomly determines location information (latitude and longitude), and randomly generates a timestamp. The input is the defined data pattern, and the output is the generated random traffic data.

[1592] Step 3:

[1593] The server transmits the generated traffic data to the terminal. Specifically, it converts the generated data into a data format such as JSON and transmits it to the terminal via the network. The input is the generated traffic data, and the output is the data transmitted to the terminal.

[1594] Step 4:

[1595] The terminal stores the traffic data received from the server in the test environment DB. Specifically, the received data is inserted into the database management system (DBMS) and saved. The input is the data received from the server, and the output is the data saved in the test environment DB.

[1596] Step 5:

[1597] Users use the data stored in the test environment DB to test autonomous vehicles. Specifically, they perform simulations based on the stored data to evaluate the performance and safety of autonomous vehicles. The input is the data stored in the test environment DB, and the output is the simulation results.

[1598] Step 6:

[1599] The user analyzes the simulation results and identifies areas for improvement in the system as needed. Specifically, the simulation results are evaluated using an analysis tool to extract areas for improvement. The input is the simulation results, and the output is a list of areas for improvement.

[1600] Example 2

[1601] Next, a description will be given of Example 2 of Form 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."

[1602] Conventional data generation systems have difficulty automatically generating data that has the same format as actual data and is suitable for business processing. Furthermore, when generating data for a test environment that does not contain personal information, it is necessary to provide data that is close to the commercial environment, but there has been a lack of efficient ways to achieve this.

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

[1604] In this invention, the server includes means for receiving a prompt sentence entered by a user, means for generating data based on the prompt sentence using a generative AI model, and means for returning the generated data to the user. This makes it possible to automatically generate data that has the same format as actual data and is suitable for business processing based on conditions specified by the user.

[1605] A "user" is an entity that operates the system and inputs prompt sentences.

[1606] A "prompt sentence" is text that describes the type and format of data that the user wants to generate, as well as specific conditions.

[1607] A "generative AI model" is an artificial intelligence model for generating data based on a prompt sentence.

[1608] "Data" is a collection of information generated by a generative AI model, with a particular format and content.

[1609] A "server" is a computer system for running a generative AI model, receiving prompts, and returning generated data.

[1610] A "terminal" is a device through which a user enters prompt sentences and communicates with a server.

[1611] The "means for receiving" is a function that allows the server to receive a prompt sentence from the user.

[1612] "Means for generating" refers to the function by which the server generates data using a generative AI model.

[1613] The "means for returning" is a function that allows the server to return the generated data to the user.

[1614] The "display means" is a function that allows the terminal to show the generated data to the user.

[1615] The present invention relates to a system for automatically generating data based on a prompt sentence entered by a user. A specific embodiment of this system will be described below.

[1616] Using a web browser or a dedicated application, a user inputs a prompt statement that includes the type and format of data they want to generate, as well as specific conditions. For example, they input a prompt statement such as, "Generate customer information in a format that includes name, address, and phone number."

[1617] The device sends the prompt text entered by the user to the server using an HTTP request. The server then analyzes the received prompt text and executes the generative AI model. Specifically, the server uses a deep learning framework such as TensorFlow or PyTorch to execute the generative AI model on the GPU.

[1618] The generative AI model generates data based on the prompt. This generated data has the same format as the actual data and is suitable for business processing. The server converts the generated data into a standard data format such as JSON and sends it to the terminal as an HTTP response.

[1619] The terminal displays the generated data received from the server to the user. For example, in the case of a web browser, the generated data is displayed on the screen so that the user can check it.

[1620] As a concrete example, consider the case where the following prompt sentence is input to a generative AI model:

[1621] Example prompt sentence:

[1622] "Generate customer information. Format it to include name, address, and phone number."

[1623] When this prompt is sent from the device to the server, the server uses a generative AI model to generate the following data:

[1624] Example of generated data:

[1625] Name: Taro Yamada

[1626] Address: 1-1-1 Nishi-Shinjuku, Shinjuku-ku, Tokyo

[1627] Phone number: 03-1234-5678

[1628] Name: Hanako Sato

[1629] Address: 2-2-2 Umeda, Kita-ku, Osaka City, Osaka Prefecture

[1630] Phone number: 06-8765-4321

[1631] The data generated in this way has the same format as the actual data, and can be used to perform the same business processes in business scenarios in the financial industry.

[1632] This system can automatically generate data suitable for business processing that has the same format as the actual data based on user-specified conditions. This makes it possible to efficiently generate data for a test environment that does not contain personal information and provide data that is close to that of a commercial environment.

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

[1634] Step 1:

[1635] The user enters a prompt statement.

[1636] The user uses a web browser or a dedicated application to input a prompt statement that includes the type and format of the data they want to generate, as well as specific conditions. For example, they input a prompt statement such as, "Please generate customer information in a format that includes name, address, and phone number." The input prompt statement is sent to the terminal.

[1637] Step 2:

[1638] The terminal sends the prompt to the server.

[1639] The terminal sends the prompt text entered by the user to the server as an HTTP POST request. For example, it sends the following request:

[1640] POST / generate-data HTTP / 1.1

[1641] Host: example.com

[1642] Content-Type: application / json

[1643] {

[1644] "prompt": "Generate customer information, including name, address, and phone number."

[1645] }

[1646] The input is a prompt statement, and the output is a request sent to the server.

[1647] Step 3:

[1648] The server receives the prompt and executes the generative AI model.

[1649] The server analyzes the prompt received from the device and executes the generative AI model. Specifically, the server uses a deep learning framework such as TensorFlow or PyTorch to execute the generative AI model on a GPU. The input is the prompt, and the output is the generated data.

[1650] Step 4:

[1651] The server returns the generated data to the terminal.

[1652] The server converts the data generated by the generative AI model into a standard data format such as JSON and sends it to the terminal as an HTTP response. For example, it sends the following response:

[1653] HTTP / 1.1 200 OK

[1654] Content-Type: application / json

[1655] {

[1656] "generated_data": [

[1657] {

[1658] "Name": "Yamada Taro",

[1659] "Address": "1-1-1 Nishi-Shinjuku, Shinjuku-ku, Tokyo",

[1660] "Phone Number": "03-1234-5678"

[1661] },

[1662] {

[1663] "Name": "Hanako Sato",

[1664] "Address": "2-2-2 Umeda, Kita-ku, Osaka City, Osaka Prefecture",

[1665] "Phone Number": "06-8765-4321"

[1666] }

[1667] ]

[1668] }

[1669] The input is the generated data, and the output is the response sent to the terminal.

[1670] Step 5:

[1671] The terminal displays the generated data to the user.

[1672] The terminal displays the generated data received from the server on the screen. For example, in the case of a web browser, the data is displayed using the following HTML code:

[1673] html

[1674]

[1675] Name: Taro Yamada

[1676] Address: 1-1-1 Nishi-Shinjuku, Shinjuku-ku, Tokyo

[1677] Phone number: 03-1234-5678

[1678] Name: Hanako Sato

[1679] Address: 2-2-2 Umeda, Kita-ku, Osaka City, Osaka Prefecture

[1680] Phone number: 06-8765-4321

[1681]

[1682] The input is the generated data received from the server and the output is the display of the data to the user.

[1683] (Application example 2)

[1684] Next, a description will be given of Application Example 2 of Form 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."

[1685] The data required for security testing in financial institutions contains personal information, making it difficult to use actual data. Furthermore, test data must be in a format similar to the actual business environment, but generating such data requires a great deal of effort and time. Therefore, there is a need for a method of generating data that can be used for efficient and safe security testing.

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

[1687] In this invention, the server includes a means for automatically and randomly creating non-existent "possibly real" data, a means for providing the relevant data to a test environment database, a means for making the test environment database not based on personal information and as close to a commercial environment as possible, a data generation means for conducting security tests for financial institutions, and a means for operating as an application to be installed on a smartphone. This makes it possible to efficiently and safely generate the data required for security tests for financial institutions and provide it in a format that is close to an actual business environment.

[1688] "Possibly real data that does not actually exist" is virtual data that does not contain actual personal information or transaction information, but has the same format and content as real data.

[1689] "Random and automated generation means" refers to the ability to generate data in an unpredictable manner using specific algorithms or programs.

[1690] A "test environment database" is a database set up separately from the actual operating environment for testing and verification.

[1691] "Non-personal information" means that the data generated does not contain information about actual individuals.

[1692] "Means to approximate a commercial environment" refers to the function of ensuring that the data generated and its processing are as close as possible to the data and processing used in actual commercial systems.

[1693] "Data generation means for conducting security tests for financial institutions" refers to a function for generating data necessary for financial institutions to conduct security tests.

[1694] "Means that operate as an application installed on a smartphone" refers to the functionality of an application that operates on a smartphone and is provided in a form that the user can use.

[1695] A system for carrying out this invention is configured as follows: A server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment database, means for making the test environment database not based on personal information and as close as possible to a commercial environment, means for generating data for security testing of financial institutions, and means for operating as an application installed on a smartphone.

[1696] Program processing explanation

[1697] The server generates data using Python 3.x. Specifically, it uses a random data generation library to generate data such as customer information, account information, and transaction information. The generated data is provided to a test environment database and stored in a form that does not include personal information. This makes it possible to efficiently and securely generate the data required for security testing at financial institutions and provide it in a format that closely resembles the actual business environment.

[1698] Hardware and software used

[1699] Hardware: Smartphone (iOS or Android)

[1700] Software: Python 3.x, random data generation library

[1701] Specific examples

[1702] For example, when a financial institution conducts security testing, it can input prompt statements like the following into a generative AI model:

[1703] Prompt Sentence Examples

[1704] Generate 100 customer data, 200 account data, and 500 transaction data. Customer data includes customer ID, name, address, and phone number. Account data includes account ID and balance. Transaction data includes transaction ID, source account, destination account, and amount.

[1705] This prompt can be used to request data generation from the generative AI model. The generated data is then provided to a test environment database via an application installed on a smartphone, allowing financial institutions to conduct security tests in a format that closely resembles a real-world business environment.

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

[1707] Step 1:

[1708] A user starts an application on a smartphone and inputs a prompt statement requesting the generation of data required for security testing at a financial institution.

[1709] Input: Prompt statement (e.g., "Generate 100 customer records, 200 account records, and 500 transaction records.")

[1710] Output: The prompt text is sent to the server.

[1711] Step 2:

[1712] The server receives the prompt sentence and inputs the prompt sentence into the generative AI model.

[1713] Input: prompt statement

[1714] Output: A template of the data generated by the generative AI model

[1715] Step 3:

[1716] The server generates actual data using a random data generation library based on the template received from the generative AI model.

[1717] Input: Data template

[1718] Output: Randomly generated customer, account, and transaction data

[1719] Step 4:

[1720] The server stores the generated data in the test environment database.

[1721] Input: Randomly generated data

[1722] Output: Data stored in the test environment database

[1723] Step 5:

[1724] Users can check the generated data through a smartphone application and perform security tests as necessary.

[1725] Input: Data stored in the test environment database

[1726] Output: User-confirmed data and security test results

[1727] Step 6:

[1728] The server analyzes the results of the security test and provides the necessary feedback to the user.

[1729] Input: Security test results

[1730] Output: Feedback report

[1731] Example 3

[1732] Next, a third embodiment of the third embodiment will be described. 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."

[1733] In conventional test environments, data needed to be manually created to replicate actual business scenarios, which was time-consuming and labor-intensive. Furthermore, data containing personal information could not be used, making it difficult to create a test environment that closely resembled a commercial environment. This hindered business efficiency.

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

[1735] In this invention, the server includes means for a user to input a prompt sentence, means for a terminal to send the prompt sentence to the server, means for the server to generate data using a generative AI model, means for the server to save the data generated by the server in a test environment DB, means for a user to check the data in the test environment DB, means for automatically randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to the test environment DB, and means for the test environment DB to be free from personal information and to be as close to a commercial environment as possible. This makes it possible to automatically generate data for reproducing actual business scenarios and provide it to the test environment DB.

[1736] A "user" is an entity that operates the system and inputs prompt sentences.

[1737] A "terminal" is a device through which a user inputs prompt text and sends it to a server.

[1738] The "server" is a device that receives prompt sentences, generates data using a generative AI model, and stores it in the test environment DB.

[1739] A "prompt sentence" is an instruction sentence entered by the user to the generative AI model.

[1740] A "generative AI model" is an artificial intelligence model for generating data based on a prompt sentence.

[1741] "Data" is information generated by a generative AI model to satisfy a specific business scenario.

[1742] The "test environment DB" is a database that stores the generated data and operates in the same way as actual business processing.

[1743] "Possible real data" is data that does not actually exist but is generated based on a real business scenario.

[1744] "Random automated generation" refers to a method that uses a generative AI model to automatically generate data without user intervention.

[1745] "Means to approximate a commercial environment" refers to a method designed to make the test environment DB operate in the same way as an actual commercial environment.

[1746] This invention is a system in which a user inputs a prompt sentence, generates data using a generative AI model, and stores the data in a test environment DB. A specific embodiment of this system will be described below.

[1747] First, the user inputs a prompt sentence using a terminal. The terminal is a device such as a personal computer or smartphone, and must be connected to the Internet. The user opens a browser on the terminal and inputs the prompt sentence into a dedicated input form. Examples of prompt sentences include "Generate data for a scenario in which the transaction is successful" and "Generate data for a scenario in which the transaction fails."

[1748] Next, the terminal sends the entered prompt text to the server. This transmission uses a communication protocol such as an HTTP request. When the submit button on the input form is clicked, the terminal sends an HTTP POST request including the prompt text to the server.

[1749] The server analyzes the received prompt and generates data using a generative AI model. The generative AI model can be an advanced natural language processing model such as OpenAI's GPT-4. The server generates data that fulfills a specific business scenario based on the prompt. For example, if the prompt is "Generate data for a scenario in which the transaction is successful," the following data will be generated:

[1750] Transaction ID: 12345

[1751] Transaction Status: Success

[1752] Transaction amount: 100,000 yen

[1753] Transaction Date: 2023-10-01 10:00:00

[1754] The generated data is stored in the test environment DB by the server. The test environment DB is a database that operates in the same way as actual business processing, and it is possible to simulate business operations using the generated data. The server inserts the generated data into the test environment DB using an SQL query. For example, execute the following SQL query:

[1755] sql

[1756] INSERT INTO transactions (transaction_id, status, amount, date_time) VALUES (12345, 'success', 100000, '2023-10-01 10:00:00');

[1757] Finally, the user accesses the test environment database via a terminal and checks the generated data. The user can access the test environment database management screen in the terminal browser and verify whether the generated data satisfies the business scenario. For example, the user searches for the record with transaction ID 12345 and checks that the transaction status is "successful."

[1758] In this way, the user can simulate the business using the generated data and improve the business efficiency. This system makes it possible to automatically generate data for reproducing an actual business scenario and provide it to the test environment DB. The flow of the identification process in the third embodiment will be described with reference to FIG. 15.

[1759] Step 1:

[1760] The user enters a prompt statement.

[1761] The user opens a browser on the device and enters the following into a dedicated input form: "Generate data for a scenario in which the transaction is successful." The entered prompt text is saved in the device's memory.

[1762] Step 2:

[1763] The terminal sends the prompt to the server.

[1764] When the submit button of the input form is clicked, the terminal sends an HTTP POST request including a prompt text to the server. The input is the prompt text, and the output is an HTTP request to the server.

[1765] Step 3:

[1766] The server receives and parses the prompt.

[1767] The server parses the received HTTP POST request and extracts the prompt text. The input is the HTTP request and the output is the prompt text.

[1768] Step 4:

[1769] The server generates data using a generative AI model.

[1770] The server inputs the extracted prompt sentences into a generative AI model (e.g., GPT-4) to generate data that meets a specific business scenario. The input is the prompt sentence, and the output is the generated data. For example, the following data is generated:

[1771] Transaction ID: 12345

[1772] Transaction Status: Success

[1773] Transaction amount: 100,000 yen

[1774] Transaction Date: 2023-10-01 10:00:00

[1775] Step 5:

[1776] The data generated by the server is saved in the test environment database.

[1777] The server inserts the generated data into the test environment DB using an SQL query. The input is the generated data, and the output is the data stored in the test environment DB. For example, execute the following SQL query:

[1778] sql

[1779] INSERT INTO transactions (transaction_id, status, amount, date_time) VALUES (12345, 'success', 100000, '2023-10-01 10:00:00');

[1780] Step 6:

[1781] The user checks the data in the test environment database.

[1782] The user accesses the test environment DB management screen using the device's browser and checks the generated data. The input is the test environment DB data, and the output is the data checked by the user. For example, search for the record with transaction ID 12345 and check that the transaction status is "Success."

[1783] (Application example 3)

[1784] Next, a description will be given of Application Example 3 of Form Example 3. 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."

[1785] When simulating business scenarios at logistics centers, it is difficult to create a test environment that operates in the same way as actual business processes. It is also difficult to generate data that is close to a commercial environment while using data that is not based on personal information. This hinders efforts to improve business efficiency and system reliability.

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

[1787] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment DB, means for making the test environment DB not based on personal information and as close to a commercial environment as possible, means for generating data for simulating business scenarios within a logistics center, and means for importing the generated data into the test environment database and verifying whether it operates in the same way as actual business processing. This makes it possible to simulate business scenarios in a logistics center, thereby improving business efficiency and system reliability.

[1788] "Possible realistic data" is data that is generated based on actual business scenarios and mimics realistic situations.

[1789] A "random, automatic generation means" is a device or program that has the function of randomly generating data using a specific algorithm.

[1790] The "test environment DB" is a database used to check and test the system's operation.

[1791] "Non-personally identifiable" means that the data generated does not contain personally identifiable information.

[1792] "Means of approximating a commercial environment" refers to functions and methods for reproducing data and operations that are close to those used in actual commercial systems.

[1793] "Business scenarios within a logistics center" refers to a series of business procedures and situations at a logistics center, such as receiving goods, shipping, inventory management, and returning goods.

[1794] "Data for simulation" is data that imitates a specific business scenario and is generated based on that scenario.

[1795] "Importing into a database in a test environment" means importing the generated data into a database in a test environment and making it operate in the same way as actual business processing.

[1796] "Means for verifying whether the system operates in the same way as actual business processing" refers to a method or device for verifying whether the system operates correctly using the generated data.

[1797] In order to put the present invention into practice, it is necessary to build a system for simulating business scenarios within a logistics center. This system is realized using the following hardware and software.

[1798] Hardware and Software

[1799] Hardware: Smartphone, server, test environment database

[1800] Software: Python environment, data generation algorithms, database management system

[1801] Data processing and calculation

[1802] The server first randomly and automatically creates "possibly real" data that does not actually exist. This data is generated using a data generation algorithm in a Python environment. The generated data is provided to a test environment database. This database uses data that is not based on personal information, but maintains data similar to that of a commercial environment.

[1803] Next, the server generates data to simulate business scenarios within the distribution center. This data is generated based on business scenarios such as product receipt, shipping, inventory management, and return processing. The generated data is imported into a database in a test environment and used to verify whether it behaves in the same way as actual business processes.

[1804] Specific examples

[1805] For example, to simulate a "receiving" scenario at a distribution center, the following prompt statement would be used:

[1806] Prompt Sentence Examples

[1807] python

[1808] Example usage

[1809] scenario = "arrival"

[1810] generated_data = generate_scenario_data(scenario)

[1811] print(generated_data)

[1812] When you run this prompt, you will get the following output:

[1813] json

[1814] {

[1815] "transaction_id": 1234,

[1816] "product_id": 567,

[1817] "quantity": 50,

[1818] "status": "Success"

[1819] }

[1820] The data generated in this way can be imported into a database in a test environment to check whether it operates in the same way as actual business processes. This system makes it possible to simulate business scenarios at logistics centers, thereby improving business efficiency and system reliability.

[1821] The flow of the specific processing in Application Example 3 will be described with reference to FIG.

[1822] Step 1:

[1823] The server receives input from the user about the scenario type (e.g., "receiving," "shipping," "inventory management," "return processing") and determines which business scenario to simulate based on this input.

[1824] Step 2:

[1825] The server uses a Python environment to automatically and randomly create data corresponding to the specified scenario type. For example, for an "Arrival of Goods" scenario, data items such as transaction ID, product ID, quantity, and status are randomly generated. A data generation algorithm is used to generate this data. The input is the scenario type, and the output is the generated data.

[1826] Step 3:

[1827] The server converts the generated data into JSON format and provides it to the test environment database. This database uses data that is not based on personal information and maintains data similar to the production environment. The input is the generated data, and the output is the data imported into the test environment database.

[1828] Step 4:

[1829] The server uses the data imported into the test environment database to simulate business scenarios within the logistics center. For example, in the case of a "receiving" scenario, it checks whether the receiving process for goods is carried out correctly. The input is the data imported into the test environment database, and the output is the simulation results.

[1830] Step 5:

[1831] The server provides the simulation results to the user. The user checks the simulation results and evaluates whether they work in the same way as the actual business process. The input is the simulation results, and the output is feedback to the user.

[1832] In this way, it becomes possible to simulate business scenarios at logistics centers, thereby improving business efficiency and system reliability.

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

[1834] "Example 1"

[1835] In one embodiment of the present invention, the emotion engine recognizes the user's emotion and adjusts parameters for data generation based on the emotion. Specifically, when the user is feeling joy, the emotion engine adjusts parameters to generate data related to joy. This allows the test environment DB to simulate business scenarios related to joy.

[1836] "Example 2"

[1837] In another embodiment of the present invention, the emotion engine selects a specific work scenario based on the user's emotion. For example, when the user feels anxious, the emotion engine selects a work scenario related to anxiety. This allows the test environment DB to simulate a work scenario related to anxiety.

[1838] "Example 3"

[1839] Furthermore, in another embodiment of the present invention, the emotion engine recognizes the user's emotion, adjusts parameters for data generation based on the emotion, and selects a specific business scenario. For example, when the user is feeling angry, the emotion engine adjusts parameters to generate data related to anger and selects a business scenario related to anger. This allows the test environment DB to simulate a business scenario related to anger.

[1840] The processing flow of each embodiment will be described below.

[1841] "Example 1"

[1842] Step 1: The emotion engine recognizes the user's emotion.

[1843] Step 2: Adjust the parameters of data generation based on the emotions recognized by the emotion engine.

[1844] Step 3: The test environment DB generates data based on the adjusted parameters.

[1845] "Example 2"

[1846] Step 1: The emotion engine recognizes the user's emotion.

[1847] Step 2: Select a specific business scenario based on the emotions recognized by the emotion engine.

[1848] Step 3: Based on the selected business scenario, the test environment DB generates data.

[1849] "Example 3"

[1850] Step 1: The emotion engine recognizes the user's emotion.

[1851] Step 2: Adjust the parameters of data generation based on the emotions recognized by the emotion engine and select a specific business scenario.

[1852] Step 3: The test environment DB generates data based on the adjusted parameters and the selected business scenario.

[1853] Example 1

[1854] Next, a description will be given of Example 1 of Form 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."

[1855] With conventional test environment databases, it was difficult to automatically randomly generate data that did not actually exist but could be considered "realistic," and it was not possible to adjust data generation parameters based on user emotions. As a result, the test environment could not approximate a commercial environment, and business scenarios were not simulated properly. Furthermore, given the demand for data generation that was not based on personal information, an efficient data generation method was needed.

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

[1857] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the relevant data to a test environment database, means for making the test environment database not based on personal information and as close to a commercial environment as possible, means for recognizing user emotions and adjusting parameters for data generation based on the emotions, means for importing the generated data into the test environment database, and means for the test environment database to simulate business scenarios using the provided data. This makes the test environment database closer to a commercial environment, makes it possible to generate data based on user emotions, and enables the simulation of more realistic business scenarios.

[1858] "Potentially real data that does not actually exist" is not real data, but is reliable data that is generated based on real business scenarios and situations.

[1859] "Random, automated generation methods" are techniques that use specific algorithms or programs to automatically generate data in an unpredictable manner.

[1860] A "test environment database" is a database used to test systems and applications, and is intended to simulate conditions close to the actual operating environment.

[1861] "Non-personal information" means that the data generated does not contain information that identifies a specific individual.

[1862] "Means to approximate a commercial environment" refers to techniques and methods for making the test environment database have the same conditions and data structure as an actual commercial operating environment.

[1863] "Means for recognizing user emotions" refers to technology for analyzing the user's emotional state and adjusting the system's behavior based on that.

[1864] "Means for adjusting data generation parameters" refers to technology for changing the characteristics and content of generated data based on the user's emotions and other conditions.

[1865] A "means for importing generated data" is a technique or method for incorporating externally generated data into the test environment database.

[1866] "Means for simulating business scenarios" refers to technology for reproducing actual business processes and scenarios based on a test environment database, and for conducting tests and evaluations.

[1867] This invention is a system that automatically randomly creates "possibly real" data that does not actually exist in a test environment database and provides the relevant data. A specific embodiment of this system will be described below.

[1868] System configuration

[1869] 1. User Emotion Recognition

[1870] A user inputs their emotions into the system using emotion recognition software. For example, if a user is excited about the release of a new product, the user communicates that emotion to the system through the emotion recognition software. The server analyzes the user's emotions using an emotion recognition API (e.g., a general emotion recognition API).

[1871] 2. Defining Data Generation Patterns

[1872] The server defines a data generation pattern based on the user's emotions. For example, if the user is feeling happy, the server defines a data pattern related to a new product release. This pattern includes items such as the product name, release date, and expected sales.

[1873] 3. Generating Random Data

[1874] The server generates random data according to a defined data pattern. For example, it uses Python's random module to generate random data such as product names, release dates, and sales figures. The generated data is saved in JSON or CSV format.

[1875] 4. Providing data to the test environment database

[1876] The server provides the generated data to the test environment database, for example by running an SQL script to import the generated data into a common database management system (DBMS), which adds the new data to the test environment database.

[1877] 5. Business scenario simulation

[1878] The test environment database uses the provided data to simulate business scenarios, such as sales forecasts and marketing strategies related to a new product release. The terminal displays the results of the simulation to the user.

[1879] Specific examples

[1880] For example, if a user is excited about a new product release, they communicate that emotion to the system through emotion recognition software. The server uses the emotion recognition API to analyze the user's emotion as "joy." Next, the server defines a "data pattern related to the new product release" and uses Python's random module to generate data like this:

[1881] Product Name: "ProductX"

[1882] Release Date: "2023-12-01"

[1883] Expected sales: "10000"

[1884] The server runs SQL scripts to import the generated data into popular database management systems, for example by executing SQL statements such as:

[1885] sql

[1886] INSERT INTO test_environment_db (product_name, release_date, expected_sales) VALUES ('ProductX', '2023-12-01', '10000');

[1887] The test environment database uses the imported data to simulate business scenarios related to new product releases. The terminal displays the simulation results to the user, such as sales forecast graphs and marketing strategy simulation results.

[1888] Prompt Sentence Examples

[1889] “If a user is excited about a new product release, how does the emotion engine adjust its parameters for data generation?”

[1890] Using this prompt, the generative AI model can provide detailed explanations of how the emotion engine works and the specific methods used to generate the data.

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

[1892] Step 1:

[1893] User emotion input

[1894] Using emotion recognition software, users input their emotions into the system. For example, if a user is excited about the release of a new product, they input that emotion. The input emotion data is then sent to the server.

[1895] Step 2:

[1896] Emotion Analysis

[1897] The server analyzes the received emotion data using an emotion recognition API. For example, it uses a general emotion recognition API to analyze the user's emotion as "joy." The analysis results are used to adjust the data generation parameters. The input is emotion data, and the output is analyzed emotion information.

[1898] Step 3:

[1899] Defining Data Generation Patterns

[1900] The server defines a data generation pattern based on the analyzed emotional information. For example, if the user is feeling happy, the server defines a "data pattern related to new product release." This pattern includes items such as the product name, release date, and expected sales. The input is the analyzed emotional information, and the output is the data generation pattern.

[1901] Step 4:

[1902] Random Data Generation

[1903] The server generates random data according to a defined data generation pattern. For example, it uses Python's random module to randomly generate data such as product names, release dates, and sales figures. The generated data is saved in JSON or CSV format. The input is the data generation pattern, and the output is the generated random data.

[1904] Step 5:

[1905] Importing Data

[1906] The server imports the generated data into the test environment database. For example, it executes an SQL script to import the generated data into a common database management system. This adds new data to the test environment database. The input is the generated random data, and the output is the data imported into the test environment database.

[1907] Step 6:

[1908] Business scenario simulation

[1909] The test environment database uses the provided data to simulate business scenarios. For example, data related to a new product release is used to simulate sales forecasts and marketing strategies. The terminal displays the simulation results to the user. The input is the data imported into the test environment database, and the output is the simulated results of the business scenario.

[1910] (Application example 1)

[1911] Next, a description will be given of Application Example 1 of Form 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."

[1912] Conventional test environment database systems have difficulty in automatically randomly generating data that does not actually exist but could be considered "realistic," and they are unable to adjust data generation parameters based on user emotions. As a result, the test environment cannot approximate a commercial environment, making it difficult to improve operational efficiency or meet specific business scenarios. Furthermore, it is also impossible to generate and display optimal advertisements based on user emotions.

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

[1914] In this invention, the server includes means for automatically and randomly creating "possibly real" data that does not actually exist, means for providing the corresponding data to a test environment DB, means for making the test environment DB not based on personal information and as close to a commercial environment as possible, means for recognizing user emotions and adjusting data generation parameters based on those emotions, and means for generating and displaying optimal advertisements based on the user emotions. This makes it possible to make the test environment closer to a commercial environment, improving business efficiency and satisfying specific business scenarios. It also makes it possible to generate and display optimal advertisements based on the user's emotions.

[1915] "Possible real data that does not actually exist" refers to data that does not exist in the real world but could actually occur.

[1916] "Random, automated generation means" refers to devices or programs that have the function of randomly generating data based on specific algorithms or rules.

[1917] "Test environment DB" refers to a database used for testing systems and applications.

[1918] "Means for providing the relevant data" refers to devices or programs that have the function of supplying the generated data to the test environment DB.

[1919] "Not based on personal information" means that the generated data does not contain information that identifies a specific individual.

[1920] "Means to approximate a commercial environment" refers to devices and programs that have the functionality to make the test environment as close as possible to the actual commercial environment.

[1921] "Means for recognizing user's emotions" refers to a device or program that has the function of detecting and identifying the user's emotional state.

[1922] "Means for adjusting data generation parameters" refers to a device or program that has the function of changing the settings and conditions for data generation based on the user's emotions.

[1923] "Means for generating and displaying optimal advertisements" refers to devices or programs that have the function of creating the most appropriate advertisements based on the user's emotions and displaying them to the user.

[1924] The following system configuration will be described as an embodiment of the present invention.

[1925] The server has a means to automatically generate random data that "could be real" but does not actually exist. This means is a device or program that has the function of generating random data based on specific algorithms or rules. For example, a Python program can be used to define a data pattern based on a business scenario and generate random data according to that pattern.

[1926] Next, the server has a means for providing the generated data to the test environment DB. This means is a device or program with the function of supplying the generated data to the test environment DB. The test environment DB is a database used for testing systems and applications, and by using data that is not based on personal information, it can be made closer to a commercial environment while ensuring privacy protection.

[1927] Furthermore, the server has a means for recognizing the user's emotions and adjusting the parameters of data generation based on those emotions. This means is a device or program with the function of detecting and identifying the user's emotional state. For example, if the user inputs the word "happy," the server sets the emotion to "joy" and adjusts the settings and conditions of data generation based on that emotion.

[1928] Finally, the server has a means for generating and displaying the most appropriate advertisement based on the user's emotions. This means is a device or program with the function of creating the most appropriate advertisement based on the user's emotions and displaying it to the user. For example, if the user inputs "I am feeling very happy today!", the emotion engine will recognize "joy" and display an advertisement related to joy.

[1929] For illustrative purposes, consider the following prompt:

[1930] "Design a system that recognizes a user's emotions and generates and displays the most appropriate ads based on those emotions. For example, if a user types 'happy', display ads related to joy."

[1931] In this way, the test environment can be made closer to the commercial environment, improving operational efficiency and meeting specific business scenarios, and generating and displaying optimal ads based on user emotions.

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

[1933] Step 1:

[1934] The server receives input from the user.

[1935] Input: Text that describes the user's feelings (e.g., "I am feeling very happy today!")

[1936] Specific operation: The server receives text data entered by the user.

[1937] Step 2:

[1938] The server uses an emotion engine to recognize the user's emotion.

[1939] Input: Text indicating the user's sentiment

[1940] Data processing: Perform text analysis to identify emotions (e.g., detect the word "happy")

[1941] Output: Recognized emotion (e.g. "joy")

[1942] Specific operation: The server uses a text analysis algorithm to extract sentiment from the user's input text.

[1943] Step 3:

[1944] The server uses a data generation module to adjust parameters of the data generation based on the recognized emotion.

[1945] Input: A recognized emotion (e.g., "joy") 【194...

Claims

1. A means for randomly and automatically creating data that does not actually exist but could be real; means for providing said data to a test environment database used to test or validate the system; means for making the data provided to the test environment database not include actual personal information and approximate situations that may occur in an actual commercial environment; A means for recognizing the user's emotions and adjusting the parameters of automatically generated data based on the recognized emotions. means for importing the generated data into the test environment database; means for simulating a business scenario using the data provided to the test environment database; A system including:

2. 2. The system according to claim 1, wherein the automatically created data is in a format that contributes to improving business efficiency.

3. 2. The system according to claim 1, wherein the automatically generated data has contents that satisfy a specific business scenario.

Images