System

Abstract

A system is provided.SOLUTION: A system including means for a user to input a test data generation request, means for a server to receive and analyze input data from the user, means for the server to generate test data based on infrastructure and development environment used by the server and a used component, means for the server to verify the generated data and correct the data as necessary, and means for the server to provide the verified test data to the user.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] When developing new services, preparing test data requires time and effort, which can reduce the quality and efficiency of testing. Furthermore, manually created test data can lack consistency and fail to fully meet specific test conditions. Furthermore, it is difficult to quickly generate data that is adapted to the infrastructure and development environment being used. This can reduce the accuracy of testing and delay the development cycle. [Means for solving the problem]

[0005] The present invention automates the test data generation process by providing a means for a user to input a test data generation request and a means for a server to receive and analyze the input data from the user. Furthermore, by providing a means for generating test data based on the infrastructure, development environment, and components used by the server, highly compatible test data can be created quickly. Furthermore, the server includes a means for verifying the generated data and correcting it as necessary, ensuring the quality of the test data. Finally, by providing the server with verified test data, the user can significantly reduce test preparation time and perform tests efficiently.

[0006] A "user" is an entity that accesses the system and inputs test data generation requests.

[0007] A "test data generation request" is an instruction that a user inputs into the system to generate data required for developing and testing a new service.

[0008] A "server" is a central computer system that receives and analyzes input data from users, and generates and provides appropriate test data.

[0009] "Input data" refers to various information provided by the user to the system as a test data generation request, including test conditions such as the number of initial users, the number of products, and the number of orders.

[0010] "Analysis" is a process in which the server determines the conditions for generating the necessary test data based on the input data received from the user.

[0011] "Infrastructure" means the underlying hardware and software environment for generating and managing test data.

[0012] "Development environment" is a general term for a group of platforms and tools used for software development and testing.

[0013] "Used components" are modules or programs that constitute part of a system or application, and are elements that affect test data generation.

[0014] "Test Data" means a series of data used to verify the functionality and performance of new services during their development and testing.

[0015] "Verification" is a procedure for confirming whether the generated test data meets specified conditions.

[0016] "Correction" is a process for correcting inconsistencies or problems in the generated test data to make it correct data.

[0017] "Providing" refers to the act of the server providing the validated test data to the user in an easy-to-use format.

[0018] A "data pattern" is a typical data structure or example for generating test data, extracted from past test data or existing data. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0027] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0040] The present invention is a system that automatically generates and efficiently provides test data required for preliminary testing and verification when developing a new service. Below, the program processing and specific examples of this system are explained in natural language.

[0041] System Overview

[0042] The user requests test data generation, and the server automatically generates the appropriate test data based on that request. The generated data is then verified and corrected, and finally provided to the user. This streamlines the test data generation process, significantly reducing the time and effort required for the development and testing cycle.

[0043] User inputs test data generation request

[0044] The user accesses the system through a browser or a dedicated application and enters the required information using the test data generation form, including, for example, the number of initial users, the number of products, the number of orders, and other specific conditions. After completing the input, the user submits a generation request.

[0045] The server receives and parses the request

[0046] When the server receives a request from a user, it analyzes the input data. Based on the analysis, it determines what kind of test data is needed and sets the corresponding generation conditions. For example, in the case of product data, information such as category, price range, and inventory quantity is set.

[0047] The server generates the test data

[0048] The server automatically generates test data, taking into account the infrastructure, development environment, and components being used. The server references past test data and stored data patterns and uses a generation algorithm to create new data. This data includes user data, product data, order data, and more.

[0049] Server validates and corrects generated data

[0050] The generated test data is internally verified via the server. During the verification process, the data is checked to see if it meets specified conditions and is consistent. If necessary, the data is corrected or regenerated. For example, it is checked to see if the generated order data is properly distributed within a specific period.

[0051] The server provides the test data

[0052] Once the verification is complete, the test data is converted into an appropriate format (e.g., CSV or JSON) by the server and provided to the user. Users can then download this data and introduce it into their own test environment, facilitating the development and testing of new services.

[0053] Specific examples

[0054] For example, suppose you are developing a new online shopping system and a user enters the following information:

[0055] Initial number of users: 1000

[0056] Number of products: 500

[0057] Order quantity: 3000

[0058] Percentage of specific product categories: 20%

[0059] Test period: 1 month

[0060] Based on this information, the server generates random user data, product data, and order data that meets specified conditions. The generated data undergoes an internal validation process before being provided to the user. Specifically, the server checks whether the generated order data is evenly distributed within a specified one-month period, whether a specific product category accounts for 20% of all products, and so on. Using this test data, users can efficiently develop and test their online shopping systems.

[0061] The processing flow will be explained below.

[0062] Step 1:

[0063] A user logs into the system via a browser or a dedicated application. The server authenticates the user and grants access.

[0064] Step 2:

[0065] The user enters the required information into the test data generation form, including the number of initial users, number of products, number of orders, specific conditions (e.g., specific categories or period), etc. The user confirms the input and presses the submit button.

[0066] Step 3:

[0067] The server receives the data sent by the user as an HTTP request, analyzes the request parameters, and extracts the basic information necessary to generate test data.

[0068] Step 4:

[0069] The server analyzes the input data and determines the type of test data required (user data, product data, order data, etc.) and the conditions for generating it.

[0070] Step 5:

[0071] The server references past test data and stored data patterns and prepares an algorithm for generating new test data based on this.

[0072] Step 6:

[0073] The server generates new test data based on the generation conditions. For example, for initial user data, a random username is generated, along with an email address and registration date.

[0074] Step 7:

[0075] The generated test data is temporarily stored in storage, and the data is converted to formats such as JSON, CSV, SQL dump, etc. as needed.

[0076] Step 8:

[0077] The server starts an internal validation of the generated data, checking whether it meets the specified conditions and whether the data is consistent.

[0078] Step 9:

[0079] If any problems are found during the validation process, the server will either regenerate the portion or apply an appropriate correction algorithm to correct the data.

[0080] Step 10:

[0081] The server converts the validated and corrected data into a final format, for example, exporting the data in CSV format and generating a download link.

[0082] Step 11:

[0083] Users download the test data via the provided link, and once the download is complete, they introduce the data into their own test environment.

[0084] Step 12:

[0085] Tests are performed on systems and services under development using test data acquired by the user. The test results are analyzed and feedback is provided to the system and data as needed.

[0086] Through this series of steps, users can efficiently generate, introduce, and test test data for new services.

[0087] Example 1

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

[0089] Conventional test data generation systems require manual data generation and verification, resulting in inefficiency and time-consuming labor. Furthermore, generating test data based on specific conditions or time periods can be difficult, potentially delaying the development and testing cycle of new services. The present invention aims to solve these problems by streamlining and automating the test data generation process.

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

[0091] In this invention, the server includes: means for inputting a prompt sentence using a natural language processing model when a user requests test data generation, and specifying the requirements for test data generation; means for the server to refer to past test data and stored data patterns and generate new test data based thereon; and means for verifying whether the generated test data is appropriately distributed within a set period and satisfies specific category conditions. This enables efficient and automatic generation of test data, enabling the development and testing cycle of new services to proceed quickly.

[0092] "User" means an end user who accesses the system and enters a request for test data generation.

[0093] A "server" is a central computer system that receives requests from users, analyzes them, generates data, validates them, and provides them.

[0094] A "test data generation request" is a set of information and conditions that a user inputs to request the generation of test data through the system.

[0095] "Infrastructure" refers to the hardware and software infrastructure required for a system to operate.

[0096] "Development Environment" refers to the set of software and tools used for developing, testing, and operating a System.

[0097] "Used components" refer to software libraries and modules that the system uses when generating test data.

[0098] A "natural language processing model" is an artificial intelligence model that analyzes and understands prompts entered by users.

[0099] A "prompt sentence" is a sentence that a user inputs in natural language when specifying conditions or requirements for generating test data.

[0100] "Past test data" refers to a collection of previously generated test data that is used as a reference for generating new data.

[0101] "Data patterns" refer to recurring trends or rules found in past test data.

[0102] "Verification measures" refer to the processes and tools used to verify that the generated test data meets specified conditions.

[0103] "Test data generation requirements" refer to conditions and constraints specified by a user when making a request for test data generation.

[0104] A "specific category condition" is a condition that indicates whether the test data conforms to a specific classification or category.

[0105] A "test period" refers to a specific time range established when test data is generated.

[0106] "Data format" refers to the data format (e.g., CSV, JSON) in which the generated test data is provided to the user.

[0107] This invention is a system that automatically generates and efficiently provides test data required for preliminary testing and verification when developing new services. The main components of this system are users, servers, and terminals. The specific functions and operations of each component are described below.

[0108] User inputs test data generation request

[0109] Users access the system through a browser or a dedicated application. Specifically, they use web browsers such as GOOGLE CHROME (registered trademark) or Mozilla Firefox, or Windows or iOS apps. The user uses the test data generation form to enter the required information (number of initial users, number of products, number of orders, specific conditions, etc.) and submits a generation request. For example, the user might enter the following information:

[0110] Initial number of users: 1000

[0111] Number of products: 500

[0112] Order quantity: 3000

[0113] Percentage of specific product categories: 20%

[0114] Test period: 1 month

[0115] The user can also specify requirements for test data generation by entering prompt sentences using a natural language processing model.

[0116] The server receives and parses the request

[0117] The server receives requests from users through a web server such as Apache® or NGINX. The back-end system uses programs written in Python or Java® to analyze the received data. During this analysis process, specific conditions for generating test data are set based on information entered by the user. These conditions include the initial number of users, the number of products, the percentage of product categories, and the test period.

[0118] The server generates the test data

[0119] The server automatically generates test data using cloud services such as AWS (registered trademark) Lambda and Google (registered trademark) Cloud Functions. At this time, it executes data generation algorithms using Python and R libraries (Pandas, NumPy). The generated test data includes user data, product data, and order data. As a concrete example, data is generated using the following prompt statement:

[0120] "To develop a new online shopping system, please generate test data that meets the following conditions:

[0121] Initial number of users: 1000

[0122] Number of products: 500

[0123] Order quantity: 3000

[0124] Percentage of specific product categories: 20%

[0125] Test period: 1 month

[0126] Server validates and corrects generated data

[0127] The generated test data undergoes a validation process on the server. Data consistency is confirmed using an SQL database (MySQL (registered trademark), PostgreSQL) or a NoSQL database (MongoDB). Specific validation tasks include checking for duplicate user IDs, whether the product category ratios are as specified, and whether the order data is evenly distributed within the test period. If any inconsistencies are found, the data is corrected or regenerated.

[0128] The server provides the test data

[0129] Once the validation is complete, the data is converted to CSV or JSON format and provided to the user. This conversion is performed using the Pandas .to_csv() method or the Node.js file system module. Users can obtain the test data via the provided download link and install it into their own development environment.

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

[0131] Step 1:

[0132] User inputs test data generation request

[0133] The user accesses the system through a browser or a dedicated application and enters the necessary information into the test data generation form. This input information includes the initial number of users, number of products, number of orders, and specific conditions (e.g., percentage of specific product categories, test period). After completing the input, the user submits a generation request. The specific operation here is that the user interface is implemented using HTML forms and React.js components.

[0134] Input: Number of initial users, number of products, number of orders, specific conditions

[0135] Output: Generated request data

[0136] Step 2:

[0137] The server receives and parses the request

[0138] The server receives generation requests from users through a web server such as Apache or NGINX. A back-end program written in Python or Java then analyzes the request data. During this analysis process, specific conditions for test data generation are set based on the information entered by the user. Specifically, it determines how the number of products, number of orders, percentage of specific product categories, and test period will be handled.

[0139] Input: Generation request data

[0140] Output: Conditions for generating test data

[0141] Step 3:

[0142] The server generates the test data

[0143] The server automatically generates test data based on the set conditions using cloud services such as AWS Lambda and Google Cloud Functions. It executes data generation algorithms using Python and R libraries (Pandas, NumPy). Specifically, it references past test data and stored data patterns to generate user data, product data, and order data.

[0144] Input: Test data generation conditions

[0145] Output: Generated test data

[0146] Step 4:

[0147] Server validates and corrects generated data

[0148] The generated test data undergoes a validation process on the server. This process uses an SQL database (MySQL, PostgreSQL) or a NoSQL database (MongoDB) to check the data's consistency. Specific validation tasks include checking for duplicate user IDs, whether the product category ratios are as specified, and whether the order data is evenly distributed within the test period. If any inconsistencies are found, the data is corrected or regenerated.

[0149] Input: Generated test data

[0150] Output: Verified test data

[0151] Step 5:

[0152] The server provides the test data

[0153] Once the test data has been validated, it is converted into the appropriate data format (CSV, JSON) by the server. This conversion process uses the Pandas .to_csv() method or the Node.js file system module. Users can then import the test data into their development environment via the provided download link.

[0154] Input: Verified test data

[0155] Output: Test data provided

[0156] (Application example 1)

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

[0158] The development of autonomous vehicles requires the generation and verification of a huge amount of test data, and the manual generation process is extremely time-consuming and labor-intensive. Therefore, there is a need for a method to efficiently generate test data and automate the verification process. It is also important to accurately verify that the generated data meets specified conditions and provide the resulting data in a specific data format.

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

[0160] In this invention, the server includes means for a user to input a test data generation request, means for the server to receive and analyze the input data from the user, means for generating test data based on the infrastructure, development environment, and components used by the server, means for inputting parameters required to generate simulation data for an autonomous vehicle, means for generating test data based on simulation parameters such as weather conditions and traffic volume, means for verifying the generated test data and correcting it as necessary, and means for the server to provide the verified test data to the user. This enables efficient generation of simulation data required for the development of autonomous vehicles and accurate verification and provision of the data.

[0161] A "test data generation request" is a request for specific test data that a user wants the system to generate.

[0162] "Server" is a central computer system that analyzes user input data and generates, verifies, and provides test data.

[0163] "Input data" refers to data provided by a user to a system, and includes information necessary for generating test data.

[0164] "Infrastructure" refers to physical and virtual computing resources, including servers and networks.

[0165] A "development environment" is the software and hardware setup used to generate and verify test data.

[0166] "Used components" are software parts such as algorithms and databases used when generating test data.

[0167] "Simulation data" is a type of test data generated to simulate the behavior of an autonomous vehicle.

[0168] "Parameters" are input values ​​and settings required when generating simulation data.

[0169] "Weather conditions" refers to the weather conditions reproduced within the simulation.

[0170] "Traffic volume" refers to the density and flow of traffic reproduced within the simulation.

[0171] "Verification" is the process of verifying whether the generated test data properly meets the specified conditions.

[0172] "Data format" refers to the particular form or structure in which test data is stored.

[0173] System Overview

[0174] This invention is a system for efficiently generating, verifying, and providing simulation data required for the development and testing of autonomous vehicles. The system is primarily composed of a server, a user terminal, and an interface for inputting various parameters.

[0175] Program processing description

[0176] The server receives and analyzes input data from users requesting test data generation. Based on this input data, the server generates simulation data for autonomous vehicles, taking into account the infrastructure, development environment, and components used. The generated data is based on simulation parameters such as weather conditions and traffic volume. The server also has a means of internally validating this data and correcting it if necessary. The validated data is provided in the data format specified by the user.

[0177] The server uses a programming language such as Python 3.x to implement a generation algorithm. This algorithm references past test data and data patterns to generate new data. To verify the accuracy of the generated data, the system also has a process for comparing it with past test data and standard settings.

[0178] Specific examples

[0179] For example, a user can input the following simulation parameters from a smartphone or PC:

[0180] Number of vehicles: 10

[0181] Route: Urban area

[0182] Weather conditions: Sunny

[0183] Traffic volume: Heavy

[0184] Simulation time: 60 minutes

[0185] The user inputs this information and requests test data generation. The server then receives this request, analyzes the input data, and generates simulation data. The generated data includes the location, speed, and event information of multiple vehicles based on weather conditions and traffic volume. After the validation process, the user can download the data in a specified format (e.g., CSV or JSON).

[0186] Prompt Sentence Examples

[0187] Entering the following prompt statement will generate simulation data based on the specified parameters:

[0188] generate_simulation_data(vehicle_count=10, route="urban", weather="sunny", traffic="heavy", duration=60)

[0189] This allows users to efficiently generate test data and facilitate the development and testing of autonomous vehicles.

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

[0191] Step 1:

[0192] The user inputs a test data generation request. In this step, the user inputs simulation parameters such as the number of vehicles, driving route, weather conditions, traffic volume, and simulation time from a smartphone or PC and sends them to the system. The specific parameters are sent to the server as input data.

[0193] Step 2:

[0194] The server receives and parses input data from the user. The server parses the received data and checks the data structure. This ensures that the input parameters are in the correct format and converts them into a form suitable for internal parsing processing. The parsing results in well-formed parameters that are used to generate subsequent data.

[0195] Step 3:

[0196] The server generates test data based on the infrastructure, development environment, and components used. The server uses the analyzed parameters to generate new simulation data while referencing past test data and data patterns. Specifically, it generates vehicle position, speed, event information, etc. randomly and according to specified conditions. The analyzed parameters are used as input, and simulation data is obtained as output.

[0197] Step 4:

[0198] Validate the generated test data and correct it if necessary. The server internally validates the generated test data to ensure it meets the specified conditions. For example, it checks weather conditions, traffic volume, and data distribution within a specified period. If any inconsistencies are found, the relevant parts are regenerated or corrected. At this step, validated data is obtained.

[0199] Step 5:

[0200] The validated test data is converted into a specific data format and provided to the user. The server converts the validated data into a format specified by the user (e.g., CSV, JSON) and provides it in a downloadable format. The validated data is used as input, and a data file is obtained as output and provided to the user.

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

[0202] This invention is a system that automatically generates test data to be used in the development and testing of new services, and recognizes user emotions during the process and reflects them in the data generation. Below, we will explain the program processing and specific examples of this system in natural language.

[0203] System Overview

[0204] The user requests test data generation, and the server automatically generates appropriate test data based on that request. The generated data is then verified and corrected, and finally provided to the user. By combining it with an emotion engine, the system analyzes the user's emotions and reflects the results in the generation of test data. This further streamlines the test data generation process, providing data that meets the user's needs and status.

[0205] User inputs test data generation request

[0206] Users access the system through a browser or a dedicated application and enter the required information using the test data generation form, including the number of initial users, number of products, number of orders, and other specific conditions. After completing the input, the user submits a generation request.

[0207] The server receives and parses the request

[0208] When the server receives a request from a user, it analyzes the input data. Based on the analysis, it determines what kind of test data is needed and sets the corresponding generation conditions. For example, in the case of product data, information such as category, price range, and inventory quantity is set.

[0209] Emotion recognition by emotion engine

[0210] The server is equipped with an emotion engine that analyzes emotions from the data and communication content entered by the user. For example, if the user is feeling stressed or relieved, the emotion engine analyzes the state and feeds the results back to the server.

[0211] The server generates the test data

[0212] The server automatically generates test data, taking into account the infrastructure, development environment, and components used, and also referring to feedback from the emotion engine. The server uses past test data and stored data patterns to apply a generative algorithm to create new data, including user data, product data, and order data.

[0213] Server validates and corrects generated data

[0214] The generated test data is internally verified via the server. During the verification process, the data is checked to see if it meets specified conditions and is consistent. If necessary, the data is corrected or regenerated. For example, it is checked to see if the generated order data is properly distributed within a specific period.

[0215] The server provides the test data

[0216] Once the verification is complete, the test data is converted into an appropriate format (e.g., CSV or JSON) by the server and provided to the user. Users can then download this data and introduce it into their own test environment, facilitating the development and testing of new services.

[0217] Specific examples

[0218] For example, suppose you are developing a new online shopping system and a user enters the following information:

[0219] Initial number of users: 1000

[0220] Number of products: 500

[0221] Order quantity: 3000

[0222] Percentage of specific product categories: 20%

[0223] Test period: 1 month

[0224] Based on this information, the server generates random user data, product data, and order data that meets the specified conditions. The generated data undergoes an internal verification process before being provided to the user. Specifically, the server checks whether the generated order data is evenly distributed within the specified one-month period, whether a specific product category accounts for 20% of all products, etc.

[0225] Furthermore, the emotion engine can be used to analyze the user's emotions, and flexible responses can be made according to the user's condition, such as simplifying the test data generation process if the user's stress level is high. In this way, users can develop and test online shopping systems efficiently and comfortably.

[0226] The processing flow will be explained below.

[0227] Step 1:

[0228] A user logs into the system via a browser or a dedicated application. The server authenticates the user and grants access.

[0229] Step 2:

[0230] The user enters the required information using the test data generation form, including the initial number of users, number of products, number of orders, and specific test conditions (e.g., category, period), confirms the input, and presses the submit button.

[0231] Step 3:

[0232] The server receives the data sent by the user as an HTTP request, analyzes the request parameters, and extracts the basic information necessary to generate test data.

[0233] Step 4:

[0234] The server activates the emotion engine, which recognizes emotions from the user's input data and communication content. The emotion engine analyzes the user's input speed and input content to generate emotion data.

[0235] Step 5:

[0236] The server receives feedback from the emotion engine and analyzes the user's emotional state. For example, if the user is feeling stressed, it will take appropriate measures such as relaxing the corresponding generation conditions.

[0237] Step 6:

[0238] The server sets the test data generation conditions based on the input data and feedback from the emotion engine, including the user data generation parameters, product data conditions, and order data distribution.

[0239] Step 7:

[0240] The server references past test data and stored data patterns to prepare algorithms for generating new test data, using specific algorithms and templates.

[0241] Step 8:

[0242] The server generates new test data based on the generation conditions. For example, the initial user data consists of a randomly generated username, email address, and registration date.

[0243] Step 9:

[0244] The generated test data is temporarily stored in storage, and the data is converted to formats such as JSON, CSV, SQL dump, etc. as needed.

[0245] Step 10:

[0246] The server initiates an internal validation of the generated data, checking whether it meets specified conditions and whether the data is consistent, for example, whether the order data is evenly distributed within a certain period of time.

[0247] Step 11:

[0248] If any problems are found during the validation process, the server will either regenerate the portion or apply an appropriate correction algorithm to correct the data.

[0249] Step 12:

[0250] The server converts the validated and corrected data into a final format, for example, exporting the data in CSV format and generating a download link.

[0251] Step 13:

[0252] Users download the test data via the provided link, and once the download is complete, they introduce the data into their own test environment.

[0253] Step 14:

[0254] Tests are performed on systems and services under development using test data acquired by the user. The test execution results are analyzed and feedback is provided to the system and data as needed. This process improves the quality of test data and maximizes test efficiency.

[0255] Through this series of steps, users can efficiently generate, introduce, and test test data for new services. Furthermore, the emotion engine enables data generation that takes into account the user's emotional state, providing a more flexible and user-friendly testing environment.

[0256] Example 2

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

[0258] Conventional test data generation systems generate data based on a fixed algorithm without considering the user's emotions, which can lead to problems such as users feeling stressed or being unable to flexibly respond to special requests. Furthermore, when inconsistencies occur in the generated data, the correction process is complicated, making it inefficient for users.

[0259] The specification process by the specification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for the user to input a test data generation request, a means for the server to receive and analyze the input data from the user, a means for analyzing the user's emotions using an emotion engine built into the server, a means for the server to generate test data based on the results of the emotion analysis, a means for the server to verify the generated data and correct it as necessary, and a means for the server to provide the verified test data to the user. This enables flexible test data generation that takes user emotions into consideration and also enables inconsistencies in the generated data to be efficiently corrected.

[0260] "User" refers to a person who accesses the system and inputs a test data generation request.

[0261] "Server" refers to a device or system that receives and analyzes input data from a user.

[0262] An "emotion engine" refers to software or algorithms for analyzing emotions from user input data and communication content.

[0263] "Test Data" refers to data automatically generated by the system and used for testing or examination based on user-specified conditions.

[0264] "Data generation request" refers to information or a request that a user inputs to the system to request the creation of test data.

[0265] "Verification" refers to the process of verifying that the generated test data meets specified conditions and is free of inconsistencies.

[0266] "Correction" refers to the act of regenerating or revising inconsistencies or inappropriate parts found during the verification process.

[0267] "Providing" refers to the act of the server providing the verified test data to the user in a downloadable form or the like.

[0268] "Data format" refers to the format in which the generated test data is stored or provided (e.g., CSV, JSON).

[0269] This invention relates to a system in which a server automatically generates test data based on a user's test data generation request. In particular, this system uses an emotion engine to analyze the user's emotions and reflects the results in the generation of test data, thereby achieving more flexible and efficient data generation. The system of the present invention is implemented as follows.

[0270] Users access the system using a browser or a dedicated application and enter the necessary information via a test data generation form. Input items include the number of initial users, number of products, number of orders, and other specific conditions. This allows users to set detailed specifications and conditions for the test data.

[0271] When the server receives a data generation request from a user, it begins analyzing the input data. Specifically, it determines what kind of test data is needed based on the analysis and moves on to the stage of setting conditions. At this point, the server uses an emotion engine to analyze emotions from the data and communication content entered by the user. For example, if the user is feeling stressed, it analyzes that state and provides feedback.

[0272] Based on the feedback from the emotion engine, the server generates test data. Specifically, the server references past test data and stored data patterns and applies a generation algorithm to create new data. This includes user data, product data, order data, and other appropriate data based on user requests.

[0273] The generated test data is then internally validated via the server. This checks whether the data meets the specified conditions and is consistent. If necessary, the data is corrected or regenerated. Finally, once validation is complete, the server converts the test data into an appropriate format (e.g., CSV or JSON) and provides it to the user.

[0274] As a concrete example, consider the case of developing a new online shopping system. Suppose a user enters information such as an initial number of users of 1,000, number of products of 500, number of orders of 3,000, a proportion of a specific product category of 20%, and a one-month trial period. Based on this information, the server generates user data, product data, and order data that is random but meets the specified conditions. The generated data undergoes an internal validation process before being provided to the user. For example, the server checks whether the generated order data is evenly distributed within the specified one-month period, and whether a specific product category accounts for 20% of all products.

[0275] By analyzing the user's emotions using the emotion engine, the test data generation process can be simplified and made more efficient when the user is under stress, allowing users to develop and test online shopping systems efficiently and comfortably.

[0276] Example prompt sentence:

[0277] Generate the following test data for your system:

[0278] Initial number of users: 1000

[0279] Number of products: 500

[0280] Order quantity: 3000

[0281] Percentage of specific product categories: 20%

[0282] Test period: 1 month

[0283] Adjust your data generation process based on user sentiment.

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

[0285] Step 1:

[0286] User inputs test data generation request

[0287] Input: The user accesses the test data generation form through a browser or a dedicated application and inputs the required information (e.g., number of initial users, number of products, number of orders, specific conditions).

[0288] Operation: The user confirms the input and presses the button to send the "generation request."

[0289] Output: Input data from the user is sent to the server.

[0290] Step 2:

[0291] The server receives and parses the request

[0292] Input: Test data generation request sent by the user.

[0293] Operation: The server receives a user request and analyzes the input data. Based on the analysis, it determines what test data is needed. For example, it sets conditions for generating user data based on the initial number of users.

[0294] Output: Set the required test data conditions (e.g. number of users, number of products, number of orders).

[0295] Step 3:

[0296] Emotional Engine Activation

[0297] Input: Data entered and communications made by users.

[0298] How it works: The emotion engine built into the server analyzes the user's input data and communication content to determine the user's emotional state. For example, it calculates an emotion score from the input content and evaluates whether the user is feeling stressed.

[0299] Output: The user's emotional state as a result of the analysis (e.g., stress level, relief level).

[0300] Step 4:

[0301] The server generates the test data

[0302] Input: The required test data conditions and the emotional state obtained from the emotion engine.

[0303] Operation: The server references feedback from the emotion engine and applies the test data generation algorithm to create data. It uses past test data and data patterns to generate user data, product data, and order data. For example, it generates product data for 1,000 users.

[0304] Output: The generated test data.

[0305] Step 5:

[0306] Server validates and corrects generated data

[0307] Input: Generated test data.

[0308] Operation: The server performs internal validation of the generated test data. It checks that the data meets specified conditions and is free of internal inconsistencies. For example, it verifies that the order distribution is even or that the proportions of specific product categories are correct. It corrects or regenerates the data as needed.

[0309] Output: Verified test data.

[0310] Step 6:

[0311] The server provides the test data

[0312] Input: Validated test data.

[0313] How it works: The server converts the test data after validation into a specific format (e.g., CSV, JSON), then provides the user with a link to download the data.

[0314] Output: Test data provided in a format that can be downloaded by the user.

[0315] Step 7:

[0316] Users can download and use test data

[0317] Input: Test data download link provided by the server.

[0318] Operation: A user clicks the download link to download the test data. After that, the downloaded test data is introduced into the user's test environment to develop and test a new service.

[0319] Output: Test data introduced into the test environment and the progress of service development and testing based on it.

[0320] (Application example 2)

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

[0322] Conventional test data generation systems generate data without considering the user's emotions or stress level, making it difficult to flexibly respond to the user's condition.In addition, in manufacturing environments, there is a need to automate the process of quickly and efficiently generating test data and reliably verifying it.

[0323] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: a means for the user to input a test data generation request; a means for the server to receive and analyze input data from the user; a means for the server to recognize and analyze the user's emotions in real time; a means for the server to adjust the test data generation algorithm based on the recognized emotions; a means for the server to generate test data based on the infrastructure, development environment, and components used by the server; a means for the server to verify the generated data and correct it as necessary; and a means for the server to provide the verified test data to the user. This enables the generation of appropriate test data according to the user's emotions and state, and fast and reliable data verification and correction.

[0324] A "user" is a person or organization that utilizes the system to enter test data generation requests.

[0325] A "server" is a device or system that receives and analyzes input data from a user.

[0326] "Input data" refers to information provided by a user when making a test data generation request.

[0327] "Emotion recognition" is the process of detecting and analyzing a user's real-time emotional state.

[0328] A "test data generation algorithm" is a set of computational steps for generating test data based on input data and sentiment analysis results.

[0329] "Infrastructure" refers to the physical and logical environment and facilities required for data generation.

[0330] "Development environment" refers to the setup and configuration of the software and hardware used to generate test data.

[0331] "Used components" are various modules and plug-ins used to generate test data.

[0332] "Verification" is the process of verifying that the generated test data meets specified conditions.

[0333] "Correction" is the process of regenerating or changing data that is found to be inconsistent as a result of verification.

[0334] "Test data" refers to a group of data generated to meet specific conditions and used for developing and testing new services and functions of the system.

[0335] In a system for implementing this invention, a user inputs a test data generation request, a server receives and analyzes it, recognizes the user's emotions, and generates data while adjusting the test data generation algorithm. The server also verifies the generated data, corrects any inconsistencies, and finally provides the verified data to the user.

[0336] System configuration

[0337] 1. User Device

[0338] A user uses a wearable device, such as smart glasses, to input a test data generation request.

[0339] The device uses a camera and microphone to recognize the user's emotions in real time.

[0340] 2. Server

[0341] Receives and analyzes data and emotional information input from the user's device.

[0342] The emotional engine is used to analyze the user's emotional state, and the results are reflected in the test data generation algorithm.

[0343] New data is generated based on past test data and data patterns.

[0344] Program processing

[0345] When a user inputs a test data generation request through the smart glasses, the camera and microphone are used to recognize the user's emotions in real time. The emotion engine analyzes the user's emotional state (e.g., stress, relief, etc.) from their facial expressions and voice. The analyzed emotional data is fed back to the generation algorithm, which adjusts the test data generation process according to the user's state. For example, if the user is feeling stressed, the amount of data generated will be reduced, reducing the burden on the user.

[0346] The server generates test data based on this information and performs validation on the cloud. The validation process checks whether the data meets the specified conditions and is consistent, and if there are any inconsistencies, the data is regenerated or corrected. Finally, the validated test data is converted into an appropriate format (e.g., CSV, JSON) and provided to the user.

[0347] Hardware and software used

[0348] Smart glasses: Used by users to input test data generation requests and recognize emotions. Examples include Google Glass® and Vuzix M300.

[0349] Emotion engine: Used to analyze the user's facial expressions and voice. External libraries such as EmotionRecognizer are used.

[0350] Cloud server: Infrastructure for generating, verifying, and correcting data. Possible examples include AWS, Microsoft® Azure®, etc. for data storage and analysis processing.

[0351] Specific examples

[0352] For example, when prototyping a new part (Part A) on a production line, an operator uses smart glasses to input the following information:

[0353] Product Type: Part A

[0354] Planned production volume: 1000

[0355] Deadline:2023-12-31

[0356] If the user's emotion is recognized as stress, the server adjusts the generation amount to 800 and verifies and corrects the data on the cloud.

[0357] Prompt Sentence Examples

[0358] Example prompt for generative AI model:

[0359] "Please enter the amount of data generated for the manufacturing test of new part A in the factory. After the input is complete, we will analyze the operator's sentiment and adjust the amount generated."

[0360] This makes it possible to generate appropriate test data according to the user's emotions and state, and to verify and correct the data quickly and reliably.

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

[0362] Step 1:

[0363] The user inputs a test data generation request through the smart glasses. Using the smart glasses interface, the user inputs the required information, such as product type, planned production volume, and deadline. The input data is encoded in JSON format and sent to the server. The input data format is as follows:

[0364] Product Type: String (e.g., Part A)

[0365] Planned production volume: Integer (e.g., 1000)

[0366] Deadline: Date (e.g. 2023-12-31)

[0367] Step 2:

[0368] The smart glasses use a camera and microphone to recognize the user's emotional state in real time. The smart glasses use the collected video and audio data to send the data to the EmotionRecognizer (emotion engine). The input is the user's facial expression and audio data, and the output is the emotional classification result (e.g., stress, relief, etc.).

[0369] Step 3:

[0370] The server receives and analyzes input data and emotion data from users. Based on the input data, it determines the test data generation conditions (product type, planned production volume, deadline, etc.) and adjusts the generation algorithm based on the emotion data. For example, if the emotion data indicates "stress," it reduces the planned production volume (e.g., change it to 800).

[0371] Step 4:

[0372] The server references past test data and data patterns and generates new test data based on them. Based on input data (product type, planned production volume, deadline) and sentiment data (adjusted planned production volume), a generation algorithm is applied to create new data. For example, test data for part A is randomly generated to include a total of 800 parts.

[0373] Step 5:

[0374] The server internally verifies the generated data. It checks whether the generated test data meets the specified conditions (product type, planned production volume, deadline) and checks for inconsistencies. If necessary, it regenerates or corrects inconsistencies. For example, it verifies whether the data is properly distributed within the deadline.

[0375] Step 6:

[0376] The server converts the validated test data into an appropriate format (e.g., CSV or JSON) and provides it to the user. After the validated data has been converted, it is sent to the user's device (smart glasses or other device) via the cloud server. The user can then download the provided data and introduce it into their own test environment.

[0377] In this way, the present invention realizes the generation of appropriate test data according to the user's emotions and state, and the rapid and reliable verification and correction of the data.

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

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

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

[0381] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0394] The present invention is a system that automatically generates and efficiently provides test data required for preliminary testing and verification when developing a new service. Below, the program processing and specific examples of this system are explained in natural language.

[0395] System Overview

[0396] The user requests test data generation, and the server automatically generates the appropriate test data based on that request. The generated data is then verified and corrected, and finally provided to the user. This streamlines the test data generation process, significantly reducing the time and effort required for the development and testing cycle.

[0397] User inputs test data generation request

[0398] The user accesses the system through a browser or a dedicated application and enters the required information using the test data generation form, including, for example, the number of initial users, the number of products, the number of orders, and other specific conditions. After completing the input, the user submits a generation request.

[0399] The server receives and parses the request

[0400] When the server receives a request from a user, it analyzes the input data. Based on the analysis, it determines what kind of test data is needed and sets the corresponding generation conditions. For example, in the case of product data, information such as category, price range, and inventory quantity is set.

[0401] The server generates the test data

[0402] The server automatically generates test data, taking into account the infrastructure, development environment, and components being used. The server references past test data and stored data patterns and uses a generation algorithm to create new data. This data includes user data, product data, order data, and more.

[0403] Server validates and corrects generated data

[0404] The generated test data is internally verified via the server. During the verification process, the data is checked to see if it meets specified conditions and is consistent. If necessary, the data is corrected or regenerated. For example, it is checked to see if the generated order data is properly distributed within a specific period.

[0405] The server provides the test data

[0406] Once the verification is complete, the test data is converted into an appropriate format (e.g., CSV or JSON) by the server and provided to the user. Users can then download this data and introduce it into their own test environment, facilitating the development and testing of new services.

[0407] Specific examples

[0408] For example, suppose you are developing a new online shopping system and a user enters the following information:

[0409] Initial number of users: 1000

[0410] Number of products: 500

[0411] Order quantity: 3000

[0412] Percentage of specific product categories: 20%

[0413] Test period: 1 month

[0414] Based on this information, the server generates random user data, product data, and order data that meets specified conditions. The generated data undergoes an internal validation process before being provided to the user. Specifically, the server checks whether the generated order data is evenly distributed within a specified one-month period, whether a specific product category accounts for 20% of all products, and so on. Using this test data, users can efficiently develop and test their online shopping systems.

[0415] The processing flow will be explained below.

[0416] Step 1:

[0417] A user logs into the system via a browser or a dedicated application. The server authenticates the user and grants access.

[0418] Step 2:

[0419] The user enters the required information into the test data generation form, including the number of initial users, number of products, number of orders, specific conditions (e.g., specific categories or period), etc. The user confirms the input and presses the submit button.

[0420] Step 3:

[0421] The server receives the data sent by the user as an HTTP request, analyzes the request parameters, and extracts the basic information necessary to generate test data.

[0422] Step 4:

[0423] The server analyzes the input data and determines the type of test data required (user data, product data, order data, etc.) and the conditions for generating it.

[0424] Step 5:

[0425] The server references past test data and stored data patterns and prepares an algorithm for generating new test data based on this.

[0426] Step 6:

[0427] The server generates new test data based on the generation conditions. For example, for initial user data, a random username is generated, along with an email address and registration date.

[0428] Step 7:

[0429] The generated test data is temporarily stored in storage, and the data is converted to formats such as JSON, CSV, SQL dump, etc. as needed.

[0430] Step 8:

[0431] The server starts an internal validation of the generated data, checking whether it meets the specified conditions and whether the data is consistent.

[0432] Step 9:

[0433] If any problems are found during the validation process, the server will either regenerate the portion or apply an appropriate correction algorithm to correct the data.

[0434] Step 10:

[0435] The server converts the validated and corrected data into a final format, for example, exporting the data in CSV format and generating a download link.

[0436] Step 11:

[0437] Users download the test data via the provided link, and once the download is complete, they introduce the data into their own test environment.

[0438] Step 12:

[0439] Tests are performed on systems and services under development using test data acquired by the user. The test results are analyzed and feedback is provided to the system and data as needed.

[0440] Through this series of steps, users can efficiently generate, introduce, and test test data for new services.

[0441] Example 1

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

[0443] Conventional test data generation systems require manual data generation and verification, resulting in inefficiency and time-consuming labor. Furthermore, generating test data based on specific conditions or time periods can be difficult, potentially delaying the development and testing cycle of new services. The present invention aims to solve these problems by streamlining and automating the test data generation process.

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

[0445] In this invention, the server includes: means for inputting a prompt sentence using a natural language processing model when a user requests test data generation, and specifying the requirements for test data generation; means for the server to refer to past test data and stored data patterns and generate new test data based thereon; and means for verifying whether the generated test data is appropriately distributed within a set period and satisfies specific category conditions. This enables efficient and automatic generation of test data, enabling the development and testing cycle of new services to proceed quickly.

[0446] "User" means an end user who accesses the system and enters a request for test data generation.

[0447] A "server" is a central computer system that receives requests from users, analyzes them, generates data, validates them, and provides them.

[0448] A "test data generation request" is a set of information and conditions that a user inputs to request the generation of test data through the system.

[0449] "Infrastructure" refers to the hardware and software infrastructure required for a system to operate.

[0450] "Development Environment" refers to the set of software and tools used for developing, testing, and operating a System.

[0451] "Used components" refer to software libraries and modules that the system uses when generating test data.

[0452] A "natural language processing model" is an artificial intelligence model that analyzes and understands prompts entered by users.

[0453] A "prompt sentence" is a sentence that a user inputs in natural language when specifying conditions or requirements for generating test data.

[0454] "Past test data" refers to a collection of previously generated test data that is used as a reference for generating new data.

[0455] "Data patterns" refer to recurring trends or rules found in past test data.

[0456] "Verification measures" refer to the processes and tools used to verify that the generated test data meets specified conditions.

[0457] "Test data generation requirements" refer to conditions and constraints specified by a user when making a request for test data generation.

[0458] A "specific category condition" is a condition that indicates whether the test data conforms to a specific classification or category.

[0459] A "test period" refers to a specific time range established when test data is generated.

[0460] "Data format" refers to the data format (e.g., CSV, JSON) in which the generated test data is provided to the user.

[0461] This invention is a system that automatically generates and efficiently provides test data required for preliminary testing and verification when developing new services. The main components of this system are users, servers, and terminals. The specific functions and operations of each component are described below.

[0462] User inputs test data generation request

[0463] Users access the system through a browser or a dedicated application. Specifically, they use web browsers such as Google Chrome or Mozilla Firefox, or Windows or iOS apps. Using the test data generation form, users enter the required information (initial number of users, number of products, number of orders, specific conditions, etc.) and submit a generation request. For example, they enter the following information:

[0464] Initial number of users: 1000

[0465] Number of products: 500

[0466] Order quantity: 3000

[0467] Percentage of specific product categories: 20%

[0468] Test period: 1 month

[0469] The user can also specify requirements for test data generation by entering prompt sentences using a natural language processing model.

[0470] The server receives and parses the request

[0471] The server receives user requests through a web server such as Apache or NGINX. The backend system uses programs written in Python or Java to analyze the received data. During this analysis process, specific conditions for generating test data are set based on the information entered by the user. These conditions include the initial number of users, the number of products, the proportion of product categories, and the test period.

[0472] The server generates the test data

[0473] The server automatically generates test data using cloud services such as AWS Lambda and Google Cloud Functions. It uses Python and R libraries (Pandas, NumPy) to execute data generation algorithms. The generated test data includes user data, product data, and order data. As a concrete example, the following prompt statements are used to generate data:

[0474] "To develop a new online shopping system, please generate test data that meets the following conditions:

[0475] Initial number of users: 1000

[0476] Number of products: 500

[0477] Order quantity: 3000

[0478] Percentage of specific product categories: 20%

[0479] Test period: 1 month

[0480] Server validates and corrects generated data

[0481] The generated test data undergoes a validation process on the server. Data consistency is checked using an SQL database (MySQL, PostgreSQL) or a NoSQL database (MongoDB). Specific validation checks include checking for duplicate user IDs, whether the product category ratios are as specified, and whether the order data is evenly distributed within the test period. If any inconsistencies are found, the data is corrected or regenerated.

[0482] The server provides the test data

[0483] Once the validation is complete, the data is converted to CSV or JSON format and provided to the user. This conversion is performed using the Pandas .to_csv() method or the Node.js file system module. Users can obtain the test data via the provided download link and install it into their own development environment.

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

[0485] Step 1:

[0486] User inputs test data generation request

[0487] The user accesses the system through a browser or a dedicated application and enters the necessary information into the test data generation form. This input information includes the initial number of users, number of products, number of orders, and specific conditions (e.g., percentage of specific product categories, test period). After completing the input, the user submits a generation request. The specific operation here is that the user interface is implemented using HTML forms and React.js components.

[0488] Input: Number of initial users, number of products, number of orders, specific conditions

[0489] Output: Generated request data

[0490] Step 2:

[0491] The server receives and parses the request

[0492] The server receives generation requests from users through a web server such as Apache or NGINX. A back-end program written in Python or Java then analyzes the request data. During this analysis process, specific conditions for test data generation are set based on the information entered by the user. Specifically, it determines how the number of products, number of orders, percentage of specific product categories, and test period will be handled.

[0493] Input: Generation request data

[0494] Output: Conditions for generating test data

[0495] Step 3:

[0496] The server generates the test data

[0497] The server automatically generates test data based on the set conditions using cloud services such as AWS Lambda and Google Cloud Functions. It executes data generation algorithms using Python and R libraries (Pandas, NumPy). Specifically, it references past test data and stored data patterns to generate user data, product data, and order data.

[0498] Input: Test data generation conditions

[0499] Output: Generated test data

[0500] Step 4:

[0501] Server validates and corrects generated data

[0502] The generated test data undergoes a validation process on the server. This process uses an SQL database (MySQL, PostgreSQL) or a NoSQL database (MongoDB) to check the data's consistency. Specific validation tasks include checking for duplicate user IDs, whether the product category ratios are as specified, and whether the order data is evenly distributed within the test period. If any inconsistencies are found, the data is corrected or regenerated.

[0503] Input: Generated test data

[0504] Output: Verified test data

[0505] Step 5:

[0506] The server provides the test data

[0507] Once the test data has been validated, it is converted into the appropriate data format (CSV, JSON) by the server. This conversion process uses the Pandas .to_csv() method or the Node.js file system module. Users can then import the test data into their development environment via the provided download link.

[0508] Input: Verified test data

[0509] Output: Test data provided

[0510] (Application example 1)

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

[0512] The development of autonomous vehicles requires the generation and verification of a huge amount of test data, and the manual generation process is extremely time-consuming and labor-intensive. Therefore, there is a need for a method to efficiently generate test data and automate the verification process. It is also important to accurately verify that the generated data meets specified conditions and provide the resulting data in a specific data format.

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

[0514] In this invention, the server includes means for a user to input a test data generation request, means for the server to receive and analyze the input data from the user, means for generating test data based on the infrastructure, development environment, and components used by the server, means for inputting parameters required to generate simulation data for an autonomous vehicle, means for generating test data based on simulation parameters such as weather conditions and traffic volume, means for verifying the generated test data and correcting it as necessary, and means for the server to provide the verified test data to the user. This enables efficient generation of simulation data required for the development of autonomous vehicles and accurate verification and provision of the data.

[0515] A "test data generation request" is a request for specific test data that a user wants the system to generate.

[0516] "Server" is a central computer system that analyzes user input data and generates, verifies, and provides test data.

[0517] "Input data" refers to data provided by a user to a system, and includes information necessary for generating test data.

[0518] "Infrastructure" refers to physical and virtual computing resources, including servers and networks.

[0519] A "development environment" is the software and hardware setup used to generate and verify test data.

[0520] "Used components" are software parts such as algorithms and databases used when generating test data.

[0521] "Simulation data" is a type of test data generated to simulate the behavior of an autonomous vehicle.

[0522] "Parameters" are input values ​​and settings required when generating simulation data.

[0523] "Weather conditions" refers to the weather conditions reproduced within the simulation.

[0524] "Traffic volume" refers to the density and flow of traffic reproduced within the simulation.

[0525] "Verification" is the process of verifying whether the generated test data properly meets the specified conditions.

[0526] "Data format" refers to the particular form or structure in which test data is stored.

[0527] System Overview

[0528] This invention is a system for efficiently generating, verifying, and providing simulation data required for the development and testing of autonomous vehicles. The system is primarily composed of a server, a user terminal, and an interface for inputting various parameters.

[0529] Program processing description

[0530] The server receives and analyzes input data from users requesting test data generation. Based on this input data, the server generates simulation data for autonomous vehicles, taking into account the infrastructure, development environment, and components used. The generated data is based on simulation parameters such as weather conditions and traffic volume. The server also has a means of internally validating this data and correcting it if necessary. The validated data is provided in the data format specified by the user.

[0531] The server uses a programming language such as Python 3.x to implement a generation algorithm. This algorithm references past test data and data patterns to generate new data. To verify the accuracy of the generated data, the system also has a process for comparing it with past test data and standard settings.

[0532] Specific examples

[0533] For example, a user can input the following simulation parameters from a smartphone or PC:

[0534] Number of vehicles: 10

[0535] Route: Urban area

[0536] Weather conditions: Sunny

[0537] Traffic volume: Heavy

[0538] Simulation time: 60 minutes

[0539] The user inputs this information and requests test data generation. The server then receives this request, analyzes the input data, and generates simulation data. The generated data includes the location, speed, and event information of multiple vehicles based on weather conditions and traffic volume. After the validation process, the user can download the data in a specified format (e.g., CSV or JSON).

[0540] Prompt Sentence Examples

[0541] Entering the following prompt statement will generate simulation data based on the specified parameters:

[0542] generate_simulation_data(vehicle_count=10, route="urban", weather="sunny", traffic="heavy", duration=60)

[0543] This allows users to efficiently generate test data and facilitate the development and testing of autonomous vehicles.

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

[0545] Step 1:

[0546] The user inputs a test data generation request. In this step, the user inputs simulation parameters such as the number of vehicles, driving route, weather conditions, traffic volume, and simulation time from a smartphone or PC and sends them to the system. The specific parameters are sent to the server as input data.

[0547] Step 2:

[0548] The server receives and parses input data from the user. The server parses the received data and checks the data structure. This ensures that the input parameters are in the correct format and converts them into a form suitable for internal parsing processing. The parsing results in well-formed parameters that are used to generate subsequent data.

[0549] Step 3:

[0550] The server generates test data based on the infrastructure, development environment, and components used. The server uses the analyzed parameters to generate new simulation data while referencing past test data and data patterns. Specifically, it generates vehicle position, speed, event information, etc. randomly and according to specified conditions. The analyzed parameters are used as input, and simulation data is obtained as output.

[0551] Step 4:

[0552] Validate the generated test data and correct it if necessary. The server internally validates the generated test data to ensure it meets the specified conditions. For example, it checks weather conditions, traffic volume, and data distribution within a specified period. If any inconsistencies are found, the relevant parts are regenerated or corrected. At this step, validated data is obtained.

[0553] Step 5:

[0554] The validated test data is converted into a specific data format and provided to the user. The server converts the validated data into a format specified by the user (e.g., CSV, JSON) and provides it in a downloadable format. The validated data is used as input, and a data file is obtained as output and provided to the user.

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

[0556] This invention is a system that automatically generates test data to be used in the development and testing of new services, and recognizes user emotions during the process and reflects them in the data generation. Below, we will explain the program processing and specific examples of this system in natural language.

[0557] System Overview

[0558] The user requests test data generation, and the server automatically generates appropriate test data based on that request. The generated data is then verified and corrected, and finally provided to the user. By combining it with an emotion engine, the system analyzes the user's emotions and reflects the results in the generation of test data. This further streamlines the test data generation process, providing data that meets the user's needs and status.

[0559] User inputs test data generation request

[0560] Users access the system through a browser or a dedicated application and enter the required information using the test data generation form, including the number of initial users, number of products, number of orders, and other specific conditions. After completing the input, the user submits a generation request.

[0561] The server receives and parses the request

[0562] When the server receives a request from a user, it analyzes the input data. Based on the analysis, it determines what kind of test data is needed and sets the corresponding generation conditions. For example, in the case of product data, information such as category, price range, and inventory quantity is set.

[0563] Emotion recognition by emotion engine

[0564] The server is equipped with an emotion engine that analyzes emotions from the data and communication content entered by the user. For example, if the user is feeling stressed or relieved, the emotion engine analyzes the state and feeds the results back to the server.

[0565] The server generates the test data

[0566] The server automatically generates test data, taking into account the infrastructure, development environment, and components used, and also referring to feedback from the emotion engine. The server uses past test data and stored data patterns to apply a generative algorithm to create new data, including user data, product data, and order data.

[0567] Server validates and corrects generated data

[0568] The generated test data is internally verified via the server. During the verification process, the data is checked to see if it meets specified conditions and is consistent. If necessary, the data is corrected or regenerated. For example, it is checked to see if the generated order data is properly distributed within a specific period.

[0569] The server provides the test data

[0570] Once the verification is complete, the test data is converted into an appropriate format (e.g., CSV or JSON) by the server and provided to the user. Users can then download this data and introduce it into their own test environment, facilitating the development and testing of new services.

[0571] Specific examples

[0572] For example, suppose you are developing a new online shopping system and a user enters the following information:

[0573] Initial number of users: 1000

[0574] Number of products: 500

[0575] Order quantity: 3000

[0576] Percentage of specific product categories: 20%

[0577] Test period: 1 month

[0578] Based on this information, the server generates random user data, product data, and order data that meets the specified conditions. The generated data undergoes an internal verification process before being provided to the user. Specifically, the server checks whether the generated order data is evenly distributed within the specified one-month period, whether a specific product category accounts for 20% of all products, etc.

[0579] Furthermore, the emotion engine can be used to analyze the user's emotions, and flexible responses can be made according to the user's condition, such as simplifying the test data generation process if the user's stress level is high. In this way, users can develop and test online shopping systems efficiently and comfortably.

[0580] The processing flow will be explained below.

[0581] Step 1:

[0582] A user logs into the system via a browser or a dedicated application. The server authenticates the user and grants access.

[0583] Step 2:

[0584] The user enters the required information using the test data generation form, including the initial number of users, number of products, number of orders, and specific test conditions (e.g., category, period), confirms the input, and presses the submit button.

[0585] Step 3:

[0586] The server receives the data sent by the user as an HTTP request, analyzes the request parameters, and extracts the basic information necessary to generate test data.

[0587] Step 4:

[0588] The server activates the emotion engine, which recognizes emotions from the user's input data and communication content. The emotion engine analyzes the user's input speed and input content to generate emotion data.

[0589] Step 5:

[0590] The server receives feedback from the emotion engine and analyzes the user's emotional state. For example, if the user is feeling stressed, it will take appropriate measures such as relaxing the corresponding generation conditions.

[0591] Step 6:

[0592] The server sets the test data generation conditions based on the input data and feedback from the emotion engine, including the user data generation parameters, product data conditions, and order data distribution.

[0593] Step 7:

[0594] The server references past test data and stored data patterns to prepare algorithms for generating new test data, using specific algorithms and templates.

[0595] Step 8:

[0596] The server generates new test data based on the generation conditions. For example, the initial user data consists of a randomly generated username, email address, and registration date.

[0597] Step 9:

[0598] The generated test data is temporarily stored in storage, and the data is converted to formats such as JSON, CSV, SQL dump, etc. as needed.

[0599] Step 10:

[0600] The server initiates an internal validation of the generated data, checking whether it meets specified conditions and whether the data is consistent, for example, whether the order data is evenly distributed within a certain period of time.

[0601] Step 11:

[0602] If any problems are found during the validation process, the server will either regenerate the portion or apply an appropriate correction algorithm to correct the data.

[0603] Step 12:

[0604] The server converts the validated and corrected data into a final format, for example, exporting the data in CSV format and generating a download link.

[0605] Step 13:

[0606] Users download the test data via the provided link, and once the download is complete, they introduce the data into their own test environment.

[0607] Step 14:

[0608] Tests are performed on systems and services under development using test data acquired by the user. The test execution results are analyzed and feedback is provided to the system and data as needed. This process improves the quality of test data and maximizes test efficiency.

[0609] Through this series of steps, users can efficiently generate, introduce, and test test data for new services. Furthermore, the emotion engine enables data generation that takes into account the user's emotional state, providing a more flexible and user-friendly testing environment.

[0610] Example 2

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

[0612] Conventional test data generation systems generate data based on a fixed algorithm without considering the user's emotions, which can lead to problems such as users feeling stressed or being unable to flexibly respond to special requests. Furthermore, when inconsistencies occur in the generated data, the correction process is complicated, making it inefficient for users.

[0613] The specification process by the specification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for the user to input a test data generation request, a means for the server to receive and analyze the input data from the user, a means for analyzing the user's emotions using an emotion engine built into the server, a means for the server to generate test data based on the results of the emotion analysis, a means for the server to verify the generated data and correct it as necessary, and a means for the server to provide the verified test data to the user. This enables flexible test data generation that takes user emotions into consideration and also enables inconsistencies in the generated data to be efficiently corrected.

[0614] "User" refers to a person who accesses the system and inputs a test data generation request.

[0615] "Server" refers to a device or system that receives and analyzes input data from a user.

[0616] An "emotion engine" refers to software or algorithms for analyzing emotions from user input data and communication content.

[0617] "Test Data" refers to data automatically generated by the system and used for testing or examination based on user-specified conditions.

[0618] "Data generation request" refers to information or a request that a user inputs to the system to request the creation of test data.

[0619] "Verification" refers to the process of verifying that the generated test data meets specified conditions and is free of inconsistencies.

[0620] "Correction" refers to the act of regenerating or revising inconsistencies or inappropriate parts found during the verification process.

[0621] "Providing" refers to the act of the server providing the verified test data to the user in a downloadable form or the like.

[0622] "Data format" refers to the format in which the generated test data is stored or provided (e.g., CSV, JSON).

[0623] This invention relates to a system in which a server automatically generates test data based on a user's test data generation request. In particular, this system uses an emotion engine to analyze the user's emotions and reflects the results in the generation of test data, thereby achieving more flexible and efficient data generation. The system of the present invention is implemented as follows.

[0624] Users access the system using a browser or a dedicated application and enter the necessary information via a test data generation form. Input items include the number of initial users, number of products, number of orders, and other specific conditions. This allows users to set detailed specifications and conditions for the test data.

[0625] When the server receives a data generation request from a user, it begins analyzing the input data. Specifically, it determines what kind of test data is needed based on the analysis and moves on to the stage of setting conditions. At this point, the server uses an emotion engine to analyze emotions from the data and communication content entered by the user. For example, if the user is feeling stressed, it analyzes that state and provides feedback.

[0626] Based on the feedback from the emotion engine, the server generates test data. Specifically, the server references past test data and stored data patterns and applies a generation algorithm to create new data. This includes user data, product data, order data, and other appropriate data based on user requests.

[0627] The generated test data is then internally validated via the server. This checks whether the data meets the specified conditions and is consistent. If necessary, the data is corrected or regenerated. Finally, once validation is complete, the server converts the test data into an appropriate format (e.g., CSV or JSON) and provides it to the user.

[0628] As a concrete example, consider the case of developing a new online shopping system. Suppose a user enters information such as an initial number of users of 1,000, number of products of 500, number of orders of 3,000, a proportion of a specific product category of 20%, and a one-month trial period. Based on this information, the server generates user data, product data, and order data that is random but meets the specified conditions. The generated data undergoes an internal validation process before being provided to the user. For example, the server checks whether the generated order data is evenly distributed within the specified one-month period, and whether a specific product category accounts for 20% of all products.

[0629] By analyzing the user's emotions using the emotion engine, the test data generation process can be simplified and made more efficient when the user is under stress, allowing users to develop and test online shopping systems efficiently and comfortably.

[0630] Example prompt sentence:

[0631] Generate the following test data for your system:

[0632] Initial number of users: 1000

[0633] Number of products: 500

[0634] Order quantity: 3000

[0635] Percentage of specific product categories: 20%

[0636] Test period: 1 month

[0637] Adjust your data generation process based on user sentiment.

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

[0639] Step 1:

[0640] User inputs test data generation request

[0641] Input: The user accesses the test data generation form through a browser or a dedicated application and inputs the required information (e.g., number of initial users, number of products, number of orders, specific conditions).

[0642] Operation: The user confirms the input and presses the button to send the "generation request."

[0643] Output: Input data from the user is sent to the server.

[0644] Step 2:

[0645] The server receives and parses the request

[0646] Input: Test data generation request sent by the user.

[0647] Operation: The server receives a user request and analyzes the input data. Based on the analysis, it determines what test data is needed. For example, it sets conditions for generating user data based on the initial number of users.

[0648] Output: Set the required test data conditions (e.g. number of users, number of products, number of orders).

[0649] Step 3:

[0650] Emotional Engine Activation

[0651] Input: Data entered and communications made by users.

[0652] How it works: The emotion engine built into the server analyzes the user's input data and communication content to determine the user's emotional state. For example, it calculates an emotion score from the input content and evaluates whether the user is feeling stressed.

[0653] Output: The user's emotional state as a result of the analysis (e.g., stress level, relief level).

[0654] Step 4:

[0655] The server generates the test data

[0656] Input: The required test data conditions and the emotional state obtained from the emotion engine.

[0657] Operation: The server references feedback from the emotion engine and applies the test data generation algorithm to create data. It uses past test data and data patterns to generate user data, product data, and order data. For example, it generates product data for 1,000 users.

[0658] Output: The generated test data.

[0659] Step 5:

[0660] Server validates and corrects generated data

[0661] Input: Generated test data.

[0662] Operation: The server performs internal validation of the generated test data. It checks that the data meets specified conditions and is free of internal inconsistencies. For example, it verifies that the order distribution is even or that the proportions of specific product categories are correct. It corrects or regenerates the data as needed.

[0663] Output: Verified test data.

[0664] Step 6:

[0665] The server provides the test data

[0666] Input: Validated test data.

[0667] How it works: The server converts the test data after validation into a specific format (e.g., CSV, JSON), then provides the user with a link to download the data.

[0668] Output: Test data provided in a format that can be downloaded by the user.

[0669] Step 7:

[0670] Users can download and use test data

[0671] Input: Test data download link provided by the server.

[0672] Operation: A user clicks the download link to download the test data. After that, the downloaded test data is introduced into the user's test environment to develop and test a new service.

[0673] Output: Test data introduced into the test environment and the progress of service development and testing based on it.

[0674] (Application example 2)

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

[0676] Conventional test data generation systems generate data without considering the user's emotions or stress level, making it difficult to flexibly respond to the user's condition.In addition, in manufacturing environments, there is a need to automate the process of quickly and efficiently generating test data and reliably verifying it.

[0677] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: a means for the user to input a test data generation request; a means for the server to receive and analyze input data from the user; a means for the server to recognize and analyze the user's emotions in real time; a means for the server to adjust the test data generation algorithm based on the recognized emotions; a means for the server to generate test data based on the infrastructure, development environment, and components used by the server; a means for the server to verify the generated data and correct it as necessary; and a means for the server to provide the verified test data to the user. This enables the generation of appropriate test data according to the user's emotions and state, and fast and reliable data verification and correction.

[0678] A "user" is a person or organization that utilizes the system to enter test data generation requests.

[0679] A "server" is a device or system that receives and analyzes input data from a user.

[0680] "Input data" refers to information provided by a user when making a test data generation request.

[0681] "Emotion recognition" is the process of detecting and analyzing a user's real-time emotional state.

[0682] A "test data generation algorithm" is a set of computational steps for generating test data based on input data and sentiment analysis results.

[0683] "Infrastructure" refers to the physical and logical environment and facilities required for data generation.

[0684] "Development environment" refers to the setup and configuration of the software and hardware used to generate test data.

[0685] "Used components" are various modules and plug-ins used to generate test data.

[0686] "Verification" is the process of verifying that the generated test data meets specified conditions.

[0687] "Correction" is the process of regenerating or changing data that is found to be inconsistent as a result of verification.

[0688] "Test data" refers to a group of data generated to meet specific conditions and used for developing and testing new services and functions of the system.

[0689] In a system for implementing this invention, a user inputs a test data generation request, a server receives and analyzes it, recognizes the user's emotions, and generates data while adjusting the test data generation algorithm. The server also verifies the generated data, corrects any inconsistencies, and finally provides the verified data to the user.

[0690] System configuration

[0691] 1. User Device

[0692] A user uses a wearable device, such as smart glasses, to input a test data generation request.

[0693] The device uses a camera and microphone to recognize the user's emotions in real time.

[0694] 2. Server

[0695] Receives and analyzes data and emotional information input from the user's device.

[0696] The emotional engine is used to analyze the user's emotional state, and the results are reflected in the test data generation algorithm.

[0697] New data is generated based on past test data and data patterns.

[0698] Program processing

[0699] When a user inputs a test data generation request through the smart glasses, the camera and microphone are used to recognize the user's emotions in real time. The emotion engine analyzes the user's emotional state (e.g., stress, relief, etc.) from their facial expressions and voice. The analyzed emotional data is fed back to the generation algorithm, which adjusts the test data generation process according to the user's state. For example, if the user is feeling stressed, the amount of data generated will be reduced, reducing the burden on the user.

[0700] The server generates test data based on this information and performs validation on the cloud. The validation process checks whether the data meets the specified conditions and is consistent, and if there are any inconsistencies, the data is regenerated or corrected. Finally, the validated test data is converted into an appropriate format (e.g., CSV, JSON) and provided to the user.

[0701] Hardware and software used

[0702] Smart glasses: Used by users to input test data generation requests and recognize emotions. Examples include Google Glass and Vuzix M300.

[0703] Emotion engine: Used to analyze the user's facial expressions and voice. External libraries such as EmotionRecognizer are used.

[0704] Cloud server: Infrastructure for generating, verifying, and correcting data. AWS, Microsoft Azure, etc. can be considered for data storage and analysis processing.

[0705] Specific examples

[0706] For example, when prototyping a new part (Part A) on a production line, an operator uses smart glasses to input the following information:

[0707] Product Type: Part A

[0708] Planned production volume: 1000

[0709] Deadline:2023-12-31

[0710] If the user's emotion is recognized as stress, the server adjusts the generation amount to 800 and verifies and corrects the data on the cloud.

[0711] Prompt Sentence Examples

[0712] Example prompt for generative AI model:

[0713] "Please enter the amount of data generated for the manufacturing test of new part A in the factory. After the input is complete, we will analyze the operator's sentiment and adjust the amount generated."

[0714] This makes it possible to generate appropriate test data according to the user's emotions and state, and to verify and correct the data quickly and reliably.

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

[0716] Step 1:

[0717] The user inputs a test data generation request through the smart glasses. Using the smart glasses interface, the user inputs the required information, such as product type, planned production volume, and deadline. The input data is encoded in JSON format and sent to the server. The input data format is as follows:

[0718] Product Type: String (e.g., Part A)

[0719] Planned production volume: Integer (e.g., 1000)

[0720] Deadline: Date (e.g. 2023-12-31)

[0721] Step 2:

[0722] The smart glasses use a camera and microphone to recognize the user's emotional state in real time. The smart glasses use the collected video and audio data to send the data to the EmotionRecognizer (emotion engine). The input is the user's facial expression and audio data, and the output is the emotional classification result (e.g., stress, relief, etc.).

[0723] Step 3:

[0724] The server receives and analyzes input data and emotion data from users. Based on the input data, it determines the test data generation conditions (product type, planned production volume, deadline, etc.) and adjusts the generation algorithm based on the emotion data. For example, if the emotion data indicates "stress," it reduces the planned production volume (e.g., change it to 800).

[0725] Step 4:

[0726] The server references past test data and data patterns and generates new test data based on them. Based on input data (product type, planned production volume, deadline) and sentiment data (adjusted planned production volume), a generation algorithm is applied to create new data. For example, test data for part A is randomly generated to include a total of 800 parts.

[0727] Step 5:

[0728] The server internally verifies the generated data. It checks whether the generated test data meets the specified conditions (product type, planned production volume, deadline) and checks for inconsistencies. If necessary, it regenerates or corrects inconsistencies. For example, it verifies whether the data is properly distributed within the deadline.

[0729] Step 6:

[0730] The server converts the validated test data into an appropriate format (e.g., CSV or JSON) and provides it to the user. After the validated data has been converted, it is sent to the user's device (smart glasses or other device) via the cloud server. The user can then download the provided data and introduce it into their own test environment.

[0731] In this way, the present invention realizes the generation of appropriate test data according to the user's emotions and state, and the rapid and reliable verification and correction of the data.

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

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

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

[0735] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0748] The present invention is a system that automatically generates and efficiently provides test data required for preliminary testing and verification when developing a new service. Below, the program processing and specific examples of this system are explained in natural language.

[0749] System Overview

[0750] The user requests test data generation, and the server automatically generates the appropriate test data based on that request. The generated data is then verified and corrected, and finally provided to the user. This streamlines the test data generation process, significantly reducing the time and effort required for the development and testing cycle.

[0751] User inputs test data generation request

[0752] The user accesses the system through a browser or a dedicated application and enters the required information using the test data generation form, including, for example, the number of initial users, the number of products, the number of orders, and other specific conditions. After completing the input, the user submits a generation request.

[0753] The server receives and parses the request

[0754] When the server receives a request from a user, it analyzes the input data. Based on the analysis, it determines what kind of test data is needed and sets the corresponding generation conditions. For example, in the case of product data, information such as category, price range, and inventory quantity is set.

[0755] The server generates the test data

[0756] The server automatically generates test data, taking into account the infrastructure, development environment, and components being used. The server references past test data and stored data patterns and uses a generation algorithm to create new data. This data includes user data, product data, order data, and more.

[0757] Server validates and corrects generated data

[0758] The generated test data is internally verified via the server. During the verification process, the data is checked to see if it meets specified conditions and is consistent. If necessary, the data is corrected or regenerated. For example, it is checked to see if the generated order data is properly distributed within a specific period.

[0759] The server provides the test data

[0760] Once the verification is complete, the test data is converted into an appropriate format (e.g., CSV or JSON) by the server and provided to the user. Users can then download this data and introduce it into their own test environment, facilitating the development and testing of new services.

[0761] Specific examples

[0762] For example, suppose you are developing a new online shopping system and a user enters the following information:

[0763] Initial number of users: 1000

[0764] Number of products: 500

[0765] Order quantity: 3000

[0766] Percentage of specific product categories: 20%

[0767] Test period: 1 month

[0768] Based on this information, the server generates random user data, product data, and order data that meets specified conditions. The generated data undergoes an internal validation process before being provided to the user. Specifically, the server checks whether the generated order data is evenly distributed within a specified one-month period, whether a specific product category accounts for 20% of all products, and so on. Using this test data, users can efficiently develop and test their online shopping systems.

[0769] The processing flow will be explained below.

[0770] Step 1:

[0771] A user logs into the system via a browser or a dedicated application. The server authenticates the user and grants access.

[0772] Step 2:

[0773] The user enters the required information into the test data generation form, including the number of initial users, number of products, number of orders, specific conditions (e.g., specific categories or period), etc. The user confirms the input and presses the submit button.

[0774] Step 3:

[0775] The server receives the data sent by the user as an HTTP request, analyzes the request parameters, and extracts the basic information necessary to generate test data.

[0776] Step 4:

[0777] The server analyzes the input data and determines the type of test data required (user data, product data, order data, etc.) and the conditions for generating it.

[0778] Step 5:

[0779] The server references past test data and stored data patterns and prepares an algorithm for generating new test data based on this.

[0780] Step 6:

[0781] The server generates new test data based on the generation conditions. For example, for initial user data, a random username is generated, along with an email address and registration date.

[0782] Step 7:

[0783] The generated test data is temporarily stored in storage, and the data is converted to formats such as JSON, CSV, SQL dump, etc. as needed.

[0784] Step 8:

[0785] The server starts an internal validation of the generated data, checking whether it meets the specified conditions and whether the data is consistent.

[0786] Step 9:

[0787] If any problems are found during the validation process, the server will either regenerate the portion or apply an appropriate correction algorithm to correct the data.

[0788] Step 10:

[0789] The server converts the validated and corrected data into a final format, for example, exporting the data in CSV format and generating a download link.

[0790] Step 11:

[0791] Users download the test data via the provided link, and once the download is complete, they introduce the data into their own test environment.

[0792] Step 12:

[0793] Tests are performed on systems and services under development using test data acquired by the user. The test results are analyzed and feedback is provided to the system and data as needed.

[0794] Through this series of steps, users can efficiently generate, introduce, and test test data for new services.

[0795] Example 1

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

[0797] Conventional test data generation systems require manual data generation and verification, resulting in inefficiency and time-consuming labor. Furthermore, generating test data based on specific conditions or time periods can be difficult, potentially delaying the development and testing cycle of new services. The present invention aims to solve these problems by streamlining and automating the test data generation process.

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

[0799] In this invention, the server includes: means for inputting a prompt sentence using a natural language processing model when a user requests test data generation, and specifying the requirements for test data generation; means for the server to refer to past test data and stored data patterns and generate new test data based thereon; and means for verifying whether the generated test data is appropriately distributed within a set period and satisfies specific category conditions. This enables efficient and automatic generation of test data, enabling the development and testing cycle of new services to proceed quickly.

[0800] "User" means an end user who accesses the system and enters a request for test data generation.

[0801] A "server" is a central computer system that receives requests from users, analyzes them, generates data, validates them, and provides them.

[0802] A "test data generation request" is a set of information and conditions that a user inputs to request the generation of test data through the system.

[0803] "Infrastructure" refers to the hardware and software infrastructure required for a system to operate.

[0804] "Development Environment" refers to the set of software and tools used for developing, testing, and operating a System.

[0805] "Used components" refer to software libraries and modules that the system uses when generating test data.

[0806] A "natural language processing model" is an artificial intelligence model that analyzes and understands prompts entered by users.

[0807] A "prompt sentence" is a sentence that a user inputs in natural language when specifying conditions or requirements for generating test data.

[0808] "Past test data" refers to a collection of previously generated test data that is used as a reference for generating new data.

[0809] "Data patterns" refer to recurring trends or rules found in past test data.

[0810] "Verification measures" refer to the processes and tools used to verify that the generated test data meets specified conditions.

[0811] "Test data generation requirements" refer to conditions and constraints specified by a user when making a request for test data generation.

[0812] A "specific category condition" is a condition that indicates whether the test data conforms to a specific classification or category.

[0813] A "test period" refers to a specific time range established when test data is generated.

[0814] "Data format" refers to the data format (e.g., CSV, JSON) in which the generated test data is provided to the user.

[0815] This invention is a system that automatically generates and efficiently provides test data required for preliminary testing and verification when developing new services. The main components of this system are users, servers, and terminals. The specific functions and operations of each component are described below.

[0816] User inputs test data generation request

[0817] Users access the system through a browser or a dedicated application. Specifically, they use web browsers such as Google Chrome or Mozilla Firefox, or Windows or iOS apps. Using the test data generation form, users enter the required information (initial number of users, number of products, number of orders, specific conditions, etc.) and submit a generation request. For example, they enter the following information:

[0818] Initial number of users: 1000

[0819] Number of products: 500

[0820] Order quantity: 3000

[0821] Percentage of specific product categories: 20%

[0822] Test period: 1 month

[0823] The user can also specify requirements for test data generation by entering prompt sentences using a natural language processing model.

[0824] The server receives and parses the request

[0825] The server receives user requests through a web server such as Apache or NGINX. The backend system uses programs written in Python or Java to analyze the received data. During this analysis process, specific conditions for generating test data are set based on the information entered by the user. These conditions include the initial number of users, the number of products, the proportion of product categories, and the test period.

[0826] The server generates the test data

[0827] The server automatically generates test data using cloud services such as AWS Lambda and Google Cloud Functions. It uses Python and R libraries (Pandas, NumPy) to execute data generation algorithms. The generated test data includes user data, product data, and order data. As a concrete example, the following prompt statements are used to generate data:

[0828] "To develop a new online shopping system, please generate test data that meets the following conditions:

[0829] Initial number of users: 1000

[0830] Number of products: 500

[0831] Order quantity: 3000

[0832] Percentage of specific product categories: 20%

[0833] Test period: 1 month

[0834] Server validates and corrects generated data

[0835] The generated test data undergoes a validation process on the server. Data consistency is checked using an SQL database (MySQL, PostgreSQL) or a NoSQL database (MongoDB). Specific validation checks include checking for duplicate user IDs, whether the product category ratios are as specified, and whether the order data is evenly distributed within the test period. If any inconsistencies are found, the data is corrected or regenerated.

[0836] The server provides the test data

[0837] Once the validation is complete, the data is converted to CSV or JSON format and provided to the user. This conversion is performed using the Pandas .to_csv() method or the Node.js file system module. Users can obtain the test data via the provided download link and install it into their own development environment.

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

[0839] Step 1:

[0840] User inputs test data generation request

[0841] The user accesses the system through a browser or a dedicated application and enters the necessary information into the test data generation form. This input information includes the initial number of users, number of products, number of orders, and specific conditions (e.g., percentage of specific product categories, test period). After completing the input, the user submits a generation request. The specific operation here is that the user interface is implemented using HTML forms and React.js components.

[0842] Input: Number of initial users, number of products, number of orders, specific conditions

[0843] Output: Generated request data

[0844] Step 2:

[0845] The server receives and parses the request

[0846] The server receives generation requests from users through a web server such as Apache or NGINX. A back-end program written in Python or Java then analyzes the request data. During this analysis process, specific conditions for test data generation are set based on the information entered by the user. Specifically, it determines how the number of products, number of orders, percentage of specific product categories, and test period will be handled.

[0847] Input: Generation request data

[0848] Output: Conditions for generating test data

[0849] Step 3:

[0850] The server generates the test data

[0851] The server automatically generates test data based on the set conditions using cloud services such as AWS Lambda and Google Cloud Functions. It executes data generation algorithms using Python and R libraries (Pandas, NumPy). Specifically, it references past test data and stored data patterns to generate user data, product data, and order data.

[0852] Input: Test data generation conditions

[0853] Output: Generated test data

[0854] Step 4:

[0855] Server validates and corrects generated data

[0856] The generated test data undergoes a validation process on the server. This process uses an SQL database (MySQL, PostgreSQL) or a NoSQL database (MongoDB) to check the data's consistency. Specific validation tasks include checking for duplicate user IDs, whether the product category ratios are as specified, and whether the order data is evenly distributed within the test period. If any inconsistencies are found, the data is corrected or regenerated.

[0857] Input: Generated test data

[0858] Output: Verified test data

[0859] Step 5:

[0860] The server provides the test data

[0861] Once the test data has been validated, it is converted into the appropriate data format (CSV, JSON) by the server. This conversion process uses the Pandas .to_csv() method or the Node.js file system module. Users can then import the test data into their development environment via the provided download link.

[0862] Input: Verified test data

[0863] Output: Test data provided

[0864] (Application example 1)

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

[0866] The development of autonomous vehicles requires the generation and verification of a huge amount of test data, and the manual generation process is extremely time-consuming and labor-intensive. Therefore, there is a need for a method to efficiently generate test data and automate the verification process. It is also important to accurately verify that the generated data meets specified conditions and provide the resulting data in a specific data format.

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

[0868] In this invention, the server includes means for a user to input a test data generation request, means for the server to receive and analyze the input data from the user, means for generating test data based on the infrastructure, development environment, and components used by the server, means for inputting parameters required to generate simulation data for an autonomous vehicle, means for generating test data based on simulation parameters such as weather conditions and traffic volume, means for verifying the generated test data and correcting it as necessary, and means for the server to provide the verified test data to the user. This enables efficient generation of simulation data required for the development of autonomous vehicles and accurate verification and provision of the data.

[0869] A "test data generation request" is a request for specific test data that a user wants the system to generate.

[0870] "Server" is a central computer system that analyzes user input data and generates, verifies, and provides test data.

[0871] "Input data" refers to data provided by a user to a system, and includes information necessary for generating test data.

[0872] "Infrastructure" refers to physical and virtual computing resources, including servers and networks.

[0873] A "development environment" is the software and hardware setup used to generate and verify test data.

[0874] "Used components" are software parts such as algorithms and databases used when generating test data.

[0875] "Simulation data" is a type of test data generated to simulate the behavior of an autonomous vehicle.

[0876] "Parameters" are input values ​​and settings required when generating simulation data.

[0877] "Weather conditions" refers to the weather conditions reproduced within the simulation.

[0878] "Traffic volume" refers to the density and flow of traffic reproduced within the simulation.

[0879] "Verification" is the process of verifying whether the generated test data properly meets the specified conditions.

[0880] "Data format" refers to the particular form or structure in which test data is stored.

[0881] System Overview

[0882] This invention is a system for efficiently generating, verifying, and providing simulation data required for the development and testing of autonomous vehicles. The system is primarily composed of a server, a user terminal, and an interface for inputting various parameters.

[0883] Program processing description

[0884] The server receives and analyzes input data from users requesting test data generation. Based on this input data, the server generates simulation data for autonomous vehicles, taking into account the infrastructure, development environment, and components used. The generated data is based on simulation parameters such as weather conditions and traffic volume. The server also has a means of internally validating this data and correcting it if necessary. The validated data is provided in the data format specified by the user.

[0885] The server uses a programming language such as Python 3.x to implement a generation algorithm. This algorithm references past test data and data patterns to generate new data. To verify the accuracy of the generated data, the system also has a process for comparing it with past test data and standard settings.

[0886] Specific examples

[0887] For example, a user can input the following simulation parameters from a smartphone or PC:

[0888] Number of vehicles: 10

[0889] Route: Urban area

[0890] Weather conditions: Sunny

[0891] Traffic volume: Heavy

[0892] Simulation time: 60 minutes

[0893] The user inputs this information and requests test data generation. The server then receives this request, analyzes the input data, and generates simulation data. The generated data includes the location, speed, and event information of multiple vehicles based on weather conditions and traffic volume. After the validation process, the user can download the data in a specified format (e.g., CSV or JSON).

[0894] Prompt Sentence Examples

[0895] Entering the following prompt statement will generate simulation data based on the specified parameters:

[0896] generate_simulation_data(vehicle_count=10, route="urban", weather="sunny", traffic="heavy", duration=60)

[0897] This allows users to efficiently generate test data and facilitate the development and testing of autonomous vehicles.

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

[0899] Step 1:

[0900] The user inputs a test data generation request. In this step, the user inputs simulation parameters such as the number of vehicles, driving route, weather conditions, traffic volume, and simulation time from a smartphone or PC and sends them to the system. The specific parameters are sent to the server as input data.

[0901] Step 2:

[0902] The server receives and parses input data from the user. The server parses the received data and checks the data structure. This ensures that the input parameters are in the correct format and converts them into a form suitable for internal parsing processing. The parsing results in well-formed parameters that are used to generate subsequent data.

[0903] Step 3:

[0904] The server generates test data based on the infrastructure, development environment, and components used. The server uses the analyzed parameters to generate new simulation data while referencing past test data and data patterns. Specifically, it generates vehicle position, speed, event information, etc. randomly and according to specified conditions. The analyzed parameters are used as input, and simulation data is obtained as output.

[0905] Step 4:

[0906] Validate the generated test data and correct it if necessary. The server internally validates the generated test data to ensure it meets the specified conditions. For example, it checks weather conditions, traffic volume, and data distribution within a specified period. If any inconsistencies are found, the relevant parts are regenerated or corrected. At this step, validated data is obtained.

[0907] Step 5:

[0908] The validated test data is converted into a specific data format and provided to the user. The server converts the validated data into a format specified by the user (e.g., CSV, JSON) and provides it in a downloadable format. The validated data is used as input, and a data file is obtained as output and provided to the user.

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

[0910] This invention is a system that automatically generates test data to be used in the development and testing of new services, and recognizes user emotions during the process and reflects them in the data generation. Below, we will explain the program processing and specific examples of this system in natural language.

[0911] System Overview

[0912] The user requests test data generation, and the server automatically generates appropriate test data based on that request. The generated data is then verified and corrected, and finally provided to the user. By combining it with an emotion engine, the system analyzes the user's emotions and reflects the results in the generation of test data. This further streamlines the test data generation process, providing data that meets the user's needs and status.

[0913] User inputs test data generation request

[0914] Users access the system through a browser or a dedicated application and enter the required information using the test data generation form, including the number of initial users, number of products, number of orders, and other specific conditions. After completing the input, the user submits a generation request.

[0915] The server receives and parses the request

[0916] When the server receives a request from a user, it analyzes the input data. Based on the analysis, it determines what kind of test data is needed and sets the corresponding generation conditions. For example, in the case of product data, information such as category, price range, and inventory quantity is set.

[0917] Emotion recognition by emotion engine

[0918] The server is equipped with an emotion engine that analyzes emotions from the data and communication content entered by the user. For example, if the user is feeling stressed or relieved, the emotion engine analyzes the state and feeds the results back to the server.

[0919] The server generates the test data

[0920] The server automatically generates test data, taking into account the infrastructure, development environment, and components used, and also referring to feedback from the emotion engine. The server uses past test data and stored data patterns to apply a generative algorithm to create new data, including user data, product data, and order data.

[0921] Server validates and corrects generated data

[0922] The generated test data is internally verified via the server. During the verification process, the data is checked to see if it meets specified conditions and is consistent. If necessary, the data is corrected or regenerated. For example, it is checked to see if the generated order data is properly distributed within a specific period.

[0923] The server provides the test data

[0924] Once the verification is complete, the test data is converted into an appropriate format (e.g., CSV or JSON) by the server and provided to the user. Users can then download this data and introduce it into their own test environment, facilitating the development and testing of new services.

[0925] Specific examples

[0926] For example, suppose you are developing a new online shopping system and a user enters the following information:

[0927] Initial number of users: 1000

[0928] Number of products: 500

[0929] Order quantity: 3000

[0930] Percentage of specific product categories: 20%

[0931] Test period: 1 month

[0932] Based on this information, the server generates random user data, product data, and order data that meets the specified conditions. The generated data undergoes an internal verification process before being provided to the user. Specifically, the server checks whether the generated order data is evenly distributed within the specified one-month period, whether a specific product category accounts for 20% of all products, etc.

[0933] Furthermore, the emotion engine can be used to analyze the user's emotions, and flexible responses can be made according to the user's condition, such as simplifying the test data generation process if the user's stress level is high. In this way, users can develop and test online shopping systems efficiently and comfortably.

[0934] The processing flow will be explained below.

[0935] Step 1:

[0936] A user logs into the system via a browser or a dedicated application. The server authenticates the user and grants access.

[0937] Step 2:

[0938] The user enters the required information using the test data generation form, including the initial number of users, number of products, number of orders, and specific test conditions (e.g., category, period), confirms the input, and presses the submit button.

[0939] Step 3:

[0940] The server receives the data sent by the user as an HTTP request, analyzes the request parameters, and extracts the basic information necessary to generate test data.

[0941] Step 4:

[0942] The server activates the emotion engine, which recognizes emotions from the user's input data and communication content. The emotion engine analyzes the user's input speed and input content to generate emotion data.

[0943] Step 5:

[0944] The server receives feedback from the emotion engine and analyzes the user's emotional state. For example, if the user is feeling stressed, it will take appropriate measures such as relaxing the corresponding generation conditions.

[0945] Step 6:

[0946] The server sets the test data generation conditions based on the input data and feedback from the emotion engine, including the user data generation parameters, product data conditions, and order data distribution.

[0947] Step 7:

[0948] The server references past test data and stored data patterns to prepare algorithms for generating new test data, using specific algorithms and templates.

[0949] Step 8:

[0950] The server generates new test data based on the generation conditions. For example, the initial user data consists of a randomly generated username, email address, and registration date.

[0951] Step 9:

[0952] The generated test data is temporarily stored in storage, and the data is converted to formats such as JSON, CSV, SQL dump, etc. as needed.

[0953] Step 10:

[0954] The server initiates an internal validation of the generated data, checking whether it meets specified conditions and whether the data is consistent, for example, whether the order data is evenly distributed within a certain period of time.

[0955] Step 11:

[0956] If any problems are found during the validation process, the server will either regenerate the portion or apply an appropriate correction algorithm to correct the data.

[0957] Step 12:

[0958] The server converts the validated and corrected data into a final format, for example, exporting the data in CSV format and generating a download link.

[0959] Step 13:

[0960] Users download the test data via the provided link, and once the download is complete, they introduce the data into their own test environment.

[0961] Step 14:

[0962] Tests are performed on systems and services under development using test data acquired by the user. The test execution results are analyzed and feedback is provided to the system and data as needed. This process improves the quality of test data and maximizes test efficiency.

[0963] Through this series of steps, users can efficiently generate, introduce, and test test data for new services. Furthermore, the emotion engine enables data generation that takes into account the user's emotional state, providing a more flexible and user-friendly testing environment.

[0964] Example 2

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

[0966] Conventional test data generation systems generate data based on a fixed algorithm without considering the user's emotions, which can lead to problems such as users feeling stressed or being unable to flexibly respond to special requests. Furthermore, when inconsistencies occur in the generated data, the correction process is complicated, making it inefficient for users.

[0967] The specification process by the specification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for the user to input a test data generation request, a means for the server to receive and analyze the input data from the user, a means for analyzing the user's emotions using an emotion engine built into the server, a means for the server to generate test data based on the results of the emotion analysis, a means for the server to verify the generated data and correct it as necessary, and a means for the server to provide the verified test data to the user. This enables flexible test data generation that takes user emotions into consideration and also enables inconsistencies in the generated data to be efficiently corrected.

[0968] "User" refers to a person who accesses the system and inputs a test data generation request.

[0969] "Server" refers to a device or system that receives and analyzes input data from a user.

[0970] An "emotion engine" refers to software or algorithms for analyzing emotions from user input data and communication content.

[0971] "Test Data" refers to data automatically generated by the system and used for testing or examination based on user-specified conditions.

[0972] "Data generation request" refers to information or a request that a user inputs to the system to request the creation of test data.

[0973] "Verification" refers to the process of verifying that the generated test data meets specified conditions and is free of inconsistencies.

[0974] "Correction" refers to the act of regenerating or revising inconsistencies or inappropriate parts found during the verification process.

[0975] "Providing" refers to the act of the server providing the verified test data to the user in a downloadable form or the like.

[0976] "Data format" refers to the format in which the generated test data is stored or provided (e.g., CSV, JSON).

[0977] This invention relates to a system in which a server automatically generates test data based on a user's test data generation request. In particular, this system uses an emotion engine to analyze the user's emotions and reflects the results in the generation of test data, thereby achieving more flexible and efficient data generation. The system of the present invention is implemented as follows.

[0978] Users access the system using a browser or a dedicated application and enter the necessary information via a test data generation form. Input items include the number of initial users, number of products, number of orders, and other specific conditions. This allows users to set detailed specifications and conditions for the test data.

[0979] When the server receives a data generation request from a user, it begins analyzing the input data. Specifically, it determines what kind of test data is needed based on the analysis and moves on to the stage of setting conditions. At this point, the server uses an emotion engine to analyze emotions from the data and communication content entered by the user. For example, if the user is feeling stressed, it analyzes that state and provides feedback.

[0980] Based on the feedback from the emotion engine, the server generates test data. Specifically, the server references past test data and stored data patterns and applies a generation algorithm to create new data. This includes user data, product data, order data, and other appropriate data based on user requests.

[0981] The generated test data is then internally validated via the server. This checks whether the data meets the specified conditions and is consistent. If necessary, the data is corrected or regenerated. Finally, once validation is complete, the server converts the test data into an appropriate format (e.g., CSV or JSON) and provides it to the user.

[0982] As a concrete example, consider the case of developing a new online shopping system. Suppose a user enters information such as an initial number of users of 1,000, number of products of 500, number of orders of 3,000, a proportion of a specific product category of 20%, and a one-month trial period. Based on this information, the server generates user data, product data, and order data that is random but meets the specified conditions. The generated data undergoes an internal validation process before being provided to the user. For example, the server checks whether the generated order data is evenly distributed within the specified one-month period, and whether a specific product category accounts for 20% of all products.

[0983] By analyzing the user's emotions using the emotion engine, the test data generation process can be simplified and made more efficient when the user is under stress, allowing users to develop and test online shopping systems efficiently and comfortably.

[0984] Example prompt sentence:

[0985] Generate the following test data for your system:

[0986] Initial number of users: 1000

[0987] Number of products: 500

[0988] Order quantity: 3000

[0989] Percentage of specific product categories: 20%

[0990] Test period: 1 month

[0991] Adjust your data generation process based on user sentiment.

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

[0993] Step 1:

[0994] User inputs test data generation request

[0995] Input: The user accesses the test data generation form through a browser or a dedicated application and inputs the required information (e.g., number of initial users, number of products, number of orders, specific conditions).

[0996] Operation: The user confirms the input and presses the button to send the "generation request."

[0997] Output: Input data from the user is sent to the server.

[0998] Step 2:

[0999] The server receives and parses the request

[1000] Input: Test data generation request sent by the user.

[1001] Operation: The server receives a user request and analyzes the input data. Based on the analysis, it determines what test data is needed. For example, it sets conditions for generating user data based on the initial number of users.

[1002] Output: Set the required test data conditions (e.g. number of users, number of products, number of orders).

[1003] Step 3:

[1004] Emotional Engine Activation

[1005] Input: Data entered and communications made by users.

[1006] How it works: The emotion engine built into the server analyzes the user's input data and communication content to determine the user's emotional state. For example, it calculates an emotion score from the input content and evaluates whether the user is feeling stressed.

[1007] Output: The user's emotional state as a result of the analysis (e.g., stress level, relief level).

[1008] Step 4:

[1009] The server generates the test data

[1010] Input: The required test data conditions and the emotional state obtained from the emotion engine.

[1011] Operation: The server references feedback from the emotion engine and applies the test data generation algorithm to create data. It uses past test data and data patterns to generate user data, product data, and order data. For example, it generates product data for 1,000 users.

[1012] Output: The generated test data.

[1013] Step 5:

[1014] Server validates and corrects generated data

[1015] Input: Generated test data.

[1016] Operation: The server performs internal validation of the generated test data. It checks that the data meets specified conditions and is free of internal inconsistencies. For example, it verifies that the order distribution is even or that the proportions of specific product categories are correct. It corrects or regenerates the data as needed.

[1017] Output: Verified test data.

[1018] Step 6:

[1019] The server provides the test data

[1020] Input: Validated test data.

[1021] How it works: The server converts the test data after validation into a specific format (e.g., CSV, JSON), then provides the user with a link to download the data.

[1022] Output: Test data provided in a format that can be downloaded by the user.

[1023] Step 7:

[1024] Users can download and use test data

[1025] Input: Test data download link provided by the server.

[1026] Operation: A user clicks the download link to download the test data. After that, the downloaded test data is introduced into the user's test environment to develop and test a new service.

[1027] Output: Test data introduced into the test environment and the progress of service development and testing based on it.

[1028] (Application example 2)

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

[1030] Conventional test data generation systems generate data without considering the user's emotions or stress level, making it difficult to flexibly respond to the user's condition.In addition, in manufacturing environments, there is a need to automate the process of quickly and efficiently generating test data and reliably verifying it.

[1031] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: a means for the user to input a test data generation request; a means for the server to receive and analyze input data from the user; a means for the server to recognize and analyze the user's emotions in real time; a means for the server to adjust the test data generation algorithm based on the recognized emotions; a means for the server to generate test data based on the infrastructure, development environment, and components used by the server; a means for the server to verify the generated data and correct it as necessary; and a means for the server to provide the verified test data to the user. This enables the generation of appropriate test data according to the user's emotions and state, and fast and reliable data verification and correction.

[1032] A "user" is a person or organization that utilizes the system to enter test data generation requests.

[1033] A "server" is a device or system that receives and analyzes input data from a user.

[1034] "Input data" refers to information provided by a user when making a test data generation request.

[1035] "Emotion recognition" is the process of detecting and analyzing a user's real-time emotional state.

[1036] A "test data generation algorithm" is a set of computational steps for generating test data based on input data and sentiment analysis results.

[1037] "Infrastructure" refers to the physical and logical environment and facilities required for data generation.

[1038] "Development environment" refers to the setup and configuration of the software and hardware used to generate test data.

[1039] "Used components" are various modules and plug-ins used to generate test data.

[1040] "Verification" is the process of verifying that the generated test data meets specified conditions.

[1041] "Correction" is the process of regenerating or changing data that is found to be inconsistent as a result of verification.

[1042] "Test data" refers to a group of data generated to meet specific conditions and used for developing and testing new services and functions of the system.

[1043] In a system for implementing this invention, a user inputs a test data generation request, a server receives and analyzes it, recognizes the user's emotions, and generates data while adjusting the test data generation algorithm. The server also verifies the generated data, corrects any inconsistencies, and finally provides the verified data to the user.

[1044] System configuration

[1045] 1. User Device

[1046] A user uses a wearable device, such as smart glasses, to input a test data generation request.

[1047] The device uses a camera and microphone to recognize the user's emotions in real time.

[1048] 2. Server

[1049] Receives and analyzes data and emotional information input from the user's device.

[1050] The emotional engine is used to analyze the user's emotional state, and the results are reflected in the test data generation algorithm.

[1051] New data is generated based on past test data and data patterns.

[1052] Program processing

[1053] When a user inputs a test data generation request through the smart glasses, the camera and microphone are used to recognize the user's emotions in real time. The emotion engine analyzes the user's emotional state (e.g., stress, relief, etc.) from their facial expressions and voice. The analyzed emotional data is fed back to the generation algorithm, which adjusts the test data generation process according to the user's state. For example, if the user is feeling stressed, the amount of data generated will be reduced, reducing the burden on the user.

[1054] The server generates test data based on this information and performs validation on the cloud. The validation process checks whether the data meets the specified conditions and is consistent, and if there are any inconsistencies, the data is regenerated or corrected. Finally, the validated test data is converted into an appropriate format (e.g., CSV, JSON) and provided to the user.

[1055] Hardware and software used

[1056] Smart glasses: Used by users to input test data generation requests and recognize emotions. Examples include Google Glass and Vuzix M300.

[1057] Emotion engine: Used to analyze the user's facial expressions and voice. External libraries such as EmotionRecognizer are used.

[1058] Cloud server: Infrastructure for generating, verifying, and correcting data. AWS, Microsoft Azure, etc. can be considered for data storage and analysis processing.

[1059] Specific examples

[1060] For example, when prototyping a new part (Part A) on a production line, an operator uses smart glasses to input the following information:

[1061] Product Type: Part A

[1062] Planned production volume: 1000

[1063] Deadline:2023-12-31

[1064] If the user's emotion is recognized as stress, the server adjusts the generation amount to 800 and verifies and corrects the data on the cloud.

[1065] Prompt Sentence Examples

[1066] Example prompt for generative AI model:

[1067] "Please enter the amount of data generated for the manufacturing test of new part A in the factory. After the input is complete, we will analyze the operator's sentiment and adjust the amount generated."

[1068] This makes it possible to generate appropriate test data according to the user's emotions and state, and to verify and correct the data quickly and reliably.

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

[1070] Step 1:

[1071] The user inputs a test data generation request through the smart glasses. Using the smart glasses interface, the user inputs the required information, such as product type, planned production volume, and deadline. The input data is encoded in JSON format and sent to the server. The input data format is as follows:

[1072] Product Type: String (e.g., Part A)

[1073] Planned production volume: Integer (e.g., 1000)

[1074] Deadline: Date (e.g. 2023-12-31)

[1075] Step 2:

[1076] The smart glasses use a camera and microphone to recognize the user's emotional state in real time. The smart glasses use the collected video and audio data to send the data to the EmotionRecognizer (emotion engine). The input is the user's facial expression and audio data, and the output is the emotional classification result (e.g., stress, relief, etc.).

[1077] Step 3:

[1078] The server receives and analyzes input data and emotion data from users. Based on the input data, it determines the test data generation conditions (product type, planned production volume, deadline, etc.) and adjusts the generation algorithm based on the emotion data. For example, if the emotion data indicates "stress," it reduces the planned production volume (e.g., change it to 800).

[1079] Step 4:

[1080] The server references past test data and data patterns and generates new test data based on them. Based on input data (product type, planned production volume, deadline) and sentiment data (adjusted planned production volume), a generation algorithm is applied to create new data. For example, test data for part A is randomly generated to include a total of 800 parts.

[1081] Step 5:

[1082] The server internally verifies the generated data. It checks whether the generated test data meets the specified conditions (product type, planned production volume, deadline) and checks for inconsistencies. If necessary, it regenerates or corrects inconsistencies. For example, it verifies whether the data is properly distributed within the deadline.

[1083] Step 6:

[1084] The server converts the validated test data into an appropriate format (e.g., CSV or JSON) and provides it to the user. After the validated data has been converted, it is sent to the user's device (smart glasses or other device) via the cloud server. The user can then download the provided data and introduce it into their own test environment.

[1085] In this way, the present invention realizes the generation of appropriate test data according to the user's emotions and state, and the rapid and reliable verification and correction of the data.

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

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

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

[1089] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1103] The present invention is a system that automatically generates and efficiently provides test data required for preliminary testing and verification when developing a new service. Below, the program processing and specific examples of this system are explained in natural language.

[1104] System Overview

[1105] The user requests test data generation, and the server automatically generates the appropriate test data based on that request. The generated data is then verified and corrected, and finally provided to the user. This streamlines the test data generation process, significantly reducing the time and effort required for the development and testing cycle.

[1106] User inputs test data generation request

[1107] The user accesses the system through a browser or a dedicated application and enters the required information using the test data generation form, including, for example, the number of initial users, the number of products, the number of orders, and other specific conditions. After completing the input, the user submits a generation request.

[1108] The server receives and parses the request

[1109] When the server receives a request from a user, it analyzes the input data. Based on the analysis, it determines what kind of test data is needed and sets the corresponding generation conditions. For example, in the case of product data, information such as category, price range, and inventory quantity is set.

[1110] The server generates the test data

[1111] The server automatically generates test data, taking into account the infrastructure, development environment, and components being used. The server references past test data and stored data patterns and uses a generation algorithm to create new data. This data includes user data, product data, order data, and more.

[1112] Server validates and corrects generated data

[1113] The generated test data is internally verified via the server. During the verification process, the data is checked to see if it meets specified conditions and is consistent. If necessary, the data is corrected or regenerated. For example, it is checked to see if the generated order data is properly distributed within a specific period.

[1114] The server provides the test data

[1115] Once the verification is complete, the test data is converted into an appropriate format (e.g., CSV or JSON) by the server and provided to the user. Users can then download this data and introduce it into their own test environment, facilitating the development and testing of new services.

[1116] Specific examples

[1117] For example, suppose you are developing a new online shopping system and a user enters the following information:

[1118] Initial number of users: 1000

[1119] Number of products: 500

[1120] Order quantity: 3000

[1121] Percentage of specific product categories: 20%

[1122] Test period: 1 month

[1123] Based on this information, the server generates random user data, product data, and order data that meets specified conditions. The generated data undergoes an internal validation process before being provided to the user. Specifically, the server checks whether the generated order data is evenly distributed within a specified one-month period, whether a specific product category accounts for 20% of all products, and so on. Using this test data, users can efficiently develop and test their online shopping systems.

[1124] The processing flow will be explained below.

[1125] Step 1:

[1126] A user logs into the system via a browser or a dedicated application. The server authenticates the user and grants access.

[1127] Step 2:

[1128] The user enters the required information into the test data generation form, including the number of initial users, number of products, number of orders, specific conditions (e.g., specific categories or period), etc. The user confirms the input and presses the submit button.

[1129] Step 3:

[1130] The server receives the data sent by the user as an HTTP request, analyzes the request parameters, and extracts the basic information necessary to generate test data.

[1131] Step 4:

[1132] The server analyzes the input data and determines the type of test data required (user data, product data, order data, etc.) and the conditions for generating it.

[1133] Step 5:

[1134] The server references past test data and stored data patterns and prepares an algorithm for generating new test data based on this.

[1135] Step 6:

[1136] The server generates new test data based on the generation conditions. For example, for initial user data, a random username is generated, along with an email address and registration date.

[1137] Step 7:

[1138] The generated test data is temporarily stored in storage, and the data is converted to formats such as JSON, CSV, SQL dump, etc. as needed.

[1139] Step 8:

[1140] The server starts an internal validation of the generated data, checking whether it meets the specified conditions and whether the data is consistent.

[1141] Step 9:

[1142] If any problems are found during the validation process, the server will either regenerate the portion or apply an appropriate correction algorithm to correct the data.

[1143] Step 10:

[1144] The server converts the validated and corrected data into a final format, for example, exporting the data in CSV format and generating a download link.

[1145] Step 11:

[1146] Users download the test data via the provided link, and once the download is complete, they introduce the data into their own test environment.

[1147] Step 12:

[1148] Tests are performed on systems and services under development using test data acquired by the user. The test results are analyzed and feedback is provided to the system and data as needed.

[1149] Through this series of steps, users can efficiently generate, introduce, and test test data for new services.

[1150] Example 1

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

[1152] Conventional test data generation systems require manual data generation and verification, resulting in inefficiency and time-consuming labor. Furthermore, generating test data based on specific conditions or time periods can be difficult, potentially delaying the development and testing cycle of new services. The present invention aims to solve these problems by streamlining and automating the test data generation process.

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

[1154] In this invention, the server includes: means for inputting a prompt sentence using a natural language processing model when a user requests test data generation, and specifying the requirements for test data generation; means for the server to refer to past test data and stored data patterns and generate new test data based thereon; and means for verifying whether the generated test data is appropriately distributed within a set period and satisfies specific category conditions. This enables efficient and automatic generation of test data, enabling the development and testing cycle of new services to proceed quickly.

[1155] "User" means an end user who accesses the system and enters a request for test data generation.

[1156] A "server" is a central computer system that receives requests from users, analyzes them, generates data, validates them, and provides them.

[1157] A "test data generation request" is a set of information and conditions that a user inputs to request the generation of test data through the system.

[1158] "Infrastructure" refers to the hardware and software infrastructure required for a system to operate.

[1159] "Development Environment" refers to the set of software and tools used for developing, testing, and operating a System.

[1160] "Used components" refer to software libraries and modules that the system uses when generating test data.

[1161] A "natural language processing model" is an artificial intelligence model that analyzes and understands prompts entered by users.

[1162] A "prompt sentence" is a sentence that a user inputs in natural language when specifying conditions or requirements for generating test data.

[1163] "Past test data" refers to a collection of previously generated test data that is used as a reference for generating new data.

[1164] "Data patterns" refer to recurring trends or rules found in past test data.

[1165] "Verification measures" refer to the processes and tools used to verify that the generated test data meets specified conditions.

[1166] "Test data generation requirements" refer to conditions and constraints specified by a user when making a request for test data generation.

[1167] A "specific category condition" is a condition that indicates whether the test data conforms to a specific classification or category.

[1168] A "test period" refers to a specific time range established when test data is generated.

[1169] "Data format" refers to the data format (e.g., CSV, JSON) in which the generated test data is provided to the user.

[1170] This invention is a system that automatically generates and efficiently provides test data required for preliminary testing and verification when developing new services. The main components of this system are users, servers, and terminals. The specific functions and operations of each component are described below.

[1171] User inputs test data generation request

[1172] Users access the system through a browser or a dedicated application. Specifically, they use web browsers such as Google Chrome or Mozilla Firefox, or Windows or iOS apps. Using the test data generation form, users enter the required information (initial number of users, number of products, number of orders, specific conditions, etc.) and submit a generation request. For example, they enter the following information:

[1173] Initial number of users: 1000

[1174] Number of products: 500

[1175] Order quantity: 3000

[1176] Percentage of specific product categories: 20%

[1177] Test period: 1 month

[1178] The user can also specify requirements for test data generation by entering prompt sentences using a natural language processing model.

[1179] The server receives and parses the request

[1180] The server receives user requests through a web server such as Apache or NGINX. The backend system uses programs written in Python or Java to analyze the received data. During this analysis process, specific conditions for generating test data are set based on the information entered by the user. These conditions include the initial number of users, the number of products, the proportion of product categories, and the test period.

[1181] The server generates the test data

[1182] The server automatically generates test data using cloud services such as AWS Lambda and Google Cloud Functions. It uses Python and R libraries (Pandas, NumPy) to execute data generation algorithms. The generated test data includes user data, product data, and order data. As a concrete example, the following prompt statements are used to generate data:

[1183] "To develop a new online shopping system, please generate test data that meets the following conditions:

[1184] Initial number of users: 1000

[1185] Number of products: 500

[1186] Order quantity: 3000

[1187] Percentage of specific product categories: 20%

[1188] Test period: 1 month

[1189] Server validates and corrects generated data

[1190] The generated test data undergoes a validation process on the server. Data consistency is checked using an SQL database (MySQL, PostgreSQL) or a NoSQL database (MongoDB). Specific validation checks include checking for duplicate user IDs, whether the product category ratios are as specified, and whether the order data is evenly distributed within the test period. If any inconsistencies are found, the data is corrected or regenerated.

[1191] The server provides the test data

[1192] Once the validation is complete, the data is converted to CSV or JSON format and provided to the user. This conversion is performed using the Pandas .to_csv() method or the Node.js file system module. Users can obtain the test data via the provided download link and install it into their own development environment.

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

[1194] Step 1:

[1195] User inputs test data generation request

[1196] The user accesses the system through a browser or a dedicated application and enters the necessary information into the test data generation form. This input information includes the initial number of users, number of products, number of orders, and specific conditions (e.g., percentage of specific product categories, test period). After completing the input, the user submits a generation request. The specific operation here is that the user interface is implemented using HTML forms and React.js components.

[1197] Input: Number of initial users, number of products, number of orders, specific conditions

[1198] Output: Generated request data

[1199] Step 2:

[1200] The server receives and parses the request

[1201] The server receives generation requests from users through a web server such as Apache or NGINX. A back-end program written in Python or Java then analyzes the request data. During this analysis process, specific conditions for test data generation are set based on the information entered by the user. Specifically, it determines how the number of products, number of orders, percentage of specific product categories, and test period will be handled.

[1202] Input: Generation request data

[1203] Output: Conditions for generating test data

[1204] Step 3:

[1205] The server generates the test data

[1206] The server automatically generates test data based on the set conditions using cloud services such as AWS Lambda and Google Cloud Functions. It executes data generation algorithms using Python and R libraries (Pandas, NumPy). Specifically, it references past test data and stored data patterns to generate user data, product data, and order data.

[1207] Input: Test data generation conditions

[1208] Output: Generated test data

[1209] Step 4:

[1210] Server validates and corrects generated data

[1211] The generated test data undergoes a validation process on the server. This process uses an SQL database (MySQL, PostgreSQL) or a NoSQL database (MongoDB) to check the data's consistency. Specific validation tasks include checking for duplicate user IDs, whether the product category ratios are as specified, and whether the order data is evenly distributed within the test period. If any inconsistencies are found, the data is corrected or regenerated.

[1212] Input: Generated test data

[1213] Output: Verified test data

[1214] Step 5:

[1215] The server provides the test data

[1216] Once the test data has been validated, it is converted into the appropriate data format (CSV, JSON) by the server. This conversion process uses the Pandas .to_csv() method or the Node.js file system module. Users can then import the test data into their development environment via the provided download link.

[1217] Input: Verified test data

[1218] Output: Test data provided

[1219] (Application example 1)

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

[1221] The development of autonomous vehicles requires the generation and verification of a huge amount of test data, and the manual generation process is extremely time-consuming and labor-intensive. Therefore, there is a need for a method to efficiently generate test data and automate the verification process. It is also important to accurately verify that the generated data meets specified conditions and provide the resulting data in a specific data format.

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

[1223] In this invention, the server includes means for a user to input a test data generation request, means for the server to receive and analyze the input data from the user, means for generating test data based on the infrastructure, development environment, and components used by the server, means for inputting parameters required to generate simulation data for an autonomous vehicle, means for generating test data based on simulation parameters such as weather conditions and traffic volume, means for verifying the generated test data and correcting it as necessary, and means for the server to provide the verified test data to the user. This enables efficient generation of simulation data required for the development of autonomous vehicles and accurate verification and provision of the data.

[1224] A "test data generation request" is a request for specific test data that a user wants the system to generate.

[1225] "Server" is a central computer system that analyzes user input data and generates, verifies, and provides test data.

[1226] "Input data" refers to data provided by a user to a system, and includes information necessary for generating test data.

[1227] "Infrastructure" refers to physical and virtual computing resources, including servers and networks.

[1228] A "development environment" is the software and hardware setup used to generate and verify test data.

[1229] "Used components" are software parts such as algorithms and databases used when generating test data.

[1230] "Simulation data" is a type of test data generated to simulate the behavior of an autonomous vehicle.

[1231] "Parameters" are input values ​​and settings required when generating simulation data.

[1232] "Weather conditions" refers to the weather conditions reproduced within the simulation.

[1233] "Traffic volume" refers to the density and flow of traffic reproduced within the simulation.

[1234] "Verification" is the process of verifying whether the generated test data properly meets the specified conditions.

[1235] "Data format" refers to the particular form or structure in which test data is stored.

[1236] System Overview

[1237] This invention is a system for efficiently generating, verifying, and providing simulation data required for the development and testing of autonomous vehicles. The system is primarily composed of a server, a user terminal, and an interface for inputting various parameters.

[1238] Program processing description

[1239] The server receives and analyzes input data from users requesting test data generation. Based on this input data, the server generates simulation data for autonomous vehicles, taking into account the infrastructure, development environment, and components used. The generated data is based on simulation parameters such as weather conditions and traffic volume. The server also has a means of internally validating this data and correcting it if necessary. The validated data is provided in the data format specified by the user.

[1240] The server uses a programming language such as Python 3.x to implement a generation algorithm. This algorithm references past test data and data patterns to generate new data. To verify the accuracy of the generated data, the system also has a process for comparing it with past test data and standard settings.

[1241] Specific examples

[1242] For example, a user can input the following simulation parameters from a smartphone or PC:

[1243] Number of vehicles: 10

[1244] Route: Urban area

[1245] Weather conditions: Sunny

[1246] Traffic volume: Heavy

[1247] Simulation time: 60 minutes

[1248] The user inputs this information and requests test data generation. The server then receives this request, analyzes the input data, and generates simulation data. The generated data includes the location, speed, and event information of multiple vehicles based on weather conditions and traffic volume. After the validation process, the user can download the data in a specified format (e.g., CSV or JSON).

[1249] Prompt Sentence Examples

[1250] Entering the following prompt statement will generate simulation data based on the specified parameters:

[1251] generate_simulation_data(vehicle_count=10, route="urban", weather="sunny", traffic="heavy", duration=60)

[1252] This allows users to efficiently generate test data and facilitate the development and testing of autonomous vehicles.

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

[1254] Step 1:

[1255] The user inputs a test data generation request. In this step, the user inputs simulation parameters such as the number of vehicles, driving route, weather conditions, traffic volume, and simulation time from a smartphone or PC and sends them to the system. The specific parameters are sent to the server as input data.

[1256] Step 2:

[1257] The server receives and parses input data from the user. The server parses the received data and checks the data structure. This ensures that the input parameters are in the correct format and converts them into a form suitable for internal parsing processing. The parsing results in well-formed parameters that are used to generate subsequent data.

[1258] Step 3:

[1259] The server generates test data based on the infrastructure, development environment, and components used. The server uses the analyzed parameters to generate new simulation data while referencing past test data and data patterns. Specifically, it generates vehicle position, speed, event information, etc. randomly and according to specified conditions. The analyzed parameters are used as input, and simulation data is obtained as output.

[1260] Step 4:

[1261] Validate the generated test data and correct it if necessary. The server internally validates the generated test data to ensure it meets the specified conditions. For example, it checks weather conditions, traffic volume, and data distribution within a specified period. If any inconsistencies are found, the relevant parts are regenerated or corrected. At this step, validated data is obtained.

[1262] Step 5:

[1263] The validated test data is converted into a specific data format and provided to the user. The server converts the validated data into a format specified by the user (e.g., CSV, JSON) and provides it in a downloadable format. The validated data is used as input, and a data file is obtained as output and provided to the user.

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

[1265] This invention is a system that automatically generates test data to be used in the development and testing of new services, and recognizes user emotions during the process and reflects them in the data generation. Below, we will explain the program processing and specific examples of this system in natural language.

[1266] System Overview

[1267] The user requests test data generation, and the server automatically generates appropriate test data based on that request. The generated data is then verified and corrected, and finally provided to the user. By combining it with an emotion engine, the system analyzes the user's emotions and reflects the results in the generation of test data. This further streamlines the test data generation process, providing data that meets the user's needs and status.

[1268] User inputs test data generation request

[1269] Users access the system through a browser or a dedicated application and enter the required information using the test data generation form, including the number of initial users, number of products, number of orders, and other specific conditions. After completing the input, the user submits a generation request.

[1270] The server receives and parses the request

[1271] When the server receives a request from a user, it analyzes the input data. Based on the analysis, it determines what kind of test data is needed and sets the corresponding generation conditions. For example, in the case of product data, information such as category, price range, and inventory quantity is set.

[1272] Emotion recognition by emotion engine

[1273] The server is equipped with an emotion engine that analyzes emotions from the data and communication content entered by the user. For example, if the user is feeling stressed or relieved, the emotion engine analyzes the state and feeds the results back to the server.

[1274] The server generates the test data

[1275] The server automatically generates test data, taking into account the infrastructure, development environment, and components used, and also referring to feedback from the emotion engine. The server uses past test data and stored data patterns to apply a generative algorithm to create new data, including user data, product data, and order data.

[1276] Server validates and corrects generated data

[1277] The generated test data is internally verified via the server. During the verification process, the data is checked to see if it meets specified conditions and is consistent. If necessary, the data is corrected or regenerated. For example, it is checked to see if the generated order data is properly distributed within a specific period.

[1278] The server provides the test data

[1279] Once the verification is complete, the test data is converted into an appropriate format (e.g., CSV or JSON) by the server and provided to the user. Users can then download this data and introduce it into their own test environment, facilitating the development and testing of new services.

[1280] Specific examples

[1281] For example, suppose you are developing a new online shopping system and a user enters the following information:

[1282] Initial number of users: 1000

[1283] Number of products: 500

[1284] Order quantity: 3000

[1285] Percentage of specific product categories: 20%

[1286] Test period: 1 month

[1287] Based on this information, the server generates random user data, product data, and order data that meets the specified conditions. The generated data undergoes an internal verification process before being provided to the user. Specifically, the server checks whether the generated order data is evenly distributed within the specified one-month period, whether a specific product category accounts for 20% of all products, etc.

[1288] Furthermore, the emotion engine can be used to analyze the user's emotions, and flexible responses can be made according to the user's condition, such as simplifying the test data generation process if the user's stress level is high. In this way, users can develop and test online shopping systems efficiently and comfortably.

[1289] The processing flow will be explained below.

[1290] Step 1:

[1291] A user logs into the system via a browser or a dedicated application. The server authenticates the user and grants access.

[1292] Step 2:

[1293] The user enters the required information using the test data generation form, including the initial number of users, number of products, number of orders, and specific test conditions (e.g., category, period), confirms the input, and presses the submit button.

[1294] Step 3:

[1295] The server receives the data sent by the user as an HTTP request, analyzes the request parameters, and extracts the basic information necessary to generate test data.

[1296] Step 4:

[1297] The server activates the emotion engine, which recognizes emotions from the user's input data and communication content. The emotion engine analyzes the user's input speed and input content to generate emotion data.

[1298] Step 5:

[1299] The server receives feedback from the emotion engine and analyzes the user's emotional state. For example, if the user is feeling stressed, it will take appropriate measures such as relaxing the corresponding generation conditions.

[1300] Step 6:

[1301] The server sets the test data generation conditions based on the input data and feedback from the emotion engine, including the user data generation parameters, product data conditions, and order data distribution.

[1302] Step 7:

[1303] The server references past test data and stored data patterns to prepare algorithms for generating new test data, using specific algorithms and templates.

[1304] Step 8:

[1305] The server generates new test data based on the generation conditions. For example, the initial user data consists of a randomly generated username, email address, and registration date.

[1306] Step 9:

[1307] The generated test data is temporarily stored in storage, and the data is converted to formats such as JSON, CSV, SQL dump, etc. as needed.

[1308] Step 10:

[1309] The server initiates an internal validation of the generated data, checking whether it meets specified conditions and whether the data is consistent, for example, whether the order data is evenly distributed within a certain period of time.

[1310] Step 11:

[1311] If any problems are found during the validation process, the server will either regenerate the portion or apply an appropriate correction algorithm to correct the data.

[1312] Step 12:

[1313] The server converts the validated and corrected data into a final format, for example, exporting the data in CSV format and generating a download link.

[1314] Step 13:

[1315] Users download the test data via the provided link, and once the download is complete, they introduce the data into their own test environment.

[1316] Step 14:

[1317] Tests are performed on systems and services under development using test data acquired by the user. The test execution results are analyzed and feedback is provided to the system and data as needed. This process improves the quality of test data and maximizes test efficiency.

[1318] Through this series of steps, users can efficiently generate, introduce, and test test data for new services. Furthermore, the emotion engine enables data generation that takes into account the user's emotional state, providing a more flexible and user-friendly testing environment.

[1319] Example 2

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

[1321] Conventional test data generation systems generate data based on a fixed algorithm without considering the user's emotions, which can lead to problems such as users feeling stressed or being unable to flexibly respond to special requests. Furthermore, when inconsistencies occur in the generated data, the correction process is complicated, making it inefficient for users.

[1322] The specification process by the specification processing unit 290 of the data processing device 12 in the second embodiment is realized by the following means. In this invention, the server includes a means for the user to input a test data generation request, a means for the server to receive and analyze the input data from the user, a means for analyzing the user's emotions using an emotion engine built into the server, a means for the server to generate test data based on the results of the emotion analysis, a means for the server to verify the generated data and correct it as necessary, and a means for the server to provide the verified test data to the user. This enables flexible test data generation that takes user emotions into consideration and also enables inconsistencies in the generated data to be efficiently corrected.

[1323] "User" refers to a person who accesses the system and inputs a test data generation request.

[1324] "Server" refers to a device or system that receives and analyzes input data from a user.

[1325] An "emotion engine" refers to software or algorithms for analyzing emotions from user input data and communication content.

[1326] "Test Data" refers to data automatically generated by the system and used for testing or examination based on user-specified conditions.

[1327] "Data generation request" refers to information or a request that a user inputs to the system to request the creation of test data.

[1328] "Verification" refers to the process of verifying that the generated test data meets specified conditions and is free of inconsistencies.

[1329] "Correction" refers to the act of regenerating or revising inconsistencies or inappropriate parts found during the verification process.

[1330] "Providing" refers to the act of the server providing the verified test data to the user in a downloadable form or the like.

[1331] "Data format" refers to the format in which the generated test data is stored or provided (e.g., CSV, JSON).

[1332] This invention relates to a system in which a server automatically generates test data based on a user's test data generation request. In particular, this system uses an emotion engine to analyze the user's emotions and reflects the results in the generation of test data, thereby achieving more flexible and efficient data generation. The system of the present invention is implemented as follows.

[1333] Users access the system using a browser or a dedicated application and enter the necessary information via a test data generation form. Input items include the number of initial users, number of products, number of orders, and other specific conditions. This allows users to set detailed specifications and conditions for the test data.

[1334] When the server receives a data generation request from a user, it begins analyzing the input data. Specifically, it determines what kind of test data is needed based on the analysis and moves on to the stage of setting conditions. At this point, the server uses an emotion engine to analyze emotions from the data and communication content entered by the user. For example, if the user is feeling stressed, it analyzes that state and provides feedback.

[1335] Based on the feedback from the emotion engine, the server generates test data. Specifically, the server references past test data and stored data patterns and applies a generation algorithm to create new data. This includes user data, product data, order data, and other appropriate data based on user requests.

[1336] The generated test data is then internally validated via the server. This checks whether the data meets the specified conditions and is consistent. If necessary, the data is corrected or regenerated. Finally, once validation is complete, the server converts the test data into an appropriate format (e.g., CSV or JSON) and provides it to the user.

[1337] As a concrete example, consider the case of developing a new online shopping system. Suppose a user enters information such as an initial number of users of 1,000, number of products of 500, number of orders of 3,000, a proportion of a specific product category of 20%, and a one-month trial period. Based on this information, the server generates user data, product data, and order data that is random but meets the specified conditions. The generated data undergoes an internal validation process before being provided to the user. For example, the server checks whether the generated order data is evenly distributed within the specified one-month period, and whether a specific product category accounts for 20% of all products.

[1338] By analyzing the user's emotions using the emotion engine, the test data generation process can be simplified and made more efficient when the user is under stress, allowing users to develop and test online shopping systems efficiently and comfortably.

[1339] Example prompt sentence:

[1340] Generate the following test data for your system:

[1341] Initial number of users: 1000

[1342] Number of products: 500

[1343] Order quantity: 3000

[1344] Percentage of specific product categories: 20%

[1345] Test period: 1 month

[1346] Adjust your data generation process based on user sentiment.

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

[1348] Step 1:

[1349] User inputs test data generation request

[1350] Input: The user accesses the test data generation form through a browser or a dedicated application and inputs the required information (e.g., number of initial users, number of products, number of orders, specific conditions).

[1351] Operation: The user confirms the input and presses the button to send the "generation request."

[1352] Output: Input data from the user is sent to the server.

[1353] Step 2:

[1354] The server receives and parses the request

[1355] Input: Test data generation request sent by the user.

[1356] Operation: The server receives a user request and analyzes the input data. Based on the analysis, it determines what test data is needed. For example, it sets conditions for generating user data based on the initial number of users.

[1357] Output: Set the required test data conditions (e.g. number of users, number of products, number of orders).

[1358] Step 3:

[1359] Emotional Engine Activation

[1360] Input: Data entered and communications made by users.

[1361] How it works: The emotion engine built into the server analyzes the user's input data and communication content to determine the user's emotional state. For example, it calculates an emotion score from the input content and evaluates whether the user is feeling stressed.

[1362] Output: The user's emotional state as a result of the analysis (e.g., stress level, relief level).

[1363] Step 4:

[1364] The server generates the test data

[1365] Input: The required test data conditions and the emotional state obtained from the emotion engine.

[1366] Operation: The server references feedback from the emotion engine and applies the test data generation algorithm to create data. It uses past test data and data patterns to generate user data, product data, and order data. For example, it generates product data for 1,000 users.

[1367] Output: The generated test data.

[1368] Step 5:

[1369] Server validates and corrects generated data

[1370] Input: Generated test data.

[1371] Operation: The server performs internal validation of the generated test data. It checks that the data meets specified conditions and is free of internal inconsistencies. For example, it verifies that the order distribution is even or that the proportions of specific product categories are correct. It corrects or regenerates the data as needed.

[1372] Output: Verified test data.

[1373] Step 6:

[1374] The server provides the test data

[1375] Input: Validated test data.

[1376] How it works: The server converts the test data after validation into a specific format (e.g., CSV, JSON), then provides the user with a link to download the data.

[1377] Output: Test data provided in a format that can be downloaded by the user.

[1378] Step 7:

[1379] Users can download and use test data

[1380] Input: Test data download link provided by the server.

[1381] Operation: A user clicks the download link to download the test data. After that, the downloaded test data is introduced into the user's test environment to develop and test a new service.

[1382] Output: Test data introduced into the test environment and the progress of service development and testing based on it.

[1383] (Application example 2)

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

[1385] Conventional test data generation systems generate data without considering the user's emotions or stress level, making it difficult to flexibly respond to the user's condition.In addition, in manufacturing environments, there is a need to automate the process of quickly and efficiently generating test data and reliably verifying it.

[1386] The specific processing by the specific processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: a means for the user to input a test data generation request; a means for the server to receive and analyze input data from the user; a means for the server to recognize and analyze the user's emotions in real time; a means for the server to adjust the test data generation algorithm based on the recognized emotions; a means for the server to generate test data based on the infrastructure, development environment, and components used by the server; a means for the server to verify the generated data and correct it as necessary; and a means for the server to provide the verified test data to the user. This enables the generation of appropriate test data according to the user's emotions and state, and fast and reliable data verification and correction.

[1387] A "user" is a person or organization that utilizes the system to enter test data generation requests.

[1388] A "server" is a device or system that receives and analyzes input data from a user.

[1389] "Input data" refers to information provided by a user when making a test data generation request.

[1390] "Emotion recognition" is the process of detecting and analyzing a user's real-time emotional state.

[1391] A "test data generation algorithm" is a set of computational steps for generating test data based on input data and sentiment analysis results.

[1392] "Infrastructure" refers to the physical and logical environment and facilities required for data generation.

[1393] "Development environment" refers to the setup and configuration of the software and hardware used to generate test data.

[1394] "Used components" are various modules and plug-ins used to generate test data.

[1395] "Verification" is the process of verifying that the generated test data meets specified conditions.

[1396] "Correction" is the process of regenerating or changing data that is found to be inconsistent as a result of verification.

[1397] "Test data" refers to a group of data generated to meet specific conditions and used for developing and testing new services and functions of the system.

[1398] In a system for implementing this invention, a user inputs a test data generation request, a server receives and analyzes it, recognizes the user's emotions, and generates data while adjusting the test data generation algorithm. The server also verifies the generated data, corrects any inconsistencies, and finally provides the verified data to the user.

[1399] System configuration

[1400] 1. User Device

[1401] A user uses a wearable device, such as smart glasses, to input a test data generation request.

[1402] The device uses a camera and microphone to recognize the user's emotions in real time.

[1403] 2. Server

[1404] Receives and analyzes data and emotional information input from the user's device.

[1405] The emotional engine is used to analyze the user's emotional state, and the results are reflected in the test data generation algorithm.

[1406] New data is generated based on past test data and data patterns.

[1407] Program processing

[1408] When a user inputs a test data generation request through the smart glasses, the camera and microphone are used to recognize the user's emotions in real time. The emotion engine analyzes the user's emotional state (e.g., stress, relief, etc.) from their facial expressions and voice. The analyzed emotional data is fed back to the generation algorithm, which adjusts the test data generation process according to the user's state. For example, if the user is feeling stressed, the amount of data generated will be reduced, reducing the burden on the user.

[1409] The server generates test data based on this information and performs validation on the cloud. The validation process checks whether the data meets the specified conditions and is consistent, and if there are any inconsistencies, the data is regenerated or corrected. Finally, the validated test data is converted into an appropriate format (e.g., CSV, JSON) and provided to the user.

[1410] Hardware and software used

[1411] Smart glasses: Used by users to input test data generation requests and recognize emotions. Examples include Google Glass and Vuzix M300.

[1412] Emotion engine: Used to analyze the user's facial expressions and voice. External libraries such as EmotionRecognizer are used.

[1413] Cloud server: Infrastructure for generating, verifying, and correcting data. AWS, Microsoft Azure, etc. can be considered for data storage and analysis processing.

[1414] Specific examples

[1415] For example, when prototyping a new part (Part A) on a production line, an operator uses smart glasses to input the following information:

[1416] Product Type: Part A

[1417] Planned production volume: 1000

[1418] Deadline:2023-12-31

[1419] If the user's emotion is recognized as stress, the server adjusts the generation amount to 800 and verifies and corrects the data on the cloud.

[1420] Prompt Sentence Examples

[1421] Example prompt for generative AI model:

[1422] "Please enter the amount of data generated for the manufacturing test of new part A in the factory. After the input is complete, we will analyze the operator's sentiment and adjust the amount generated."

[1423] This makes it possible to generate appropriate test data according to the user's emotions and state, and to verify and correct the data quickly and reliably.

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

[1425] Step 1:

[1426] The user inputs a test data generation request through the smart glasses. Using the smart glasses interface, the user inputs the required information, such as product type, planned production volume, and deadline. The input data is encoded in JSON format and sent to the server. The input data format is as follows:

[1427] Product Type: String (e.g., Part A)

[1428] Planned production volume: Integer (e.g., 1000)

[1429] Deadline: Date (e.g. 2023-12-31)

[1430] Step 2:

[1431] The smart glasses use a camera and microphone to recognize the user's emotional state in real time. The smart glasses use the collected video and audio data to send the data to the EmotionRecognizer (emotion engine). The input is the user's facial expression and audio data, and the output is the emotional classification result (e.g., stress, relief, etc.).

[1432] Step 3:

[1433] The server receives and analyzes input data and emotion data from users. Based on the input data, it determines the test data generation conditions (product type, planned production volume, deadline, etc.) and adjusts the generation algorithm based on the emotion data. For example, if the emotion data indicates "stress," it reduces the planned production volume (e.g., change it to 800).

[1434] Step 4:

[1435] The server references past test data and data patterns and generates new test data based on them. Based on input data (product type, planned production volume, deadline) and sentiment data (adjusted planned production volume), a generation algorithm is applied to create new data. For example, test data for part A is randomly generated to include a total of 800 parts.

[1436] Step 5:

[1437] The server internally verifies the generated data. It checks whether the generated test data meets the specified conditions (product type, planned production volume, deadline) and checks for inconsistencies. If necessary, it regenerates or corrects inconsistencies. For example, it verifies whether the data is properly distributed within the deadline.

[1438] Step 6:

[1439] The server converts the validated test data into an appropriate format (e.g., CSV or JSON) and provides it to the user. After the validated data has been converted, it is sent to the user's device (smart glasses or other device) via the cloud server. The user can then download the provided data and introduce it into their own test environment.

[1440] In this way, the present invention realizes the generation of appropriate test data according to the user's emotions and state, and the rapid and reliable verification and correction of the data.

[1441] The specific processing unit 290 transmits the result of the specific processing to the robot 414. In the robot 414, the control unit 46A causes the speaker 240 and the control target 443 to output the result of the specific processing. The microphone 238 acquires voice indicating a user input regarding the result of the specific processing. The control unit 46A transmits voice data indicating the user input acquired by the microphone 238 to the data processing device 12. In the data processing device 12, the specific processing unit 290 acquires the voice data.

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

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

[1444] The emotion identification model 59 as an emotion engine may determine the user's emotion according to a specific mapping. Specifically, the emotion identification model 59 may determine the user's emotion according to an emotion map (see FIG. 9), which is a specific mapping. Similarly, the emotion identification model 59 may determine the robot's emotion, and the identification processing unit 290 may perform identification processing using the robot's emotion.

[1445] FIG. 9 is a diagram illustrating an emotion map 400 on which multiple emotions are mapped. In the emotion map 400, emotions are arranged in concentric circles radiating from the center. Emotions closer to the center of the concentric circles are more primitive. Emotions representing states and actions arising from a state of mind are arranged on the outer edges of the concentric circles. The concept of emotion includes both affect and mental states. Emotions generally generated from reactions occurring in the brain are arranged on the left side of the concentric circles. Emotions generally induced by situational judgment are arranged on the right side of the concentric circles. Emotions generally generated from reactions occurring in the brain and induced by situational judgment are arranged on the upper and lower sides of the concentric circles. Furthermore, the emotion of "pleasure" is arranged on the upper side of the concentric circles, and the emotion of "discomfort" is arranged on the lower side. In this way, in the emotion map 400, multiple emotions are mapped based on the structure by which emotions are generated, and emotions that tend to occur simultaneously are mapped close to each other.

[1446] These emotions are distributed in the 3 o'clock direction on emotion map 400, and typically fluctuate between relief and anxiety. In the right half of emotion map 400, situational awareness dominates over internal sensations, resulting in a sense of calm.

[1447] The inside of emotion map 400 represents what is going on in the mind, and the outside of emotion map 400 represents behavior, so the further you go outside emotion map 400, the more visible the emotions become (the more they are expressed in behavior).

[1448] Human emotions are based on various balances, such as posture and blood sugar levels. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. Emotions can also be created for robots, automobiles, and motorcycles, based on various balances, such as posture and remaining battery life. When these balances deviate from the ideal, a state of discomfort is indicated, and when they approach the ideal, a state of pleasure is indicated. An emotion map can be generated, for example, based on Dr. Mitsuyoshi's emotion map (Research on Voice Emotion Recognition and Emotional Brain Physiological Signal Analysis Systems, Tokushima University, Doctoral Dissertation: https: / / ci.nii.ac.jp / naid / 500000375379). The left half of the emotion map lists emotions belonging to the "reaction" domain, where sensation is dominant. The right half of the emotion map lists emotions belonging to the "situation" domain, where situational awareness is dominant.

[1449] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1450] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1451] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1452] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1453] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1454] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1455] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1456] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1457] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1458] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1459] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1460] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1461] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1462] The following is further disclosed regarding the above embodiment.

[1463] (Claim 1)

[1464] means for a user to input a test data generation request;

[1465] means for the server to receive and analyze input data from a user;

[1466] A means for generating test data based on the infrastructure, development environment, and components used by the server;

[1467] a means for the server to validate and, if necessary, correct the generated data;

[1468] a means by which the server provides the verified test data to the user;

[1469] A system including:

[1470] (Claim 2)

[1471] a verification means for verifying whether the generated test data satisfies specified conditions;

[1472] a means for regenerating or correcting a portion that has failed verification if there is an inconsistency in the generated data;

[1473] 10. The system of claim 1, comprising:

[1474] (Claim 3)

[1475] A means for the server to refer to past test data and data patterns and generate new test data based thereon;

[1476] means for converting the generated test data into a specific data format and providing it to a user;

[1477] 10. The system of claim 1, comprising:

[1478] "Example 1"

[1479] (Claim 1)

[1480] means for a user to input a test data generation request;

[1481] means for the server to receive and analyze input data from a user;

[1482] A means for generating test data based on the infrastructure, development environment, and components used by the server;

[1483] a means for the server to validate and, if necessary, correct the generated data;

[1484] a means by which the server provides the verified test data to the user;

[1485] a means for inputting a prompt sentence using a natural language processing model to specify requirements for test data generation when a user requests test data generation;

[1486] A system including:

[1487] (Claim 2)

[1488] a verification means for verifying whether the generated test data satisfies specified conditions;

[1489] a means for regenerating or correcting a portion that has failed verification if there is an inconsistency in the generated data;

[1490] A means for the server to refer to past test data and stored data patterns and generate new test data based thereon;

[1491] 10. The system of claim 1, comprising:

[1492] (Claim 3)

[1493] A means for the server to refer to past test data and data patterns and generate new test data based thereon;

[1494] means for converting the generated test data into a specific data format and providing it to a user;

[1495] A verification method to check whether the generated test data is appropriately distributed within a set period and satisfies specific category conditions;

[1496] 10. The system of claim 1, comprising:

[1497] "Application Example 1"

[1498] (Claim 1)

[1499] means for a user to input a test data generation request;

[1500] means for the server to receive and analyze input data from a user;

[1501] A means for generating test data based on the infrastructure, development environment, and components used by the server;

[1502] a means for inputting parameters required to generate simulation data for an autonomous vehicle;

[1503] means for generating test data based on simulation parameters such as weather conditions and traffic volume;

[1504] a means for verifying and, if necessary, correcting the test data generated;

[1505] a means by which the server provides the verified test data to the user;

[1506] A system including:

[1507] (Claim 2)

[1508] a verification means for verifying whether the generated test data satisfies specified conditions;

[1509] a means for regenerating or correcting a portion that has failed verification if there is an inconsistency in the generated data;

[1510] A means for converting the verified test data into a specific data format and providing it to a user;

[1511] 10. The system of claim 1, comprising:

[1512] (Claim 3)

[1513] A means for the server to refer to past test data and data patterns and generate new test data based thereon;

[1514] A means for converting the data into a specific data format for autonomous vehicle simulation and providing it to a user;

[1515] 10. The system of claim 1, comprising:

[1516] "Example 2: Combining Emotion Engines"

[1517] (Claim 1)

[1518] means for a user to input a test data generation request;

[1519] means for the server to receive and analyze input data from a user;

[1520] A means for analyzing a user's emotions using an emotion engine built into the server;

[1521] A means for the server to generate test data based on the result of the sentiment analysis;

[1522] a means for the server to validate and, if necessary, correct the generated data;

[1523] a means by which the server provides the verified test data to the user;

[1524] A system including:

[1525] (Claim 2)

[1526] a verification means for verifying whether the generated test data satisfies specified conditions;

[1527] a means for regenerating or correcting a portion that has failed verification if there is an inconsistency in the generated data;

[1528] 10. The system of claim 1, comprising:

[1529] (Claim 3)

[1530] A means for the server to refer to past test data and data patterns and generate new test data based thereon;

[1531] means for converting the generated test data into a specific data format and providing it to a user;

[1532] 10. The system of claim 1, comprising:

[1533] "Application example 2 when combining emotion engines"

[1534] (Claim 1)

[1535] means for a user to input a test data generation request;

[1536] means for the server to receive and analyze input data from a user;

[1537] A means for the server to recognize and analyze the user's emotions in real time;

[1538] means for the server to adjust a test data generation algorithm based on the recognized emotions;

[1539] A means for generating test data based on the infrastructure, development environment, and components used by the server;

[1540] a means for the server to validate and, if necessary, correct the generated data;

[1541] a means by which the server provides the verified test data to the user;

[1542] A system including:

[1543] (Claim 2)

[1544] a verification means for verifying whether the generated test data satisfies specified conditions;

[1545] a means for regenerating or correcting a portion that has failed verification if there is an inconsistency in the generated data;

[1546] 10. The system of claim 1, comprising:

[1547] (Claim 3)

[1548] A means for the server to refer to past test data and data patterns and generate new test data based thereon;

[1549] means for converting the generated test data into a specific data format and providing it to a user;

[1550] 10. The system of claim 1, comprising: [Explanation of symbols]

[1551] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. means for a user to input a test data generation request; means for the server to receive and analyze input data from a user; A means for generating test data based on the infrastructure, development environment, and components used by the server; a means for the server to validate and, if necessary, correct the generated data; a means by which the server provides the verified test data to the user; A system including:

2. a verification means for verifying whether the generated test data satisfies specified conditions; a means for regenerating or correcting a portion that has failed verification if there is an inconsistency in the generated data; The system of claim 1 , comprising:

3. A means for the server to refer to past test data and data patterns and generate new test data based thereon; means for converting the generated test data into a specific data format and providing it to a user; The system of claim 1 , comprising:

Images