system

Abstract

Provide a system. A means for a user to register a plurality of attributes, hobbies, skills, and roles; A generating AI means for generating new services based on user registration information; means for notifying a user of the generated service; a means of receiving and managing participation requests; and A means of collecting user feedback and using it to create the next service. A system including:

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] Current metaverse systems have difficulty responding quickly and effectively to diverse user needs. As a result, users often feel dissatisfied and frustrated with their activities in the metaverse space. In particular, the service delivery method is often fixed and does not fully reflect the hobbies and skills of individual users. In such a situation, it is difficult to maximize users' potential, resulting in a limited user experience. [Means for solving the problem]

[0005] This invention provides a means for users to register multiple attributes, hobbies, skills, and roles. Based on this information, a generation AI generates new services that are optimal for the user. The generated services are notified to the user, and the user can select the services they wish to participate in. Furthermore, by collecting feedback from users and using it to generate the next service, it is possible to continue providing services that always meet the user's needs. This provides a new metaverse system that can make the most of the hobbies and skills of individual users and improve the user experience.

[0006] "User information" refers to information such as multiple attributes, hobbies, skills, and roles registered by users of the metaverse system.

[0007] "Generative AI" is an artificial intelligence system that generates new services based on user registration information.

[0008] "Services" are activities such as events, competitions, and workshops planned by generative AI and provided to users.

[0009] "Feedback" refers to information such as evaluations and impressions provided by users after participating.

[0010] A "notification" is a message or alert that conveys generated service information to a user.

[0011] "Assignment" refers to the generation AI assigning a role that is appropriate for a specific user.

[0012] "Means" are methods or processes for accomplishing a particular function recited in a claim.

[0013] "Periodic" means that the process is repeatedly executed at regular intervals. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0022] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0035] This invention describes a specific implementation method of a metaverse system, including a series of processes such as registering user information, generating new services using generation AI, notifying users, collecting participation requests, and obtaining feedback. The following content shows how this invention can be specifically implemented based on the claims of the invention.

[0036] User Registration

[0037] The user accesses the metaverse system using a terminal and displays the login screen. Here, a form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[0038] The terminal sends the input information to the server, formatting the data in JSON or XML format and sending a POST request to the server.

[0039] The server validates the received data and stores it in the database. If validation is successful, the server returns a "Registration successful" message to the user.

[0040] Service planning using generative AI

[0041] The server periodically retrieves user information from the database and sends it to the generation AI. This can be achieved by running a script at a fixed time (every day at midnight), for example.

[0042] The Generative AI generates new services based on the submitted user information, trends, and past feedback data, and determines the specific service content based on the user's interests and skills.

[0043] The generated service information is returned to the server, which then stores it in a database, along with detailed information such as the service overview, start date and time, and participation conditions.

[0044] Running the service

[0045] The server notifies users of new services via email or in-app notifications, and includes details of the service, how to join, and deadlines for joining.

[0046] Users input their participation request and evaluation of the service through their terminal. By entering the necessary information in the participation request form and pressing the "Submit" button, the participation request is sent to the server.

[0047] The server centrally manages the collected participation information and sends it to the generation AI. The generation AI takes into account the participants' skills and past performance and assigns appropriate roles to users. The server stores the assignment results in a database and notifies the user.

[0048] Feedback collection and new service creation

[0049] After the service is executed, the server automatically collects feedback from the user by sending a link to a feedback form via automated email or in-app message.

[0050] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[0051] The server sends the collected feedback data to the generation AI, which analyzes it and uses it to plan new services.

[0052] As a result, the present invention realizes a new metaverse system that continuously provides services based on the user's individual hobbies and skills, improving the user experience.

[0053] The processing flow will be explained below.

[0054] User registration process steps

[0055] Step 1:

[0056] The user uses the terminal to access the login screen of the metaverse system.

[0057] Step 2:

[0058] Users enter information into a form that asks for attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.).

[0059] Step 3:

[0060] The user presses the "Register" button to confirm the entered information.

[0061] Step 4:

[0062] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[0063] Step 5:

[0064] The server validates the received data, checking for required fields and confirming the data format.

[0065] Step 6:

[0066] If the data validation is successful, the server saves the information in the database and returns a "Registration successful" message to the user.

[0067] Processing steps for service planning using generative AI

[0068] Step 1:

[0069] The server executes the script by a scheduled trigger and retrieves user information from the database.

[0070] Step 2:

[0071] The server sends the acquired user information to the generating AI using a REST API or internal communication protocol.

[0072] Step 3:

[0073] The generative AI analyzes the submitted user information and uses specific algorithms to identify trends and patterns.

[0074] Step 4:

[0075] The generative AI generates new service content based on the user's attributes, hobbies, and skills.

[0076] Step 5:

[0077] The generation AI sends the generated service information to the server.

[0078] Step 6:

[0079] The server stores the received service information in a database.

[0080] Processing steps for executing a service

[0081] Step 1:

[0082] The server retrieves new service information and notifies the user via email or in-app notification.

[0083] Step 2:

[0084] The user confirms the notification and accesses the service participation request form.

[0085] Step 3:

[0086] The user inputs the participation information and presses the "Submit" button.

[0087] Step 4:

[0088] The terminal transmits participation request data to the server.

[0089] Step 5:

[0090] The server centrally manages the participation request information and sends it to the generation AI.

[0091] Step 6:

[0092] The generative AI takes into account the user's skills and past performance and assigns them appropriate roles.

[0093] Step 7:

[0094] The server stores the assignment results in a database and notifies the user.

[0095] Processing steps for collecting feedback and creating new services

[0096] Step 1:

[0097] After the service is performed, the server automatically sends the user a link to a feedback form.

[0098] Step 2:

[0099] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[0100] Step 3:

[0101] The terminal transmits the feedback data to the server.

[0102] Step 4:

[0103] The server sends the collected feedback data to the generation AI.

[0104] Step 5:

[0105] The generative AI analyzes the feedback and identifies new ideas and improvements to use in the next service generation.

[0106] Step 6:

[0107] The generating AI sends the new service information to the server and repeats the process.

[0108] Example 1

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

[0110] Conventional metaverse systems have had difficulty providing services that fully reflect the characteristics and interests of users. Furthermore, the feedback function for reflecting generated service evaluations in the next service plan was insufficient. Furthermore, the assignment of appropriate roles in the service was not automated, which could result in a decline in service quality. The present invention aims to provide a metaverse system that solves these problems and improves the user experience.

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

[0112] In this invention, the server includes: a means for a user to register multiple attributes, hobbies, skills, and roles; a means for formatting the registered information in JSON or XML format and sending it to the server; a means for validating the received user information and saving it in a database; a generation AI means for generating a new service based on the user information and past feedback data; a means for saving the generated service information in a database and notifying the user; a means for collecting user information wishing to participate in the service and saving it in a database; a means for sending the collected participation information to the generation AI, assigning appropriate roles, and saving it in the database; and a means for collecting feedback from users after the service is executed and sending it to the generation AI. This enables the continuous provision of a service that reflects the user's characteristics and interests, the improvement of the service based on feedback, and the automatic assignment of optimal roles to participating users.

[0113] A "user" is an entity that accesses the metaverse system and inputs and registers attributes, hobbies, skills, and roles.

[0114] "Terminal" means a computer or mobile device used by a user to access the metaverse system.

[0115] The "server" is a central device that receives information sent by users, validates it, stores it in a database, and works with the generation AI to generate and manage new services.

[0116] "Generative AI" is an artificial intelligence system that generates new services based on user information and past feedback data.

[0117] "Attributes" are basic personal information that users register in the system, such as age, gender, and occupation.

[0118] "Hobbies" refers to activities or interests that a user is interested in, and is information that is registered in the system.

[0119] "Skills" refers to specific skills or knowledge that a user possesses, such as programming or design.

[0120] "Role" refers to the role a user desires to play within the metaverse, including executor, evaluator, etc.

[0121] "JSON" stands for JavaScript (registered trademark) Object Notation, a lightweight data interchange format for representing data in a format that is easy for humans and machines to read.

[0122] "XML" stands for Extensible Markup Language, a markup language used to exchange and store data.

[0123] "Validation" is the process of checking that received user information is in the correct format.

[0124] "Database" refers to a system for storing and managing user information and generated service information.

[0125] "Feedback" refers to evaluations and impressions of the service collected from users after using the service.

[0126] "Participation request" is information that conveys to the system the user's desire to participate in a particular service.

[0127] This paper describes a specific implementation method for a metaverse system that executes a series of processes including user information registration, new service generation by generation AI, notification, collection of participation requests, and feedback acquisition. The distinctive features of this invention include the detailed registration of user information, service generation based on that information, and the importance of feedback.

[0128] User Registration

[0129] A user accesses the metaverse system using a terminal and displays a login screen. Here, the user is presented with a form to input their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). For example, user "A" inputs his / her age "25," gender "male," occupation "engineer," hobby "games," skill "programming," and desired role "executor."

[0130] The device formats the input information in JSON or XML format and sends it to the server via a POST request. This formatted data is then made available to the server. For example, a JSON payload like the following is generated:

[0131] {

[0132] "age": 25,

[0133] "gender": "male",

[0134] "occupation": "engineer",

[0135] "hobby": "gaming",

[0136] "skill": "programming",

[0137] "role_preference": "executor"

[0138] }

[0139] The server validates the received data and stores it in a database, for example by executing the following query against the database:

[0140] INSERT INTO users (age, gender, occupation, hobby, skill, role_preference) VALUES (25, 'male', 'engineer', 'gaming', 'programming', 'executor');

[0141] If validation is successful, the server sends a "Registration successful" message to the user.

[0142] Service planning using generative AI

[0143] The server periodically retrieves user information from the database, for example, at midnight every day, and sends it to the generation AI. This operation is performed through a script or similar.

[0144] The generative AI generates new services based on the received user information and past feedback data. For example, it proposes an "AI programming contest" based on the user information and past feedback.

[0145] The generated service information is returned to the server, which stores it in a database. For example, the following SQL query is executed:

[0146] INSERT INTO services (name, description, start_date, end_date) VALUES ('AI programming contest', 'A contest to test participants' programming skills', '2024-01-01', '2024-01-31');

[0147] To notify you of services and collect your participation preferences

[0148] The server will notify the user of the new service information generated by the server via email or in-app notification. For example, the following notification message will be sent:

[0149] "We're launching a new service, the AI ​​Programming Contest! Click the link for more details."

[0150] After receiving the notification, the user uses the terminal to enter their participation request for the service. For example, they enter their desired participation date and role in the participation request form, and then press the "Submit" button to send their participation request to the server.

[0151] The device formats the entered participation information in JSON format and sends it to the server. The transmitted data is as follows:

[0152] {

[0153] "user_id": 1,

[0154] "service_id": 1,

[0155] "participation_date": "2024-01-03",

[0156] "role": "executor"

[0157] }

[0158] Participant role assignment and notification

[0159] The server centrally manages the collected participation information and sends it to the generation AI, which then takes into account the participants' skills and performance and assigns appropriate roles to users.

[0160] The server stores the role assignment result in a database and notifies the user, for example, by sending a notification saying, "Your role is technical lead."

[0161] Feedback collection and new service creation

[0162] After the service is executed, the server automatically collects feedback from the user by sending a link to a feedback form via automated email or in-app message.

[0163] The user accesses the feedback form, enters their evaluation and thoughts about the service, and submits it. The entered feedback information is sent to the server.

[0164] The server sends the collected feedback data to the generation AI, which analyzes it and uses it to generate the next new service.

[0165] This will realize a new metaverse system that continuously provides services based on the individual hobbies and skills of users, improving the user experience.

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

[0167] Step 1: User Registration

[0168] Input: The user accesses the metaverse system using a terminal and inputs their age, gender, occupation, hobbies, skills, and desired role.

[0169] Action: User "A" inputs his / her age "25 years old", gender "male", occupation "engineer", hobby "gaming", skill "programming", and desired role "executor".

[0170] Data processing: The terminal formats the input information in JSON or XML format and sends it to the server as a POST request.

[0171] {

[0172] "age": 25,

[0173] "gender": "male",

[0174] "occupation": "engineer",

[0175] "hobby": "gaming",

[0176] "skill": "programming",

[0177] "role_preference": "executor"

[0178] }

[0179] Output: The formatted data sent to the server.

[0180] Step 2: Validate and save the data

[0181] Input: User information received by the server from the terminal.

[0182] Data Calculation: The server validates the received data and formats it for storage in the database.

[0183] INSERT INTO users (age, gender, occupation, hobby, skill, role_preference) VALUES (25, 'male', 'engineer', 'gaming', 'programming', 'executor');

[0184] Output: User information stored in the database. If validation is successful, a "Registration successful" message is sent to the user.

[0185] Step 3: Obtaining user information for creating a new service

[0186] Input: A trigger to periodically (e.g., every day at midnight) retrieve user information from the database.

[0187] Operation: The server executes SELECT FROM users; to retrieve all user information.

[0188] Output: User information to send to the generation AI.

[0189] Step 4: Generating new services using generative AI

[0190] Input: User information and past feedback data sent from the server.

[0191] Data calculation: Generative AI analyzes the received information and generates new services based on the user's interests and skills.

[0192] Operation: A service called "AI Programming Contest" is created.

[0193] Output: The generated service information.

[0194] Step 5: Save and notify generated service information

[0195] Input: New service information sent from the generation AI.

[0196] Data processing: The server saves the new service information in the database.

[0197] INSERT INTO services (name, description, start_date, end_date) VALUES ('AI programming contest', 'Contest utilizing programming skills', '2024-01-01', '2024-01-31');

[0198] Action: The server sends a notification to the user saying, "A new service, 'AI Programming Contest', is starting!"

[0199] Output: New service information notified to the user.

[0200] Step 6: Enter and submit your participation request

[0201] Input: The user inputs their desire to join the new service.

[0202] Action: Enter your desired participation date and role in the participation request form and press the "Submit" button. For example, enter January 3, 2024, and enter "Role" as "executor."

[0203] Data processing: The terminal reformats the input information in JSON format again and sends it to the server.

[0204] {

[0205] "user_id": 1,

[0206] "service_id": 1,

[0207] "participation_date": "2024-01-03",

[0208] "role": "executor"

[0209] }

[0210] Output: The participation request sent to the server.

[0211] Step 7: Manage participation preferences and assign roles

[0212] Input: Participation request information sent from the device.

[0213] Data processing: The server stores the participation information in a database and then sends it to the generation AI.

[0214] Data calculation: Generative AI assigns appropriate roles based on participants' information.

[0215] Action: "Yamada Taro" is assigned the role of "Technical Leader."

[0216] Output: An updated database containing the allocation results.

[0217] Step 8: Save and notify role assignment results

[0218] Input: Role assignment results sent from the generation AI.

[0219] Data processing: The server stores the allocation results in a database.

[0220] UPDATE participation_requests SET assigned_role = 'executor' WHERE user_id = 1 AND service_id = 1;

[0221] Action: The server sends a notification to the user stating "Your role is Tech Lead."

[0222] Output: Role assignment result notified to the user.

[0223] Step 9: Collect and send feedback

[0224] Input: Feedback request from user after service execution.

[0225] Action: The server sends the user a link to a feedback form.

[0226] Data processing: The information entered by the user in the feedback form is sent to the server.

[0227] {

[0228] "user_id": 1,

[0229] "service_id": 1,

[0230] "feedback": "The service was very helpful"

[0231] }

[0232] Output: Feedback information sent to the server.

[0233] Step 10: Analyze feedback data and reflect it in the creation of new services

[0234] Input: Feedback data submitted by the user.

[0235] Data calculation: The server sends feedback data to the generation AI, which analyzes it.

[0236] Operation: Based on the analysis results, feedback is reflected in the creation of new services.

[0237] Output: Plan for the next new service that reflects feedback.

[0238] Through these steps, we will realize a metaverse system that improves the user experience by generating services, collecting feedback, and assigning roles based on the user's characteristics and interests.

[0239] (Application example 1)

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

[0241] Conventional metaverse systems and online shopping sites do not adequately propose services based on a user's individual hobbies and skills. As a result, users have difficulty finding the services that best suit them, resulting in a poor user experience. Furthermore, the lack of a mechanism for efficiently utilizing feedback to improve services makes it difficult to improve service quality. The objective of this invention is to solve these problems and provide a system that enables purchasing suggestions and services tailored to the user's individual needs.

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

[0243] In this invention, the server includes a means for users to register multiple attributes, hobbies, skills, and roles; a generation AI means for generating new services based on the user's registered information; a means for notifying the user of the generated services; a means for generating personalized purchasing proposals based on the user's purchasing history, interests, and attributes; and a means for notifying the smart device of the generated purchasing proposals. This allows users to receive services and product proposals that are best suited to them, improving their user experience. Furthermore, by analyzing feedback information and reflecting it in future services, the quality of the service can be continuously improved.

[0244] "User" refers to an individual or corporation that accesses the metaverse system or online shopping site and registers information such as attributes, hobbies, skills, and role.

[0245] "Attributes" refers to basic information such as a user's age, gender, occupation, and location.

[0246] "Hobbies" refers to activities or subjects that interest a user, such as music, sports, reading, etc.

[0247] "Skills" refer to specific skills or abilities that a user possesses, such as programming, design, writing, etc.

[0248] "Role" refers to the specific role a user wishes to play within the system, e.g., performer, evaluator, etc.

[0249] "Generative AI means" refers to artificial intelligence that generates new services and purchasing suggestions based on users' registered information.

[0250] "Service" refers to a specific activity, project, or content generated by Generative AI Means and made available to Users.

[0251] "Purchase Suggestions" refers to personalized product and service suggestions generated by generative AI means based on a user's preferences, purchasing history, and attributes.

[0252] "Notification means" refers to means for informing users of generated services or purchase offers, such as email notifications or in-app notifications.

[0253] "Feedback" refers to the act of a user providing evaluations, impressions, opinions, etc. regarding a service or purchase proposal.

[0254] "Smart device" refers to a smartphone, tablet, smart glasses, head-mounted display, or robot used by a user.

[0255] The present invention relates to a metaverse system and an online shopping site that includes a series of processes such as registering user information, generating new services using a generation AI, notifying users, collecting participation requests, and obtaining feedback. Specific embodiments for implementing the present invention are described in detail below.

[0256] A system embodying the invention includes the following main components:

[0257] A terminal for registering and managing user information

[0258] A server that uses generative AI to generate new services and purchase proposals

[0259] Communication method for notifying smart devices

[0260] A means of collecting and analyzing user feedback

[0261] 1. User Registration

[0262] The user accesses the system using a terminal and displays the login screen. A form is displayed in which the user can enter attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button. The terminal then sends the entered information to the server. This data is formatted in JSON or XML format and sent to the server via a POST request. The server validates the received data and saves it in a database. If validation is successful, the server sends the user a "Registration successful" message.

[0263] 2. Service planning and purchasing proposals using generative AI

[0264] The server periodically retrieves user information from the database and sends it to the generation AI. Based on this, the generation AI generates suitable service and product suggestions based on the user information. The generation AI model is built using frameworks such as TENSORFLOW (registered trademark). The generated service information and purchase suggestions are returned to the server and stored in a database. Detailed information such as the service overview, start date and time, and participation conditions are also stored.

[0265] 3. Service notifications and purchase offer notifications

[0266] The server notifies the user of newly generated services and purchase proposals via email or in-app notifications. The notification includes information such as service overview, participation method, and participation deadline. At the same time, the user is also notified of the purchase proposals generated by the generative AI model.

[0267] 4. Gathering Participation and Feedback

[0268] Users input their participation request and evaluation into the service via their device. By entering the necessary information into the participation request form and pressing the "Submit" button, their participation request is sent to the server. The collected participation request information is centrally managed and sent to the generation AI. The generation AI assigns appropriate roles to users, taking into account their skills and past performance. The server stores the results of this assignment in a database and notifies the user.

[0269] 5. Use feedback

[0270] After the service is performed, the server automatically collects feedback from the user. A link to a feedback form is sent via automated email or in-app message. The user accesses the feedback form, enters their evaluation and thoughts about the service, and submits it. The server sends the collected feedback data to the generation AI, which analyzes it and uses it to plan new services. This makes it possible to continuously provide purchasing suggestions and services based on the user's individual hobbies and skills, improving the user experience.

[0271] Prompt Sentence Examples

[0272] An example of a prompt sentence when generating a service for the generation AI is:

[0273] "Generate content based on the following user data to propose the next project. User Data: { 'Age': 25, 'Gender': 'Male', 'Occupation': 'Engineer', 'Interests': ['Music'], 'Skills': ['Programming'], 'Role': 'Executor'}"

[0274] It is possible to input this information into a generative AI model in the following way.

[0275] The above is an embodiment of the present invention, which makes it possible to provide purchasing suggestions and services tailored to the user's needs, thereby achieving a more sophisticated user experience.

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

[0277] Step 1:

[0278] Users use a terminal to access the system through a login screen, where they enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). This information is entered into a form on the terminal, and by pressing the "Register" button, the data is converted into JSON format and sent to the server. The server validates the received data and saves it in a database. If validation is successful, the server sends a "Registration successful" message to the user.

[0279] Step 2:

[0280] The server periodically retrieves user information from the database and sends it to the generative AI model. In this step, a program executes a scheduled trigger to automatically retrieve user data. The retrieved data includes the user's attributes, hobbies, skills, and role information, and provides prompts to the generative AI model based on this information. Based on the prompts, the generative AI model generates new services and purchasing suggestions. The generated results are returned to the server and stored in the database.

[0281] Step 3:

[0282] The server notifies users of newly generated services and purchase offers via email or in-app notifications. The notifications include a service overview, start date and time, participation conditions, and purchase offers generated by the generative AI model. This information is retrieved from the database and sent to the corresponding users.

[0283] Step 4:

[0284] Users enter their participation request and evaluation into the service via their device. By entering the necessary information into the participation request form and pressing the "Submit" button, their participation request is sent to the server. The collected participation request information is managed centrally and sent to the generative AI model. The generative AI model assigns appropriate roles to users, taking into account their skills and past performance. The server stores the results of this assignment in a database and notifies the user.

[0285] Step 5:

[0286] After the service is performed, the server automatically collects feedback from the user. A link to a feedback form is sent via automated email or in-app message. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The server sends the collected feedback data to the generative AI model, which analyzes it and uses it to plan new services. This makes it possible to continuously provide purchasing suggestions and services based on the user's individual hobbies and skills, improving the user experience.

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

[0288] This invention describes a specific implementation method of a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, obtains feedback, and also recognizes user emotions using an emotion engine and reflects them in the generation of services. The content shown below shows how this invention can be specifically implemented based on the claims of the invention.

[0289] User Registration

[0290] The user accesses the metaverse system using a terminal and displays a login screen. A form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[0291] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[0292] The server validates the received data, checking for required fields and confirming the data format. If validation is successful, it saves the information in the database and returns a "Registration successful" message to the user.

[0293] Service planning using generative AI

[0294] The server executes the script using a scheduled trigger and retrieves user information from the database.

[0295] The server sends the acquired user information to the generating AI via a REST API or internal communication protocol.

[0296] The Generator AI analyzes the submitted user information and uses specific algorithms to identify counter trends and patterns.

[0297] The generative AI generates new service content based on the user's attributes, hobbies, and skills. It also analyzes the user's emotional information using an emotion engine and adjusts the content of the service accordingly.

[0298] The generated service information is returned to the server, which then stores it in a database. Detailed information such as the service overview, start date and time, and participation conditions is saved.

[0299] Running the service

[0300] The server retrieves new service information and notifies the user via email or in-app notification.

[0301] The user confirms the notification and accesses the service participation request form.

[0302] The user inputs the participation information and presses the "Submit" button.

[0303] The terminal transmits participation request data to the server.

[0304] The server centrally manages the participation request information and sends it to the generation AI, which then takes into account the information from the emotion engine and the user's emotional state to assign an appropriate role to the user.

[0305] The server stores the assignment results in a database and notifies the user.

[0306] Feedback collection and new service creation

[0307] After the service is performed, the server automatically sends the user a link to a feedback form.

[0308] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[0309] The terminal transmits the feedback data to the server.

[0310] The server sends the collected feedback data and user emotional information to the generation AI.

[0311] The generative AI analyzes the feedback and incorporates the user's emotions recognized by the emotion engine to generate new services. For example, it can reflect specific elements that the user expressed positive emotions about in the next service.

[0312] As a result, the present invention realizes a new metaverse system that continuously provides services that reflect the individual hobbies, skills, and even emotions of users, thereby improving the user experience.

[0313] The processing flow will be explained below.

[0314] User registration process steps

[0315] Step 1:

[0316] The user uses the terminal to access the login screen of the metaverse system.

[0317] Step 2:

[0318] Users enter information into a form that asks for attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.).

[0319] Step 3:

[0320] The user presses the "Register" button to confirm the entered information.

[0321] Step 4:

[0322] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[0323] Step 5:

[0324] The server validates the received data, checking for required items and confirming the data format.

[0325] Step 6:

[0326] If the data validation is successful, the server saves the information in the database and returns a "Registration successful" message to the user.

[0327] Processing steps for service planning using generative AI

[0328] Step 1:

[0329] The server executes the script using a scheduled trigger and retrieves user information from the database.

[0330] Step 2:

[0331] The server sends the acquired user information to the generating AI via a REST API or internal communication protocol.

[0332] Step 3:

[0333] The generative AI analyzes the submitted user information and uses specific algorithms to identify trends and patterns.

[0334] Step 4:

[0335] The generative AI generates new service content based on the user's attributes, hobbies, and skills. It also analyzes the user's emotional information using an emotion engine and adjusts the content of the service accordingly.

[0336] Step 5:

[0337] The generation AI sends the generated service information to the server.

[0338] Step 6:

[0339] The server stores the received service information in a database.

[0340] Processing steps for executing a service

[0341] Step 1:

[0342] The server retrieves new service information and notifies the user via email or in-app notification.

[0343] Step 2:

[0344] The user confirms the notification and accesses the service participation request form.

[0345] Step 3:

[0346] The user inputs the participation information and presses the "Submit" button.

[0347] Step 4:

[0348] The terminal transmits participation request data to the server.

[0349] Step 5:

[0350] The server centrally manages the participation request information and sends it to the generation AI.

[0351] Step 6:

[0352] The generative AI considers the user's skills and past performance to assign an appropriate role to the user, taking into account the user's emotional state through the addition of information from the emotion engine.

[0353] Step 7:

[0354] The server stores the assignment results in a database and notifies the user.

[0355] Processing steps for collecting feedback and creating new services

[0356] Step 1:

[0357] After the service is performed, the server automatically sends the user a link to a feedback form.

[0358] Step 2:

[0359] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[0360] Step 3:

[0361] The terminal transmits the feedback data to the server.

[0362] Step 4:

[0363] The server sends the collected feedback data and user emotional information to the generation AI.

[0364] Step 5:

[0365] The generative AI analyzes the feedback and incorporates the user's emotions recognized by the emotion engine to generate new services. For example, it can reflect specific elements that the user expressed positive emotions about in the next service.

[0366] Step 6:

[0367] The generating AI sends the new service information to the server and repeats the process.

[0368] Example 2

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

[0370] Although conventional systems provided services based on the user's attributes, hobbies, and skills, they had issues with insufficient adjustment of services based on the user's emotional information and insufficient reflection of feedback.In addition, they did not generate services using generative AI or assign roles that incorporated emotional information, making it difficult to improve the user experience.

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

[0372] In this invention, the server includes: means for a user to register multiple attributes, hobbies, skills, and roles; means for sending the information entered by the user to the server in a specified format; means for validating the data received by the server and storing it in a database; means for acquiring user information by a regular trigger and sending it to a generation AI means; generation AI means for generating a new service based on the user's attributes, hobbies, skills, and emotional information; means for storing the generated service information in a database and notifying the user; means for receiving and managing the user's service participation preference information; generation AI means for analyzing the user's emotional information and assigning an appropriate role to the user; means for sending a user feedback form and collecting feedback data after the service is executed; and means for analyzing the collected feedback data and reflecting it in the next service.

[0373] This makes it possible to continuously provide services that reflect the user's individual hobbies, skills, and even emotions, improving the user experience.

[0374] "User" refers to an individual or organization that accesses the Metaverse System and uses the Services.

[0375] "Attributes" is a general term for personal information such as a user's age, sex, and occupation.

[0376] "Hobbies" refer to activities or areas of interest that a user enjoys in their free time.

[0377] "Skills" refer to specific abilities or expertise that a user possesses.

[0378] A "role" refers to the responsibility or position that a user must fulfill within a service.

[0379] "Server" is a general term for a computing device that provides functions such as validating user information, storing data, communicating with the generation AI, and generating and notifying new services.

[0380] "Generative AI means" refers to artificial intelligence technologies and algorithms for generating new service content based on user information.

[0381] "Validation" is the process of checking whether received data conforms to the expected format and content.

[0382] A "database" refers to a system for efficiently storing, managing, and searching structured data.

[0383] A "timed trigger" refers to a mechanism that automatically executes a specified operation or task at a specific time interval.

[0384] "Emotional information" refers to data that quantifies the user's emotional state through analysis.

[0385] "Feedback" refers to evaluations and opinions of users regarding the services provided.

[0386] MODE FOR CARRYING OUT THE INVENTION

[0387] This invention describes a specific implementation method of a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, and obtains feedback, and also recognizes user emotions using an emotion engine to reflect these in the generation of services. This metaverse system is configured using the following hardware and software:

[0388] Hardware and software used

[0389] Terminal: A device through which a user accesses the Metaverse system. Examples include PCs, smartphones, and tablets.

[0390] Server: Provides functions such as managing user information, data validation, communication with generation AI, access to databases, and generation and notification of new services. An example is a cloud server (such as AWS (registered trademark) EC2).

[0391] Database: A system for storing, managing, and searching structured data. Examples include MySQL (registered trademark) and PostgreSQL.

[0392] Generative AI: Artificial intelligence technology for generating new service content based on user information. An example is a generative AI model such as GPT-4 (registered trademark).

[0393] Emotion engine: An engine that analyzes user emotional information and reflects it in service generation. An example is Affectiva.

[0394] Specific implementation methods of the system

[0395] 1. User Registration:

[0396] The user accesses the metaverse system using a terminal and displays the login screen. The login screen displays a form for entering attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[0397] The terminal formats the entered information in JSON format and sends a POST request to the server. The server validates the received data, checking for required fields and confirming the data format. If validation is successful, the information is saved in the database and a "Registration successful" message is sent back to the user.

[0398] 2. Service planning using generative AI:

[0399] The server runs a script using a scheduled trigger (e.g., a cron job) to retrieve user information from a database. The server then sends the retrieved user information to the generation AI via a REST API. The generation AI analyzes the user information and identifies countertrends and patterns using specific algorithms (e.g., clustering). The generation AI generates new service content based on the user's attributes, hobbies, and skills. During this process, it uses an emotion engine to analyze the user's emotional information and adjusts the service content based on that. The generated service information is returned to the server, which then stores it in a database.

[0400] 3. Running the service:

[0401] The server obtains new service information and notifies the user via email or in-app notification (e.g., SendGrid, Firebase Cloud Messaging). The user checks the notification and accesses the service participation request form. The user enters the participation request information and presses the "Submit" button. The device sends the participation request data to the server. The server centrally manages the participation request information and sends it to the generation AI. The generation AI assigns an appropriate role to the user based on the information from the emotion engine.

[0402] 4. Feedback collection and new service creation:

[0403] After the service is performed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The device sends the feedback data to the server. The server sends the collected feedback data and the user's emotional information to the generation AI. The generation AI analyzes the feedback and generates a new service based on the data from the emotion engine. Positive feedback elements are reflected in the next service.

[0404] Examples of concrete examples and prompts

[0405] As an example, here is a prompt to input to a generative AI model:

[0406] "Create a new metaverse service based on user information. The following is the information for each user:

[0407] Age: 25

[0408] Gender: Male

[0409] Occupation: Software Engineer

[0410] Hobbies: Games, music

[0411] Skills: Programming, design

[0412] Desired role: Executor

[0413] Additionally, the emotion engine analysis indicates that this user is currently excited and looking for new challenges. Please generate new services that reflect this information.

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

[0415] User Registration

[0416] Step 1:

[0417] The user accesses the metaverse system using a terminal, and a login screen appears.

[0418] Input: Accessed by the user through a terminal.

[0419] Output: The login screen is displayed.

[0420] Step 2:

[0421] On the login screen, users enter information about their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.), and then press the "Register" button.

[0422] Input: The user enters information about their attributes, hobbies, skills, and desired role.

[0423] Output: Information entered by the user is sent to the terminal.

[0424] Step 3:

[0425] The terminal formats the input information in JSON format and sends a POST request to the server.

[0426] Input: Information entered by the user.

[0427] Output: The formatted user information is sent to the server.

[0428] Step 4:

[0429] The server validates the received user information, checks for required fields and confirms the data format. If validation is successful, the data is saved in the database.

[0430] Input: User information received by the server.

[0431] Output: Validation result. If successful, the information is saved to the database. After saving, a "Registration successful" message is returned to the user.

[0432] Service planning using generative AI

[0433] Step 5:

[0434] The server runs the script using a scheduled trigger (e.g., a cron job) and retrieves user information from the database.

[0435] Input: The script to be executed by the scheduled trigger.

[0436] Output: User information retrieved from the database.

[0437] Step 6:

[0438] The server sends the acquired user information to the generation AI via a REST API.

[0439] Input: The retrieved user information.

[0440] Output: The user information sent.

[0441] Step 7:

[0442] Generative AI analyzes user information and uses specific algorithms (e.g., clustering) to identify countertrends and patterns.

[0443] Input: The submitted user information.

[0444] Output: Pattern recognition results and new service content.

[0445] Step 8:

[0446] The generation AI generates new service content based on the user's attributes, hobbies, skills, and emotional information, and sends the generated service information to the server.

[0447] Input: Pattern recognition results and user attributes, hobbies, skills, and emotional information.

[0448] Output: The generated service information.

[0449] Step 9:

[0450] The server stores the received service information in a database.

[0451] Input: The generated service information.

[0452] Output: Service information stored in a database.

[0453] Running the service

[0454] Step 10:

[0455] The server retrieves new service information and notifies the user via email or in-app notification.

[0456] Input: Service information stored in the database.

[0457] Output: Service information sent via email and in-app notifications.

[0458] Step 11:

[0459] The user confirms the notification, accesses the service participation request form, enters the participation information, and presses the "Submit" button.

[0460] Input: Service participation information.

[0461] Output: The participation request information sent by the user is sent to the terminal.

[0462] Step 12:

[0463] The terminal transmits participation request data to the server.

[0464] Input: The participation information entered by the user.

[0465] Output: The participation request data sent to the server.

[0466] Step 13:

[0467] The server centrally manages the participation request information and sends it to the generation AI, which then assigns appropriate roles to users based on the information from the emotion engine.

[0468] Input: participation preference and emotion engine data.

[0469] Output: Data that assigns the most suitable role to the user.

[0470] Step 14:

[0471] The server stores the assignment results in a database and notifies the user.

[0472] Input: Assignment result.

[0473] Output: Assignment results stored in the database and notifications sent to the user.

[0474] Feedback collection and new service creation

[0475] Step 15:

[0476] After the service is executed, the server automatically sends the user a link to a feedback form.

[0477] Input: Trigger for service execution completion.

[0478] Output: The feedback form link sent to the user.

[0479] Step 16:

[0480] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[0481] Input: User ratings and comments.

[0482] Output: The feedback data sent.

[0483] Step 17:

[0484] The terminal transmits the feedback data to the server.

[0485] Input: Feedback information entered by the user.

[0486] Output: Feedback data sent to the server.

[0487] Step 18:

[0488] The server sends the collected feedback data and emotional information to the generation AI.

[0489] Input: Collected feedback data and sentiment information.

[0490] Output: Feedback data and emotional information sent to the generative AI.

[0491] Step 19:

[0492] The generative AI analyzes the feedback and generates new services based on the emotion engine data, incorporating positive feedback elements into the next service.

[0493] Input: Submitted feedback data and sentiment information.

[0494] Output: Data required for the next service generation.

[0495] This allows us to continue to provide optimal services based on the individuality and emotions of each user.

[0496] (Application example 2)

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

[0498] Conventional metaverse systems have had difficulty providing services that fully reflect the diverse needs and emotional states of users. Additionally, product recommendations in virtual environments are not personalized, which hinders the improvement of the user experience.

[0499] The specification processing by the specification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for a user to register multiple attributes, hobbies, skills, and roles; a generation AI means for generating a new service based on the user's registration information; a means for notifying the user of the generated service; a means for receiving and managing participation requests; a means for collecting feedback from the user and using it to generate the next service; an emotion engine means for recognizing the user's emotions and adjusting the service content in real time; and a means for making product suggestions in a virtual environment. This makes it possible to provide personalized services and product suggestions that reflect the user's individual needs and emotions.

[0500] A "user" is a person who accesses the system and registers their attributes, hobbies, skills, and roles.

[0501] "Attributes" are basic information including the user's age, gender, occupation, and so on.

[0502] A "hobby" is an activity that a user likes to do (e.g., games, music, sports, etc.).

[0503] A "skill" is a specific ability or expertise that a user has (e.g., programming, design, writing, etc.).

[0504] A "role" is the position a user desires to assume within the system (e.g., executor, evaluator, etc.).

[0505] The "generative AI means" is an artificial intelligence that generates new services based on the user's registered information and assigns the most suitable role to the user.

[0506] The "notification means" is a means for notifying the user of the generated service information.

[0507] The "means for receiving and managing participation requests" is a means for collecting and managing information on users' desire to participate in the service.

[0508] The "means for collecting and utilizing feedback" refers to a means for collecting user feedback and utilizing it in creating the next service.

[0509] The "emotion engine means" is an engine for recognizing the user's emotions and adjusting the service content in real time.

[0510] A "virtual environment" is a virtual space that users can access via the Internet to browse and purchase products.

[0511] The "means for making product suggestions" is a means for suggesting appropriate products to the user.

[0512] MODE FOR CARRYING OUT THE INVENTION

[0513] This invention describes a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, and obtains feedback, and also recognizes user emotions using an emotion engine, which is then reflected in the service content in real time. The invention is specifically implemented by combining the various means shown below.

[0514] User Registration

[0515] A user accesses the metaverse system using a device such as a smartphone and displays a login screen. A form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button. The device formats the entered information in JSON or XML format and sends a POST request to the server.

[0516] Service planning using generative AI

[0517] The server executes a script at a scheduled trigger and retrieves user information from the database. The server then sends the retrieved user information to the generation AI via a REST API or internal communication protocol. The generation AI analyzes the sent user information and uses a specific algorithm to identify reverse trends and patterns. The generation AI generates new service content based on the user's attributes, hobbies, and skills. Here, an emotion engine is used to analyze the user's emotional information and adjust the service content based on that. The generated service information is returned to the server, which stores it in a database.

[0518] Service execution and user notification

[0519] The server obtains new service information and notifies the user via email or in-app notification. The user checks the notification and accesses the service participation request form. The user enters the participation request information and presses the "Submit" button. The device sends the participation request data to the server. The server centrally manages the participation request information and sends it to the generation AI. Here, the generation AI takes into account information from the emotion engine and considers the user's emotional state to assign an appropriate role to the user. The server saves the assignment results in a database and notifies the user.

[0520] Collecting and analyzing feedback

[0521] After the service is performed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The device sends the feedback data to the server. The server sends the collected feedback data and the user's emotional information to the generation AI. The generation AI analyzes the feedback, incorporates the user's emotions recognized by the emotion engine, and uses them to generate new services.

[0522] Specific examples

[0523] For example, by inputting the following prompt sentence into a generative AI model, it is possible to suggest the best product for the user.

[0524] Prompt Sentence Examples

[0525] "I'm a 30-year-old male engineer whose hobbies are games and music. Please suggest products and services that will interest him."

[0526] This enables the generative AI to provide personalized services and product suggestions that reflect the individual needs and emotions of the user.

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

[0528] Step 1:

[0529] A user accesses the metaverse system using a device such as a smartphone and displays a login screen. A form is displayed in which the user enters their attributes, hobbies, skills, and desired role. This information is formatted by the device into JSON or XML format and sent to the server as a POST request.

[0530] Input: User-entered attributes, hobbies, skills, and roles

[0531] Output: The formatted user information is sent to the server

[0532] Step 2:

[0533] The server validates the received user information, checking for required fields and confirming the data format. If validation is successful, it saves the information in the database and returns a "Registration successful" message to the user. If validation fails, it notifies the user with an error message.

[0534] Input: User information sent from the device

[0535] Output: Validation results and saved data or error messages

[0536] Step 3:

[0537] The server periodically executes a trigger script to retrieve accumulated user information from the database. This user information is then sent to the generation AI via a REST API or internal communication protocol. The generation AI analyzes the user registration information and uses specific algorithms to identify trends and patterns.

[0538] Input: User information retrieved from the database

[0539] Output: Analyzed trends and patterns

[0540] Step 4:

[0541] The generation AI generates new service content based on the user's attributes, hobbies, skills, and emotional information provided by the emotion engine. This information is returned to the server, which stores it in a database. The generated service information includes details such as a service overview, start date and time, and participation conditions.

[0542] Input: Analyzed user attributes, hobbies, skills, and emotional information

[0543] Output: Generated new service information

[0544] Step 5:

[0545] The server sends the newly generated service information to the user via email or in-app notification. The user receives the notification and clicks the link in the notification to access the service registration form.

[0546] Input: Generated new service information

[0547] Output: Notification to the user

[0548] Step 6:

[0549] The user enters their desired information into the service participation request form and presses the "Submit" button. The device then sends this participation request information to the server. The server then centrally manages the participation request information and sends it to the generation AI.

[0550] Input: User-entered participation information

[0551] Output: The participation request sent to the server

[0552] Step 7:

[0553] The generative AI takes into account the data from the emotion engine and the user's emotional state to assign an appropriate role to the user. The assignment results are sent back to the server and stored in a database. The server then notifies the user of the assignment results.

[0554] Input: User participation preference information and emotion engine data

[0555] Output: Assignment result notified to the user

[0556] Step 8:

[0557] After the service is executed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and impressions of the service, and submits it. The terminal then sends the feedback data to the server.

[0558] Input: User feedback information

[0559] Output: Feedback information sent to the server

[0560] Step 9:

[0561] The server sends the collected feedback data and user emotion information to the generation AI, which analyzes the feedback and incorporates the user emotion recognized by the emotion engine to generate new services.

[0562] Input: User feedback data and emotional information

[0563] Output: New services generated based on the analyzed feedback results

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

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

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

[0567] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0580] This invention describes a specific implementation method of a metaverse system, including a series of processes such as registering user information, generating new services using generation AI, notifying users, collecting participation requests, and obtaining feedback. The following content shows how this invention can be specifically implemented based on the claims of the invention.

[0581] User Registration

[0582] The user accesses the metaverse system using a terminal and displays the login screen. Here, a form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[0583] The terminal sends the input information to the server, formatting the data in JSON or XML format and sending a POST request to the server.

[0584] The server validates the received data and stores it in the database. If validation is successful, the server returns a "Registration successful" message to the user.

[0585] Service planning using generative AI

[0586] The server periodically retrieves user information from the database and sends it to the generation AI. This can be achieved by running a script at a fixed time (every day at midnight), for example.

[0587] The Generative AI generates new services based on the submitted user information, trends, and past feedback data, and determines the specific service content based on the user's interests and skills.

[0588] The generated service information is returned to the server, which then stores it in a database, along with detailed information such as the service overview, start date and time, and participation conditions.

[0589] Running the service

[0590] The server notifies users of new services via email or in-app notifications, and includes details of the service, how to join, and deadlines for joining.

[0591] Users input their participation request and evaluation of the service through their terminal. By entering the necessary information in the participation request form and pressing the "Submit" button, the participation request is sent to the server.

[0592] The server centrally manages the collected participation information and sends it to the generation AI. The generation AI takes into account the participants' skills and past performance and assigns appropriate roles to users. The server stores the assignment results in a database and notifies the user.

[0593] Feedback collection and new service creation

[0594] After the service is executed, the server automatically collects feedback from the user by sending a link to a feedback form via automated email or in-app message.

[0595] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[0596] The server sends the collected feedback data to the generation AI, which analyzes it and uses it to plan new services.

[0597] As a result, the present invention realizes a new metaverse system that continuously provides services based on the user's individual hobbies and skills, improving the user experience.

[0598] The processing flow will be explained below.

[0599] User registration process steps

[0600] Step 1:

[0601] The user uses the terminal to access the login screen of the metaverse system.

[0602] Step 2:

[0603] Users enter information into a form that asks for attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.).

[0604] Step 3:

[0605] The user presses the "Register" button to confirm the entered information.

[0606] Step 4:

[0607] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[0608] Step 5:

[0609] The server validates the received data, checking for required fields and confirming the data format.

[0610] Step 6:

[0611] If the data validation is successful, the server saves the information in the database and returns a "Registration successful" message to the user.

[0612] Processing steps for service planning using generative AI

[0613] Step 1:

[0614] The server executes the script by a scheduled trigger and retrieves user information from the database.

[0615] Step 2:

[0616] The server sends the acquired user information to the generating AI using a REST API or internal communication protocol.

[0617] Step 3:

[0618] The generative AI analyzes the submitted user information and uses specific algorithms to identify trends and patterns.

[0619] Step 4:

[0620] The generative AI generates new service content based on the user's attributes, hobbies, and skills.

[0621] Step 5:

[0622] The generation AI sends the generated service information to the server.

[0623] Step 6:

[0624] The server stores the received service information in a database.

[0625] Processing steps for executing a service

[0626] Step 1:

[0627] The server retrieves new service information and notifies the user via email or in-app notification.

[0628] Step 2:

[0629] The user confirms the notification and accesses the service participation request form.

[0630] Step 3:

[0631] The user inputs the participation information and presses the "Submit" button.

[0632] Step 4:

[0633] The terminal transmits participation request data to the server.

[0634] Step 5:

[0635] The server centrally manages the participation request information and sends it to the generation AI.

[0636] Step 6:

[0637] The generative AI takes into account the user's skills and past performance and assigns them appropriate roles.

[0638] Step 7:

[0639] The server stores the assignment results in a database and notifies the user.

[0640] Processing steps for collecting feedback and creating new services

[0641] Step 1:

[0642] After the service is performed, the server automatically sends the user a link to a feedback form.

[0643] Step 2:

[0644] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[0645] Step 3:

[0646] The terminal transmits the feedback data to the server.

[0647] Step 4:

[0648] The server sends the collected feedback data to the generation AI.

[0649] Step 5:

[0650] The generative AI analyzes the feedback and identifies new ideas and improvements to use in the next service generation.

[0651] Step 6:

[0652] The generating AI sends the new service information to the server and repeats the process.

[0653] Example 1

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

[0655] Conventional metaverse systems have had difficulty providing services that fully reflect the characteristics and interests of users. Furthermore, the feedback function for reflecting generated service evaluations in the next service plan was insufficient. Furthermore, the assignment of appropriate roles in the service was not automated, which could result in a decline in service quality. The present invention aims to provide a metaverse system that solves these problems and improves the user experience.

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

[0657] In this invention, the server includes: a means for a user to register multiple attributes, hobbies, skills, and roles; a means for formatting the registered information in JSON or XML format and sending it to the server; a means for validating the received user information and saving it in a database; a generation AI means for generating a new service based on the user information and past feedback data; a means for saving the generated service information in a database and notifying the user; a means for collecting user information wishing to participate in the service and saving it in a database; a means for sending the collected participation information to the generation AI, assigning appropriate roles, and saving it in the database; and a means for collecting feedback from users after the service is executed and sending it to the generation AI. This enables the continuous provision of a service that reflects the user's characteristics and interests, the improvement of the service based on feedback, and the automatic assignment of optimal roles to participating users.

[0658] A "user" is an entity that accesses the metaverse system and inputs and registers attributes, hobbies, skills, and roles.

[0659] "Terminal" means a computer or mobile device used by a user to access the metaverse system.

[0660] The "server" is a central device that receives information sent by users, validates it, stores it in a database, and works with the generation AI to generate and manage new services.

[0661] "Generative AI" is an artificial intelligence system that generates new services based on user information and past feedback data.

[0662] "Attributes" are basic personal information that users register in the system, such as age, gender, and occupation.

[0663] "Hobbies" refers to activities or interests that a user is interested in, and is information that is registered in the system.

[0664] "Skills" refers to specific skills or knowledge that a user possesses, such as programming or design.

[0665] "Role" refers to the role a user desires to play within the metaverse, including executor, evaluator, etc.

[0666] "JSON" stands for JavaScript Object Notation, a lightweight data interchange format for representing data in a human- and machine-readable format.

[0667] "XML" stands for Extensible Markup Language, a markup language used to exchange and store data.

[0668] "Validation" is the process of checking that received user information is in the correct format.

[0669] "Database" refers to a system for storing and managing user information and generated service information.

[0670] "Feedback" refers to evaluations and impressions of the service collected from users after using the service.

[0671] "Participation request" is information that conveys to the system the user's desire to participate in a particular service.

[0672] This paper describes a specific implementation method for a metaverse system that executes a series of processes including user information registration, new service generation by generation AI, notification, collection of participation requests, and feedback acquisition. The distinctive features of this invention include the detailed registration of user information, service generation based on that information, and the importance of feedback.

[0673] User Registration

[0674] A user accesses the metaverse system using a terminal and displays a login screen. Here, the user is presented with a form to input their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). For example, user "A" inputs his / her age "25," gender "male," occupation "engineer," hobby "games," skill "programming," and desired role "executor."

[0675] The device formats the input information in JSON or XML format and sends it to the server via a POST request. This formatted data is then made available to the server. For example, a JSON payload like the following is generated:

[0676] {

[0677] "age": 25,

[0678] "gender": "male",

[0679] "occupation": "engineer",

[0680] "hobby": "gaming",

[0681] "skill": "programming",

[0682] "role_preference": "executor"

[0683] }

[0684] The server validates the received data and stores it in a database, for example by executing the following query against the database:

[0685] INSERT INTO users (age, gender, occupation, hobby, skill, role_preference) VALUES (25, 'male', 'engineer', 'gaming', 'programming', 'executor');

[0686] If validation is successful, the server sends a "Registration successful" message to the user.

[0687] Service planning using generative AI

[0688] The server periodically retrieves user information from the database, for example, at midnight every day, and sends it to the generation AI. This operation is performed through a script or similar.

[0689] The generative AI generates new services based on the received user information and past feedback data. For example, it proposes an "AI programming contest" based on the user information and past feedback.

[0690] The generated service information is returned to the server, which stores it in a database. For example, the following SQL query is executed:

[0691] INSERT INTO services (name, description, start_date, end_date) VALUES ('AI programming contest', 'A contest to test participants' programming skills', '2024-01-01', '2024-01-31');

[0692] To notify you of services and collect your participation preferences

[0693] The server will notify the user of the new service information generated by the server via email or in-app notification. For example, the following notification message will be sent:

[0694] "We're launching a new service, the AI ​​Programming Contest! Click the link for more details."

[0695] After receiving the notification, the user uses the terminal to enter their participation request for the service. For example, they enter their desired participation date and role in the participation request form, and then press the "Submit" button to send their participation request to the server.

[0696] The device formats the entered participation information in JSON format and sends it to the server. The transmitted data is as follows:

[0697] {

[0698] "user_id": 1,

[0699] "service_id": 1,

[0700] "participation_date": "2024-01-03",

[0701] "role": "executor"

[0702] }

[0703] Participant role assignment and notification

[0704] The server centrally manages the collected participation information and sends it to the generation AI, which then takes into account the participants' skills and performance and assigns appropriate roles to users.

[0705] The server stores the role assignment result in a database and notifies the user, for example, by sending a notification saying, "Your role is technical lead."

[0706] Feedback collection and new service creation

[0707] After the service is executed, the server automatically collects feedback from the user by sending a link to a feedback form via automated email or in-app message.

[0708] The user accesses the feedback form, enters their evaluation and thoughts about the service, and submits it. The entered feedback information is sent to the server.

[0709] The server sends the collected feedback data to the generation AI, which analyzes it and uses it to generate the next new service.

[0710] This will realize a new metaverse system that continuously provides services based on the individual hobbies and skills of users, improving the user experience.

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

[0712] Step 1: User Registration

[0713] Input: The user accesses the metaverse system using a terminal and inputs their age, gender, occupation, hobbies, skills, and desired role.

[0714] Action: User "A" inputs his / her age "25 years old", gender "male", occupation "engineer", hobby "gaming", skill "programming", and desired role "executor".

[0715] Data processing: The terminal formats the input information in JSON or XML format and sends it to the server as a POST request.

[0716] {

[0717] "age": 25,

[0718] "gender": "male",

[0719] "occupation": "engineer",

[0720] "hobby": "gaming",

[0721] "skill": "programming",

[0722] "role_preference": "executor"

[0723] }

[0724] Output: The formatted data sent to the server.

[0725] Step 2: Validate and save the data

[0726] Input: User information received by the server from the terminal.

[0727] Data Calculation: The server validates the received data and formats it for storage in the database.

[0728] INSERT INTO users (age, gender, occupation, hobby, skill, role_preference) VALUES (25, 'male', 'engineer', 'gaming', 'programming', 'executor');

[0729] Output: User information stored in the database. If validation is successful, a "Registration successful" message is sent to the user.

[0730] Step 3: Obtaining user information for creating a new service

[0731] Input: A trigger to periodically (e.g., every day at midnight) retrieve user information from the database.

[0732] Operation: The server executes SELECT FROM users; to retrieve all user information.

[0733] Output: User information to send to the generation AI.

[0734] Step 4: Generating new services using generative AI

[0735] Input: User information and past feedback data sent from the server.

[0736] Data calculation: Generative AI analyzes the received information and generates new services based on the user's interests and skills.

[0737] Operation: A service called "AI Programming Contest" is created.

[0738] Output: The generated service information.

[0739] Step 5: Save and notify generated service information

[0740] Input: New service information sent from the generation AI.

[0741] Data processing: The server saves the new service information in the database.

[0742] INSERT INTO services (name, description, start_date, end_date) VALUES ('AI programming contest', 'Contest utilizing programming skills', '2024-01-01', '2024-01-31');

[0743] Action: The server sends a notification to the user saying, "A new service, 'AI Programming Contest', is starting!"

[0744] Output: New service information notified to the user.

[0745] Step 6: Enter and submit your participation request

[0746] Input: The user inputs their desire to join the new service.

[0747] Action: Enter your desired participation date and role in the participation request form and press the "Submit" button. For example, enter January 3, 2024, and enter "Role" as "executor."

[0748] Data processing: The terminal reformats the input information in JSON format again and sends it to the server.

[0749] {

[0750] "user_id": 1,

[0751] "service_id": 1,

[0752] "participation_date": "2024-01-03",

[0753] "role": "executor"

[0754] }

[0755] Output: The participation request sent to the server.

[0756] Step 7: Manage participation preferences and assign roles

[0757] Input: Participation request information sent from the device.

[0758] Data processing: The server stores the participation information in a database and then sends it to the generation AI.

[0759] Data calculation: Generative AI assigns appropriate roles based on participants' information.

[0760] Action: "Yamada Taro" is assigned the role of "Technical Leader."

[0761] Output: An updated database containing the allocation results.

[0762] Step 8: Save and notify role assignment results

[0763] Input: Role assignment results sent from the generation AI.

[0764] Data processing: The server stores the allocation results in a database.

[0765] UPDATE participation_requests SET assigned_role = 'executor' WHERE user_id = 1 AND service_id = 1;

[0766] Action: The server sends a notification to the user stating "Your role is Tech Lead."

[0767] Output: Role assignment result notified to the user.

[0768] Step 9: Collect and send feedback

[0769] Input: Feedback request from user after service execution.

[0770] Action: The server sends the user a link to a feedback form.

[0771] Data processing: The information entered by the user in the feedback form is sent to the server.

[0772] {

[0773] "user_id": 1,

[0774] "service_id": 1,

[0775] "feedback": "The service was very helpful"

[0776] }

[0777] Output: Feedback information sent to the server.

[0778] Step 10: Analyze feedback data and reflect it in the creation of new services

[0779] Input: Feedback data submitted by the user.

[0780] Data calculation: The server sends feedback data to the generation AI, which analyzes it.

[0781] Operation: Based on the analysis results, feedback is reflected in the creation of new services.

[0782] Output: Plan for the next new service that reflects feedback.

[0783] Through these steps, we will realize a metaverse system that improves the user experience by generating services, collecting feedback, and assigning roles based on the user's characteristics and interests.

[0784] (Application example 1)

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

[0786] Conventional metaverse systems and online shopping sites do not adequately propose services based on a user's individual hobbies and skills. As a result, users have difficulty finding the services that best suit them, resulting in a poor user experience. Furthermore, the lack of a mechanism for efficiently utilizing feedback to improve services makes it difficult to improve service quality. The objective of this invention is to solve these problems and provide a system that enables purchasing suggestions and services tailored to the user's individual needs.

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

[0788] In this invention, the server includes a means for users to register multiple attributes, hobbies, skills, and roles; a generation AI means for generating new services based on the user's registered information; a means for notifying the user of the generated services; a means for generating personalized purchasing proposals based on the user's purchasing history, interests, and attributes; and a means for notifying the smart device of the generated purchasing proposals. This allows users to receive services and product proposals that are best suited to them, improving their user experience. Furthermore, by analyzing feedback information and reflecting it in future services, the quality of the service can be continuously improved.

[0789] "User" refers to an individual or corporation that accesses the metaverse system or online shopping site and registers information such as attributes, hobbies, skills, and role.

[0790] "Attributes" refers to basic information such as a user's age, gender, occupation, and location.

[0791] "Hobbies" refers to activities or subjects that interest a user, such as music, sports, reading, etc.

[0792] "Skills" refer to specific skills or abilities that a user possesses, such as programming, design, writing, etc.

[0793] "Role" refers to the specific role a user wishes to play within the system, e.g., performer, evaluator, etc.

[0794] "Generative AI means" refers to artificial intelligence that generates new services and purchasing suggestions based on users' registered information.

[0795] "Service" refers to a specific activity, project, or content generated by Generative AI Means and made available to Users.

[0796] "Purchase Suggestions" refers to personalized product and service suggestions generated by generative AI means based on a user's preferences, purchasing history, and attributes.

[0797] "Notification means" refers to means for informing users of generated services or purchase offers, such as email notifications or in-app notifications.

[0798] "Feedback" refers to the act of a user providing evaluations, impressions, opinions, etc. regarding a service or purchase proposal.

[0799] "Smart device" refers to a smartphone, tablet, smart glasses, head-mounted display, or robot used by a user.

[0800] The present invention relates to a metaverse system and an online shopping site that includes a series of processes such as registering user information, generating new services using a generation AI, notifying users, collecting participation requests, and obtaining feedback. Specific embodiments for implementing the present invention are described in detail below.

[0801] A system embodying the invention includes the following main components:

[0802] A terminal for registering and managing user information

[0803] A server that uses generative AI to generate new services and purchase proposals

[0804] Communication method for notifying smart devices

[0805] A means of collecting and analyzing user feedback

[0806] 1. User Registration

[0807] The user accesses the system using a terminal and displays the login screen. A form is displayed in which the user can enter attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button. The terminal then sends the entered information to the server. This data is formatted in JSON or XML format and sent to the server via a POST request. The server validates the received data and saves it in a database. If validation is successful, the server sends the user a "Registration successful" message.

[0808] 2. Service planning and purchasing proposals using generative AI

[0809] The server periodically retrieves user information from the database and sends it to the generation AI. Based on this, the generation AI generates suitable service and product suggestions based on the user information. The generative AI model is built using frameworks such as TensorFlow. The generated service information and purchase suggestions are returned to the server and stored in a database. Detailed information such as the service overview, start date and time, and participation conditions are also stored.

[0810] 3. Service notifications and purchase offer notifications

[0811] The server notifies the user of newly generated services and purchase proposals via email or in-app notifications. The notification includes information such as service overview, participation method, and participation deadline. At the same time, the user is also notified of the purchase proposals generated by the generative AI model.

[0812] 4. Gathering Participation and Feedback

[0813] Users input their participation request and evaluation into the service via their device. By entering the necessary information into the participation request form and pressing the "Submit" button, their participation request is sent to the server. The collected participation request information is centrally managed and sent to the generation AI. The generation AI assigns appropriate roles to users, taking into account their skills and past performance. The server stores the results of this assignment in a database and notifies the user.

[0814] 5. Use feedback

[0815] After the service is performed, the server automatically collects feedback from the user. A link to a feedback form is sent via automated email or in-app message. The user accesses the feedback form, enters their evaluation and thoughts about the service, and submits it. The server sends the collected feedback data to the generation AI, which analyzes it and uses it to plan new services. This makes it possible to continuously provide purchasing suggestions and services based on the user's individual hobbies and skills, improving the user experience.

[0816] Prompt Sentence Examples

[0817] An example of a prompt sentence when generating a service for the generation AI is:

[0818] "Generate content based on the following user data to propose the next project. User Data: { 'Age': 25, 'Gender': 'Male', 'Occupation': 'Engineer', 'Interests': ['Music'], 'Skills': ['Programming'], 'Role': 'Executor'}"

[0819] It is possible to input this information into a generative AI model in the following way.

[0820] The above is an embodiment of the present invention, which makes it possible to provide purchasing suggestions and services tailored to the user's needs, thereby achieving a more sophisticated user experience.

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

[0822] Step 1:

[0823] Users use a terminal to access the system through a login screen, where they enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). This information is entered into a form on the terminal, and by pressing the "Register" button, the data is converted into JSON format and sent to the server. The server validates the received data and saves it in a database. If validation is successful, the server sends a "Registration successful" message to the user.

[0824] Step 2:

[0825] The server periodically retrieves user information from the database and sends it to the generative AI model. In this step, a program executes a scheduled trigger to automatically retrieve user data. The retrieved data includes the user's attributes, hobbies, skills, and role information, and provides prompts to the generative AI model based on this information. Based on the prompts, the generative AI model generates new services and purchasing suggestions. The generated results are returned to the server and stored in the database.

[0826] Step 3:

[0827] The server notifies users of newly generated services and purchase offers via email or in-app notifications. The notifications include a service overview, start date and time, participation conditions, and purchase offers generated by the generative AI model. This information is retrieved from the database and sent to the corresponding users.

[0828] Step 4:

[0829] Users enter their participation request and evaluation into the service via their device. By entering the necessary information into the participation request form and pressing the "Submit" button, their participation request is sent to the server. The collected participation request information is managed centrally and sent to the generative AI model. The generative AI model assigns appropriate roles to users, taking into account their skills and past performance. The server stores the results of this assignment in a database and notifies the user.

[0830] Step 5:

[0831] After the service is performed, the server automatically collects feedback from the user. A link to a feedback form is sent via automated email or in-app message. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The server sends the collected feedback data to the generative AI model, which analyzes it and uses it to plan new services. This makes it possible to continuously provide purchasing suggestions and services based on the user's individual hobbies and skills, improving the user experience.

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

[0833] This invention describes a specific implementation method of a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, obtains feedback, and also recognizes user emotions using an emotion engine and reflects them in the generation of services. The content shown below shows how this invention can be specifically implemented based on the claims of the invention.

[0834] User Registration

[0835] The user accesses the metaverse system using a terminal and displays a login screen. A form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[0836] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[0837] The server validates the received data, checking for required fields and confirming the data format. If validation is successful, it saves the information in the database and returns a "Registration successful" message to the user.

[0838] Service planning using generative AI

[0839] The server executes the script using a scheduled trigger and retrieves user information from the database.

[0840] The server sends the acquired user information to the generating AI via a REST API or internal communication protocol.

[0841] The Generator AI analyzes the submitted user information and uses specific algorithms to identify counter trends and patterns.

[0842] The generative AI generates new service content based on the user's attributes, hobbies, and skills. It also analyzes the user's emotional information using an emotion engine and adjusts the content of the service accordingly.

[0843] The generated service information is returned to the server, which then stores it in a database. Detailed information such as the service overview, start date and time, and participation conditions is saved.

[0844] Running the service

[0845] The server retrieves new service information and notifies the user via email or in-app notification.

[0846] The user confirms the notification and accesses the service participation request form.

[0847] The user inputs the participation information and presses the "Submit" button.

[0848] The terminal transmits participation request data to the server.

[0849] The server centrally manages the participation request information and sends it to the generation AI, which then takes into account the information from the emotion engine and the user's emotional state to assign an appropriate role to the user.

[0850] The server stores the assignment results in a database and notifies the user.

[0851] Feedback collection and new service creation

[0852] After the service is performed, the server automatically sends the user a link to a feedback form.

[0853] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[0854] The terminal transmits the feedback data to the server.

[0855] The server sends the collected feedback data and user emotional information to the generation AI.

[0856] The generative AI analyzes the feedback and incorporates the user's emotions recognized by the emotion engine to generate new services. For example, it can reflect specific elements that the user expressed positive emotions about in the next service.

[0857] As a result, the present invention realizes a new metaverse system that continuously provides services that reflect the individual hobbies, skills, and even emotions of users, thereby improving the user experience.

[0858] The processing flow will be explained below.

[0859] User registration process steps

[0860] Step 1:

[0861] The user uses the terminal to access the login screen of the metaverse system.

[0862] Step 2:

[0863] Users enter information into a form that asks for attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.).

[0864] Step 3:

[0865] The user presses the "Register" button to confirm the entered information.

[0866] Step 4:

[0867] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[0868] Step 5:

[0869] The server validates the received data, checking for required items and confirming the data format.

[0870] Step 6:

[0871] If the data validation is successful, the server saves the information in the database and returns a "Registration successful" message to the user.

[0872] Processing steps for service planning using generative AI

[0873] Step 1:

[0874] The server executes the script using a scheduled trigger and retrieves user information from the database.

[0875] Step 2:

[0876] The server sends the acquired user information to the generating AI via a REST API or internal communication protocol.

[0877] Step 3:

[0878] The generative AI analyzes the submitted user information and uses specific algorithms to identify trends and patterns.

[0879] Step 4:

[0880] The generative AI generates new service content based on the user's attributes, hobbies, and skills. It also analyzes the user's emotional information using an emotion engine and adjusts the content of the service accordingly.

[0881] Step 5:

[0882] The generation AI sends the generated service information to the server.

[0883] Step 6:

[0884] The server stores the received service information in a database.

[0885] Processing steps for executing a service

[0886] Step 1:

[0887] The server retrieves new service information and notifies the user via email or in-app notification.

[0888] Step 2:

[0889] The user confirms the notification and accesses the service participation request form.

[0890] Step 3:

[0891] The user inputs the participation information and presses the "Submit" button.

[0892] Step 4:

[0893] The terminal transmits participation request data to the server.

[0894] Step 5:

[0895] The server centrally manages the participation request information and sends it to the generation AI.

[0896] Step 6:

[0897] The generative AI considers the user's skills and past performance to assign an appropriate role to the user, taking into account the user's emotional state through the addition of information from the emotion engine.

[0898] Step 7:

[0899] The server stores the assignment results in a database and notifies the user.

[0900] Processing steps for collecting feedback and creating new services

[0901] Step 1:

[0902] After the service is performed, the server automatically sends the user a link to a feedback form.

[0903] Step 2:

[0904] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[0905] Step 3:

[0906] The terminal transmits the feedback data to the server.

[0907] Step 4:

[0908] The server sends the collected feedback data and user emotional information to the generation AI.

[0909] Step 5:

[0910] The generative AI analyzes the feedback and incorporates the user's emotions recognized by the emotion engine to generate new services. For example, it can reflect specific elements that the user expressed positive emotions about in the next service.

[0911] Step 6:

[0912] The generating AI sends the new service information to the server and repeats the process.

[0913] Example 2

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

[0915] Although conventional systems provided services based on the user's attributes, hobbies, and skills, they had issues with insufficient adjustment of services based on the user's emotional information and insufficient reflection of feedback.In addition, they did not generate services using generative AI or assign roles that incorporated emotional information, making it difficult to improve the user experience.

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

[0917] In this invention, the server includes: means for a user to register multiple attributes, hobbies, skills, and roles; means for sending the information entered by the user to the server in a specified format; means for validating the data received by the server and storing it in a database; means for acquiring user information by a regular trigger and sending it to a generation AI means; generation AI means for generating a new service based on the user's attributes, hobbies, skills, and emotional information; means for storing the generated service information in a database and notifying the user; means for receiving and managing the user's service participation preference information; generation AI means for analyzing the user's emotional information and assigning an appropriate role to the user; means for sending a user feedback form and collecting feedback data after the service is executed; and means for analyzing the collected feedback data and reflecting it in the next service.

[0918] This makes it possible to continuously provide services that reflect the user's individual hobbies, skills, and even emotions, improving the user experience.

[0919] "User" refers to an individual or organization that accesses the Metaverse System and uses the Services.

[0920] "Attributes" is a general term for personal information such as a user's age, sex, and occupation.

[0921] "Hobbies" refer to activities or areas of interest that a user enjoys in their free time.

[0922] "Skills" refer to specific abilities or expertise that a user possesses.

[0923] A "role" refers to the responsibility or position that a user must fulfill within a service.

[0924] "Server" is a general term for a computing device that provides functions such as validating user information, storing data, communicating with the generation AI, and generating and notifying new services.

[0925] "Generative AI means" refers to artificial intelligence technologies and algorithms for generating new service content based on user information.

[0926] "Validation" is the process of checking whether received data conforms to the expected format and content.

[0927] A "database" refers to a system for efficiently storing, managing, and searching structured data.

[0928] A "timed trigger" refers to a mechanism that automatically executes a specified operation or task at a specific time interval.

[0929] "Emotional information" refers to data that quantifies the user's emotional state through analysis.

[0930] "Feedback" refers to evaluations and opinions of users regarding the services provided.

[0931] MODE FOR CARRYING OUT THE INVENTION

[0932] This invention describes a specific implementation method of a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, and obtains feedback, and also recognizes user emotions using an emotion engine to reflect these in the generation of services. This metaverse system is configured using the following hardware and software:

[0933] Hardware and software used

[0934] Terminal: A device through which a user accesses the Metaverse system. Examples include PCs, smartphones, and tablets.

[0935] Server: Provides functions such as managing user information, data validation, communication with the generation AI, accessing the database, generating new services, and notifications. An example is a cloud server (such as AWS EC2).

[0936] Database: A system for storing, managing, and searching structured data. Examples include MySQL and PostgreSQL.

[0937] Generative AI: Artificial intelligence technology that generates new service content based on user information. Examples include generative AI models such as GPT-4.

[0938] Emotion engine: An engine that analyzes user emotional information and reflects it in service generation. An example is Affectiva.

[0939] Specific implementation methods of the system

[0940] 1. User Registration:

[0941] The user accesses the metaverse system using a terminal and displays the login screen. The login screen displays a form for entering attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[0942] The terminal formats the entered information in JSON format and sends a POST request to the server. The server validates the received data, checking for required fields and confirming the data format. If validation is successful, the information is saved in the database and a "Registration successful" message is sent back to the user.

[0943] 2. Service planning using generative AI:

[0944] The server runs a script using a scheduled trigger (e.g., a cron job) to retrieve user information from a database. The server then sends the retrieved user information to the generation AI via a REST API. The generation AI analyzes the user information and identifies countertrends and patterns using specific algorithms (e.g., clustering). The generation AI generates new service content based on the user's attributes, hobbies, and skills. During this process, it uses an emotion engine to analyze the user's emotional information and adjusts the service content based on that. The generated service information is returned to the server, which then stores it in a database.

[0945] 3. Running the service:

[0946] The server obtains new service information and notifies the user via email or in-app notification (e.g., SendGrid, Firebase Cloud Messaging). The user checks the notification and accesses the service participation request form. The user enters the participation request information and presses the "Submit" button. The device sends the participation request data to the server. The server centrally manages the participation request information and sends it to the generation AI. The generation AI assigns an appropriate role to the user based on the information from the emotion engine.

[0947] 4. Feedback collection and new service creation:

[0948] After the service is performed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The device sends the feedback data to the server. The server sends the collected feedback data and the user's emotional information to the generation AI. The generation AI analyzes the feedback and generates a new service based on the data from the emotion engine. Positive feedback elements are reflected in the next service.

[0949] Examples of concrete examples and prompts

[0950] As an example, here is a prompt to input to a generative AI model:

[0951] "Create a new metaverse service based on user information. The following is the information for each user:

[0952] Age: 25

[0953] Gender: Male

[0954] Occupation: Software Engineer

[0955] Hobbies: Games, music

[0956] Skills: Programming, design

[0957] Desired role: Executor

[0958] Additionally, the emotion engine analysis indicates that this user is currently excited and looking for new challenges. Please generate new services that reflect this information.

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

[0960] User Registration

[0961] Step 1:

[0962] The user accesses the metaverse system using a terminal, and a login screen appears.

[0963] Input: Accessed by the user through a terminal.

[0964] Output: The login screen is displayed.

[0965] Step 2:

[0966] On the login screen, users enter information about their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.), and then press the "Register" button.

[0967] Input: The user enters information about their attributes, hobbies, skills, and desired role.

[0968] Output: Information entered by the user is sent to the terminal.

[0969] Step 3:

[0970] The terminal formats the input information in JSON format and sends a POST request to the server.

[0971] Input: Information entered by the user.

[0972] Output: The formatted user information is sent to the server.

[0973] Step 4:

[0974] The server validates the received user information, checks for required fields and confirms the data format. If validation is successful, the data is saved in the database.

[0975] Input: User information received by the server.

[0976] Output: Validation result. If successful, the information is saved to the database. After saving, a "Registration successful" message is returned to the user.

[0977] Service planning using generative AI

[0978] Step 5:

[0979] The server runs the script using a scheduled trigger (e.g., a cron job) and retrieves user information from the database.

[0980] Input: The script to be executed by the scheduled trigger.

[0981] Output: User information retrieved from the database.

[0982] Step 6:

[0983] The server sends the acquired user information to the generation AI via a REST API.

[0984] Input: The retrieved user information.

[0985] Output: The user information sent.

[0986] Step 7:

[0987] Generative AI analyzes user information and uses specific algorithms (e.g., clustering) to identify countertrends and patterns.

[0988] Input: The submitted user information.

[0989] Output: Pattern recognition results and new service content.

[0990] Step 8:

[0991] The generation AI generates new service content based on the user's attributes, hobbies, skills, and emotional information, and sends the generated service information to the server.

[0992] Input: Pattern recognition results and user attributes, hobbies, skills, and emotional information.

[0993] Output: The generated service information.

[0994] Step 9:

[0995] The server stores the received service information in a database.

[0996] Input: The generated service information.

[0997] Output: Service information stored in a database.

[0998] Running the service

[0999] Step 10:

[1000] The server retrieves new service information and notifies the user via email or in-app notification.

[1001] Input: Service information stored in the database.

[1002] Output: Service information sent via email and in-app notifications.

[1003] Step 11:

[1004] The user confirms the notification, accesses the service participation request form, enters the participation information, and presses the "Submit" button.

[1005] Input: Service participation information.

[1006] Output: The participation request information sent by the user is sent to the terminal.

[1007] Step 12:

[1008] The terminal transmits participation request data to the server.

[1009] Input: The participation information entered by the user.

[1010] Output: The participation request data sent to the server.

[1011] Step 13:

[1012] The server centrally manages the participation request information and sends it to the generation AI, which then assigns appropriate roles to users based on the information from the emotion engine.

[1013] Input: participation preference and emotion engine data.

[1014] Output: Data that assigns the most suitable role to the user.

[1015] Step 14:

[1016] The server stores the assignment results in a database and notifies the user.

[1017] Input: Assignment result.

[1018] Output: Assignment results stored in the database and notifications sent to the user.

[1019] Feedback collection and new service creation

[1020] Step 15:

[1021] After the service is executed, the server automatically sends the user a link to a feedback form.

[1022] Input: Trigger for service execution completion.

[1023] Output: The feedback form link sent to the user.

[1024] Step 16:

[1025] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[1026] Input: User ratings and comments.

[1027] Output: The feedback data sent.

[1028] Step 17:

[1029] The terminal transmits the feedback data to the server.

[1030] Input: Feedback information entered by the user.

[1031] Output: Feedback data sent to the server.

[1032] Step 18:

[1033] The server sends the collected feedback data and emotional information to the generation AI.

[1034] Input: Collected feedback data and sentiment information.

[1035] Output: Feedback data and emotional information sent to the generative AI.

[1036] Step 19:

[1037] The generative AI analyzes the feedback and generates new services based on the emotion engine data, incorporating positive feedback elements into the next service.

[1038] Input: Submitted feedback data and sentiment information.

[1039] Output: Data required for the next service generation.

[1040] This allows us to continue to provide optimal services based on the individuality and emotions of each user.

[1041] (Application example 2)

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

[1043] Conventional metaverse systems have had difficulty providing services that fully reflect the diverse needs and emotional states of users. Additionally, product recommendations in virtual environments are not personalized, which hinders the improvement of the user experience.

[1044] The specification processing by the specification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for a user to register multiple attributes, hobbies, skills, and roles; a generation AI means for generating a new service based on the user's registration information; a means for notifying the user of the generated service; a means for receiving and managing participation requests; a means for collecting feedback from the user and using it to generate the next service; an emotion engine means for recognizing the user's emotions and adjusting the service content in real time; and a means for making product suggestions in a virtual environment. This makes it possible to provide personalized services and product suggestions that reflect the user's individual needs and emotions.

[1045] A "user" is a person who accesses the system and registers their attributes, hobbies, skills, and roles.

[1046] "Attributes" are basic information including the user's age, gender, occupation, and so on.

[1047] A "hobby" is an activity that a user likes to do (e.g., games, music, sports, etc.).

[1048] A "skill" is a specific ability or expertise that a user has (e.g., programming, design, writing, etc.).

[1049] A "role" is the position a user desires to assume within the system (e.g., executor, evaluator, etc.).

[1050] The "generative AI means" is an artificial intelligence that generates new services based on the user's registered information and assigns the most suitable role to the user.

[1051] The "notification means" is a means for notifying the user of the generated service information.

[1052] The "means for receiving and managing participation requests" is a means for collecting and managing information on users' desire to participate in the service.

[1053] The "means for collecting and utilizing feedback" refers to a means for collecting user feedback and utilizing it in creating the next service.

[1054] The "emotion engine means" is an engine for recognizing the user's emotions and adjusting the service content in real time.

[1055] A "virtual environment" is a virtual space that users can access via the Internet to browse and purchase products.

[1056] The "means for making product suggestions" is a means for suggesting appropriate products to the user.

[1057] MODE FOR CARRYING OUT THE INVENTION

[1058] This invention describes a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, and obtains feedback, and also recognizes user emotions using an emotion engine, which is then reflected in the service content in real time. The invention is specifically implemented by combining the various means shown below.

[1059] User Registration

[1060] A user accesses the metaverse system using a device such as a smartphone and displays a login screen. A form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button. The device formats the entered information in JSON or XML format and sends a POST request to the server.

[1061] Service planning using generative AI

[1062] The server executes a script at a scheduled trigger and retrieves user information from the database. The server then sends the retrieved user information to the generation AI via a REST API or internal communication protocol. The generation AI analyzes the sent user information and uses a specific algorithm to identify reverse trends and patterns. The generation AI generates new service content based on the user's attributes, hobbies, and skills. Here, an emotion engine is used to analyze the user's emotional information and adjust the service content based on that. The generated service information is returned to the server, which stores it in a database.

[1063] Service execution and user notification

[1064] The server obtains new service information and notifies the user via email or in-app notification. The user checks the notification and accesses the service participation request form. The user enters the participation request information and presses the "Submit" button. The device sends the participation request data to the server. The server centrally manages the participation request information and sends it to the generation AI. Here, the generation AI takes into account information from the emotion engine and considers the user's emotional state to assign an appropriate role to the user. The server saves the assignment results in a database and notifies the user.

[1065] Collecting and analyzing feedback

[1066] After the service is performed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The device sends the feedback data to the server. The server sends the collected feedback data and the user's emotional information to the generation AI. The generation AI analyzes the feedback, incorporates the user's emotions recognized by the emotion engine, and uses them to generate new services.

[1067] Specific examples

[1068] For example, by inputting the following prompt sentence into a generative AI model, it is possible to suggest the best product for the user.

[1069] Prompt Sentence Examples

[1070] "I'm a 30-year-old male engineer whose hobbies are games and music. Please suggest products and services that will interest him."

[1071] This enables the generative AI to provide personalized services and product suggestions that reflect the individual needs and emotions of the user.

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

[1073] Step 1:

[1074] A user accesses the metaverse system using a device such as a smartphone and displays a login screen. A form is displayed in which the user enters their attributes, hobbies, skills, and desired role. This information is formatted by the device into JSON or XML format and sent to the server as a POST request.

[1075] Input: User-entered attributes, hobbies, skills, and roles

[1076] Output: The formatted user information is sent to the server

[1077] Step 2:

[1078] The server validates the received user information, checking for required fields and confirming the data format. If validation is successful, it saves the information in the database and returns a "Registration successful" message to the user. If validation fails, it notifies the user with an error message.

[1079] Input: User information sent from the device

[1080] Output: Validation results and saved data or error messages

[1081] Step 3:

[1082] The server periodically executes a trigger script to retrieve accumulated user information from the database. This user information is then sent to the generation AI via a REST API or internal communication protocol. The generation AI analyzes the user registration information and uses specific algorithms to identify trends and patterns.

[1083] Input: User information retrieved from the database

[1084] Output: Analyzed trends and patterns

[1085] Step 4:

[1086] The generation AI generates new service content based on the user's attributes, hobbies, skills, and emotional information provided by the emotion engine. This information is returned to the server, which stores it in a database. The generated service information includes details such as a service overview, start date and time, and participation conditions.

[1087] Input: Analyzed user attributes, hobbies, skills, and emotional information

[1088] Output: Generated new service information

[1089] Step 5:

[1090] The server sends the newly generated service information to the user via email or in-app notification. The user receives the notification and clicks the link in the notification to access the service registration form.

[1091] Input: Generated new service information

[1092] Output: Notification to the user

[1093] Step 6:

[1094] The user enters their desired information into the service participation request form and presses the "Submit" button. The device then sends this participation request information to the server. The server then centrally manages the participation request information and sends it to the generation AI.

[1095] Input: User-entered participation information

[1096] Output: The participation request sent to the server

[1097] Step 7:

[1098] The generative AI takes into account the data from the emotion engine and the user's emotional state to assign an appropriate role to the user. The assignment results are sent back to the server and stored in a database. The server then notifies the user of the assignment results.

[1099] Input: User participation preference information and emotion engine data

[1100] Output: Assignment result notified to the user

[1101] Step 8:

[1102] After the service is executed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and impressions of the service, and submits it. The terminal then sends the feedback data to the server.

[1103] Input: User feedback information

[1104] Output: Feedback information sent to the server

[1105] Step 9:

[1106] The server sends the collected feedback data and user emotion information to the generation AI, which analyzes the feedback and incorporates the user emotion recognized by the emotion engine to generate new services.

[1107] Input: User feedback data and emotional information

[1108] Output: New services generated based on the analyzed feedback results

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

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

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

[1112] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[1125] This invention describes a specific implementation method of a metaverse system, including a series of processes such as registering user information, generating new services using generation AI, notifying users, collecting participation requests, and obtaining feedback. The following content shows how this invention can be specifically implemented based on the claims of the invention.

[1126] User Registration

[1127] The user accesses the metaverse system using a terminal and displays the login screen. Here, a form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[1128] The terminal sends the input information to the server, formatting the data in JSON or XML format and sending a POST request to the server.

[1129] The server validates the received data and stores it in the database. If validation is successful, the server returns a "Registration successful" message to the user.

[1130] Service planning using generative AI

[1131] The server periodically retrieves user information from the database and sends it to the generation AI. This can be achieved by running a script at a fixed time (every day at midnight), for example.

[1132] The Generative AI generates new services based on the submitted user information, trends, and past feedback data, and determines the specific service content based on the user's interests and skills.

[1133] The generated service information is returned to the server, which then stores it in a database, along with detailed information such as the service overview, start date and time, and participation conditions.

[1134] Running the service

[1135] The server notifies users of new services via email or in-app notifications, and includes details of the service, how to join, and deadlines for joining.

[1136] Users input their participation request and evaluation of the service through their terminal. By entering the necessary information in the participation request form and pressing the "Submit" button, the participation request is sent to the server.

[1137] The server centrally manages the collected participation information and sends it to the generation AI. The generation AI takes into account the participants' skills and past performance and assigns appropriate roles to users. The server stores the assignment results in a database and notifies the user.

[1138] Feedback collection and new service creation

[1139] After the service is executed, the server automatically collects feedback from the user by sending a link to a feedback form via automated email or in-app message.

[1140] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[1141] The server sends the collected feedback data to the generation AI, which analyzes it and uses it to plan new services.

[1142] As a result, the present invention realizes a new metaverse system that continuously provides services based on the user's individual hobbies and skills, improving the user experience.

[1143] The processing flow will be explained below.

[1144] User registration process steps

[1145] Step 1:

[1146] The user uses the terminal to access the login screen of the metaverse system.

[1147] Step 2:

[1148] Users enter information into a form that asks for attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.).

[1149] Step 3:

[1150] The user presses the "Register" button to confirm the entered information.

[1151] Step 4:

[1152] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[1153] Step 5:

[1154] The server validates the received data, checking for required fields and confirming the data format.

[1155] Step 6:

[1156] If the data validation is successful, the server saves the information in the database and returns a "Registration successful" message to the user.

[1157] Processing steps for service planning using generative AI

[1158] Step 1:

[1159] The server executes the script by a scheduled trigger and retrieves user information from the database.

[1160] Step 2:

[1161] The server sends the acquired user information to the generating AI using a REST API or internal communication protocol.

[1162] Step 3:

[1163] The generative AI analyzes the submitted user information and uses specific algorithms to identify trends and patterns.

[1164] Step 4:

[1165] The generative AI generates new service content based on the user's attributes, hobbies, and skills.

[1166] Step 5:

[1167] The generation AI sends the generated service information to the server.

[1168] Step 6:

[1169] The server stores the received service information in a database.

[1170] Processing steps for executing a service

[1171] Step 1:

[1172] The server retrieves new service information and notifies the user via email or in-app notification.

[1173] Step 2:

[1174] The user confirms the notification and accesses the service participation request form.

[1175] Step 3:

[1176] The user inputs the participation information and presses the "Submit" button.

[1177] Step 4:

[1178] The terminal transmits participation request data to the server.

[1179] Step 5:

[1180] The server centrally manages the participation request information and sends it to the generation AI.

[1181] Step 6:

[1182] The generative AI takes into account the user's skills and past performance and assigns them appropriate roles.

[1183] Step 7:

[1184] The server stores the assignment results in a database and notifies the user.

[1185] Processing steps for collecting feedback and creating new services

[1186] Step 1:

[1187] After the service is performed, the server automatically sends the user a link to a feedback form.

[1188] Step 2:

[1189] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[1190] Step 3:

[1191] The terminal transmits the feedback data to the server.

[1192] Step 4:

[1193] The server sends the collected feedback data to the generation AI.

[1194] Step 5:

[1195] The generative AI analyzes the feedback and identifies new ideas and improvements to use in the next service generation.

[1196] Step 6:

[1197] The generating AI sends the new service information to the server and repeats the process.

[1198] Example 1

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

[1200] Conventional metaverse systems have had difficulty providing services that fully reflect the characteristics and interests of users. Furthermore, the feedback function for reflecting generated service evaluations in the next service plan was insufficient. Furthermore, the assignment of appropriate roles in the service was not automated, which could result in a decline in service quality. The present invention aims to provide a metaverse system that solves these problems and improves the user experience.

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

[1202] In this invention, the server includes: a means for a user to register multiple attributes, hobbies, skills, and roles; a means for formatting the registered information in JSON or XML format and sending it to the server; a means for validating the received user information and saving it in a database; a generation AI means for generating a new service based on the user information and past feedback data; a means for saving the generated service information in a database and notifying the user; a means for collecting user information wishing to participate in the service and saving it in a database; a means for sending the collected participation information to the generation AI, assigning appropriate roles, and saving it in the database; and a means for collecting feedback from users after the service is executed and sending it to the generation AI. This enables the continuous provision of a service that reflects the user's characteristics and interests, the improvement of the service based on feedback, and the automatic assignment of optimal roles to participating users.

[1203] A "user" is an entity that accesses the metaverse system and inputs and registers attributes, hobbies, skills, and roles.

[1204] "Terminal" means a computer or mobile device used by a user to access the metaverse system.

[1205] The "server" is a central device that receives information sent by users, validates it, stores it in a database, and works with the generation AI to generate and manage new services.

[1206] "Generative AI" is an artificial intelligence system that generates new services based on user information and past feedback data.

[1207] "Attributes" are basic personal information that users register in the system, such as age, gender, and occupation.

[1208] "Hobbies" refers to activities or interests that a user is interested in, and is information that is registered in the system.

[1209] "Skills" refers to specific skills or knowledge that a user possesses, such as programming or design.

[1210] "Role" refers to the role a user desires to play within the metaverse, including executor, evaluator, etc.

[1211] "JSON" stands for JavaScript Object Notation, a lightweight data interchange format for representing data in a human- and machine-readable format.

[1212] "XML" stands for Extensible Markup Language, a markup language used to exchange and store data.

[1213] "Validation" is the process of checking that received user information is in the correct format.

[1214] "Database" refers to a system for storing and managing user information and generated service information.

[1215] "Feedback" refers to evaluations and impressions of the service collected from users after using the service.

[1216] "Participation request" is information that conveys to the system the user's desire to participate in a particular service.

[1217] This paper describes a specific implementation method for a metaverse system that executes a series of processes including user information registration, new service generation by generation AI, notification, collection of participation requests, and feedback acquisition. The distinctive features of this invention include the detailed registration of user information, service generation based on that information, and the importance of feedback.

[1218] User Registration

[1219] A user accesses the metaverse system using a terminal and displays a login screen. Here, the user is presented with a form to input their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). For example, user "A" inputs his / her age "25," gender "male," occupation "engineer," hobby "games," skill "programming," and desired role "executor."

[1220] The device formats the input information in JSON or XML format and sends it to the server via a POST request. This formatted data is then made available to the server. For example, a JSON payload like the following is generated:

[1221] {

[1222] "age": 25,

[1223] "gender": "male",

[1224] "occupation": "engineer",

[1225] "hobby": "gaming",

[1226] "skill": "programming",

[1227] "role_preference": "executor"

[1228] }

[1229] The server validates the received data and stores it in a database, for example by executing the following query against the database:

[1230] INSERT INTO users (age, gender, occupation, hobby, skill, role_preference) VALUES (25, 'male', 'engineer', 'gaming', 'programming', 'executor');

[1231] If validation is successful, the server sends a "Registration successful" message to the user.

[1232] Service planning using generative AI

[1233] The server periodically retrieves user information from the database, for example, at midnight every day, and sends it to the generation AI. This operation is performed through a script or similar.

[1234] The generative AI generates new services based on the received user information and past feedback data. For example, it proposes an "AI programming contest" based on the user information and past feedback.

[1235] The generated service information is returned to the server, which stores it in a database. For example, the following SQL query is executed:

[1236] INSERT INTO services (name, description, start_date, end_date) VALUES ('AI programming contest', 'A contest to test participants' programming skills', '2024-01-01', '2024-01-31');

[1237] To notify you of services and collect your participation preferences

[1238] The server will notify the user of the new service information generated by the server via email or in-app notification. For example, the following notification message will be sent:

[1239] "We're launching a new service, the AI ​​Programming Contest! Click the link for more details."

[1240] After receiving the notification, the user uses the terminal to enter their participation request for the service. For example, they enter their desired participation date and role in the participation request form, and then press the "Submit" button to send their participation request to the server.

[1241] The device formats the entered participation information in JSON format and sends it to the server. The transmitted data is as follows:

[1242] {

[1243] "user_id": 1,

[1244] "service_id": 1,

[1245] "participation_date": "2024-01-03",

[1246] "role": "executor"

[1247] }

[1248] Participant role assignment and notification

[1249] The server centrally manages the collected participation information and sends it to the generation AI, which then takes into account the participants' skills and performance and assigns appropriate roles to users.

[1250] The server stores the role assignment result in a database and notifies the user, for example, by sending a notification saying, "Your role is technical lead."

[1251] Feedback collection and new service creation

[1252] After the service is executed, the server automatically collects feedback from the user by sending a link to a feedback form via automated email or in-app message.

[1253] The user accesses the feedback form, enters their evaluation and thoughts about the service, and submits it. The entered feedback information is sent to the server.

[1254] The server sends the collected feedback data to the generation AI, which analyzes it and uses it to generate the next new service.

[1255] This will realize a new metaverse system that continuously provides services based on the individual hobbies and skills of users, improving the user experience.

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

[1257] Step 1: User Registration

[1258] Input: The user accesses the metaverse system using a terminal and inputs their age, gender, occupation, hobbies, skills, and desired role.

[1259] Action: User "A" inputs his / her age "25 years old", gender "male", occupation "engineer", hobby "gaming", skill "programming", and desired role "executor".

[1260] Data processing: The terminal formats the input information in JSON or XML format and sends it to the server as a POST request.

[1261] {

[1262] "age": 25,

[1263] "gender": "male",

[1264] "occupation": "engineer",

[1265] "hobby": "gaming",

[1266] "skill": "programming",

[1267] "role_preference": "executor"

[1268] }

[1269] Output: The formatted data sent to the server.

[1270] Step 2: Validate and save the data

[1271] Input: User information received by the server from the terminal.

[1272] Data Calculation: The server validates the received data and formats it for storage in the database.

[1273] INSERT INTO users (age, gender, occupation, hobby, skill, role_preference) VALUES (25, 'male', 'engineer', 'gaming', 'programming', 'executor');

[1274] Output: User information stored in the database. If validation is successful, a "Registration successful" message is sent to the user.

[1275] Step 3: Obtaining user information for creating a new service

[1276] Input: A trigger to periodically (e.g., every day at midnight) retrieve user information from the database.

[1277] Operation: The server executes SELECT FROM users; to retrieve all user information.

[1278] Output: User information to send to the generation AI.

[1279] Step 4: Generating new services using generative AI

[1280] Input: User information and past feedback data sent from the server.

[1281] Data calculation: Generative AI analyzes the received information and generates new services based on the user's interests and skills.

[1282] Operation: A service called "AI Programming Contest" is created.

[1283] Output: The generated service information.

[1284] Step 5: Save and notify generated service information

[1285] Input: New service information sent from the generation AI.

[1286] Data processing: The server saves the new service information in the database.

[1287] INSERT INTO services (name, description, start_date, end_date) VALUES ('AI programming contest', 'Contest utilizing programming skills', '2024-01-01', '2024-01-31');

[1288] Action: The server sends a notification to the user saying, "A new service, 'AI Programming Contest', is starting!"

[1289] Output: New service information notified to the user.

[1290] Step 6: Enter and submit your participation request

[1291] Input: The user inputs their desire to join the new service.

[1292] Action: Enter your desired participation date and role in the participation request form and press the "Submit" button. For example, enter January 3, 2024, and enter "Role" as "executor."

[1293] Data processing: The terminal reformats the input information in JSON format again and sends it to the server.

[1294] {

[1295] "user_id": 1,

[1296] "service_id": 1,

[1297] "participation_date": "2024-01-03",

[1298] "role": "executor"

[1299] }

[1300] Output: The participation request sent to the server.

[1301] Step 7: Manage participation preferences and assign roles

[1302] Input: Participation request information sent from the device.

[1303] Data processing: The server stores the participation information in a database and then sends it to the generation AI.

[1304] Data calculation: Generative AI assigns appropriate roles based on participants' information.

[1305] Action: "Yamada Taro" is assigned the role of "Technical Leader."

[1306] Output: An updated database containing the allocation results.

[1307] Step 8: Save and notify role assignment results

[1308] Input: Role assignment results sent from the generation AI.

[1309] Data processing: The server stores the allocation results in a database.

[1310] UPDATE participation_requests SET assigned_role = 'executor' WHERE user_id = 1 AND service_id = 1;

[1311] Action: The server sends a notification to the user stating "Your role is Tech Lead."

[1312] Output: Role assignment result notified to the user.

[1313] Step 9: Collect and send feedback

[1314] Input: Feedback request from user after service execution.

[1315] Action: The server sends the user a link to a feedback form.

[1316] Data processing: The information entered by the user in the feedback form is sent to the server.

[1317] {

[1318] "user_id": 1,

[1319] "service_id": 1,

[1320] "feedback": "The service was very helpful"

[1321] }

[1322] Output: Feedback information sent to the server.

[1323] Step 10: Analyze feedback data and reflect it in the creation of new services

[1324] Input: Feedback data submitted by the user.

[1325] Data calculation: The server sends feedback data to the generation AI, which analyzes it.

[1326] Operation: Based on the analysis results, feedback is reflected in the creation of new services.

[1327] Output: Plan for the next new service that reflects feedback.

[1328] Through these steps, we will realize a metaverse system that improves the user experience by generating services, collecting feedback, and assigning roles based on the user's characteristics and interests.

[1329] (Application example 1)

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

[1331] Conventional metaverse systems and online shopping sites do not adequately propose services based on a user's individual hobbies and skills. As a result, users have difficulty finding the services that best suit them, resulting in a poor user experience. Furthermore, the lack of a mechanism for efficiently utilizing feedback to improve services makes it difficult to improve service quality. The objective of this invention is to solve these problems and provide a system that enables purchasing suggestions and services tailored to the user's individual needs.

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

[1333] In this invention, the server includes a means for users to register multiple attributes, hobbies, skills, and roles; a generation AI means for generating new services based on the user's registered information; a means for notifying the user of the generated services; a means for generating personalized purchasing proposals based on the user's purchasing history, interests, and attributes; and a means for notifying the smart device of the generated purchasing proposals. This allows users to receive services and product proposals that are best suited to them, improving their user experience. Furthermore, by analyzing feedback information and reflecting it in future services, the quality of the service can be continuously improved.

[1334] "User" refers to an individual or corporation that accesses the metaverse system or online shopping site and registers information such as attributes, hobbies, skills, and role.

[1335] "Attributes" refers to basic information such as a user's age, gender, occupation, and location.

[1336] "Hobbies" refers to activities or subjects that interest a user, such as music, sports, reading, etc.

[1337] "Skills" refer to specific skills or abilities that a user possesses, such as programming, design, writing, etc.

[1338] "Role" refers to the specific role a user wishes to play within the system, e.g., performer, evaluator, etc.

[1339] "Generative AI means" refers to artificial intelligence that generates new services and purchasing suggestions based on users' registered information.

[1340] "Service" refers to a specific activity, project, or content generated by Generative AI Means and made available to Users.

[1341] "Purchase Suggestions" refers to personalized product and service suggestions generated by generative AI means based on a user's preferences, purchasing history, and attributes.

[1342] "Notification means" refers to means for informing users of generated services or purchase offers, such as email notifications or in-app notifications.

[1343] "Feedback" refers to the act of a user providing evaluations, impressions, opinions, etc. regarding a service or purchase proposal.

[1344] "Smart device" refers to a smartphone, tablet, smart glasses, head-mounted display, or robot used by a user.

[1345] The present invention relates to a metaverse system and an online shopping site that includes a series of processes such as registering user information, generating new services using a generation AI, notifying users, collecting participation requests, and obtaining feedback. Specific embodiments for implementing the present invention are described in detail below.

[1346] A system embodying the invention includes the following main components:

[1347] A terminal for registering and managing user information

[1348] A server that uses generative AI to generate new services and purchase proposals

[1349] Communication method for notifying smart devices

[1350] A means of collecting and analyzing user feedback

[1351] 1. User Registration

[1352] The user accesses the system using a terminal and displays the login screen. A form is displayed in which the user can enter attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button. The terminal then sends the entered information to the server. This data is formatted in JSON or XML format and sent to the server via a POST request. The server validates the received data and saves it in a database. If validation is successful, the server sends the user a "Registration successful" message.

[1353] 2. Service planning and purchasing proposals using generative AI

[1354] The server periodically retrieves user information from the database and sends it to the generation AI. Based on this, the generation AI generates suitable service and product suggestions based on the user information. The generative AI model is built using frameworks such as TensorFlow. The generated service information and purchase suggestions are returned to the server and stored in a database. Detailed information such as the service overview, start date and time, and participation conditions are also stored.

[1355] 3. Service notifications and purchase offer notifications

[1356] The server notifies the user of newly generated services and purchase proposals via email or in-app notifications. The notification includes information such as service overview, participation method, and participation deadline. At the same time, the user is also notified of the purchase proposals generated by the generative AI model.

[1357] 4. Gathering Participation and Feedback

[1358] Users input their participation request and evaluation into the service via their device. By entering the necessary information into the participation request form and pressing the "Submit" button, their participation request is sent to the server. The collected participation request information is centrally managed and sent to the generation AI. The generation AI assigns appropriate roles to users, taking into account their skills and past performance. The server stores the results of this assignment in a database and notifies the user.

[1359] 5. Use feedback

[1360] After the service is performed, the server automatically collects feedback from the user. A link to a feedback form is sent via automated email or in-app message. The user accesses the feedback form, enters their evaluation and thoughts about the service, and submits it. The server sends the collected feedback data to the generation AI, which analyzes it and uses it to plan new services. This makes it possible to continuously provide purchasing suggestions and services based on the user's individual hobbies and skills, improving the user experience.

[1361] Prompt Sentence Examples

[1362] An example of a prompt sentence when generating a service for the generation AI is:

[1363] "Generate content based on the following user data to propose the next project. User Data: { 'Age': 25, 'Gender': 'Male', 'Occupation': 'Engineer', 'Interests': ['Music'], 'Skills': ['Programming'], 'Role': 'Executor'}"

[1364] It is possible to input this information into a generative AI model in the following way.

[1365] The above is an embodiment of the present invention, which makes it possible to provide purchasing suggestions and services tailored to the user's needs, thereby achieving a more sophisticated user experience.

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

[1367] Step 1:

[1368] Users use a terminal to access the system through a login screen, where they enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). This information is entered into a form on the terminal, and by pressing the "Register" button, the data is converted into JSON format and sent to the server. The server validates the received data and saves it in a database. If validation is successful, the server sends a "Registration successful" message to the user.

[1369] Step 2:

[1370] The server periodically retrieves user information from the database and sends it to the generative AI model. In this step, a program executes a scheduled trigger to automatically retrieve user data. The retrieved data includes the user's attributes, hobbies, skills, and role information, and provides prompts to the generative AI model based on this information. Based on the prompts, the generative AI model generates new services and purchasing suggestions. The generated results are returned to the server and stored in the database.

[1371] Step 3:

[1372] The server notifies users of newly generated services and purchase offers via email or in-app notifications. The notifications include a service overview, start date and time, participation conditions, and purchase offers generated by the generative AI model. This information is retrieved from the database and sent to the corresponding users.

[1373] Step 4:

[1374] Users enter their participation request and evaluation into the service via their device. By entering the necessary information into the participation request form and pressing the "Submit" button, their participation request is sent to the server. The collected participation request information is managed centrally and sent to the generative AI model. The generative AI model assigns appropriate roles to users, taking into account their skills and past performance. The server stores the results of this assignment in a database and notifies the user.

[1375] Step 5:

[1376] After the service is performed, the server automatically collects feedback from the user. A link to a feedback form is sent via automated email or in-app message. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The server sends the collected feedback data to the generative AI model, which analyzes it and uses it to plan new services. This makes it possible to continuously provide purchasing suggestions and services based on the user's individual hobbies and skills, improving the user experience.

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

[1378] This invention describes a specific implementation method of a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, obtains feedback, and also recognizes user emotions using an emotion engine and reflects them in the generation of services. The content shown below shows how this invention can be specifically implemented based on the claims of the invention.

[1379] User Registration

[1380] The user accesses the metaverse system using a terminal and displays a login screen. A form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[1381] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[1382] The server validates the received data, checking for required fields and confirming the data format. If validation is successful, it saves the information in the database and returns a "Registration successful" message to the user.

[1383] Service planning using generative AI

[1384] The server executes the script using a scheduled trigger and retrieves user information from the database.

[1385] The server sends the acquired user information to the generating AI via a REST API or internal communication protocol.

[1386] The Generator AI analyzes the submitted user information and uses specific algorithms to identify counter trends and patterns.

[1387] The generative AI generates new service content based on the user's attributes, hobbies, and skills. It also analyzes the user's emotional information using an emotion engine and adjusts the content of the service accordingly.

[1388] The generated service information is returned to the server, which then stores it in a database. Detailed information such as the service overview, start date and time, and participation conditions is saved.

[1389] Running the service

[1390] The server retrieves new service information and notifies the user via email or in-app notification.

[1391] The user confirms the notification and accesses the service participation request form.

[1392] The user inputs the participation information and presses the "Submit" button.

[1393] The terminal transmits participation request data to the server.

[1394] The server centrally manages the participation request information and sends it to the generation AI, which then takes into account the information from the emotion engine and the user's emotional state to assign an appropriate role to the user.

[1395] The server stores the assignment results in a database and notifies the user.

[1396] Feedback collection and new service creation

[1397] After the service is performed, the server automatically sends the user a link to a feedback form.

[1398] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[1399] The terminal transmits the feedback data to the server.

[1400] The server sends the collected feedback data and user emotional information to the generation AI.

[1401] The generative AI analyzes the feedback and incorporates the user's emotions recognized by the emotion engine to generate new services. For example, it can reflect specific elements that the user expressed positive emotions about in the next service.

[1402] As a result, the present invention realizes a new metaverse system that continuously provides services that reflect the individual hobbies, skills, and even emotions of users, thereby improving the user experience.

[1403] The processing flow will be explained below.

[1404] User registration process steps

[1405] Step 1:

[1406] The user uses the terminal to access the login screen of the metaverse system.

[1407] Step 2:

[1408] Users enter information into a form that asks for attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.).

[1409] Step 3:

[1410] The user presses the "Register" button to confirm the entered information.

[1411] Step 4:

[1412] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[1413] Step 5:

[1414] The server validates the received data, checking for required items and confirming the data format.

[1415] Step 6:

[1416] If the data validation is successful, the server saves the information in the database and returns a "Registration successful" message to the user.

[1417] Processing steps for service planning using generative AI

[1418] Step 1:

[1419] The server executes the script using a scheduled trigger and retrieves user information from the database.

[1420] Step 2:

[1421] The server sends the acquired user information to the generating AI via a REST API or internal communication protocol.

[1422] Step 3:

[1423] The generative AI analyzes the submitted user information and uses specific algorithms to identify trends and patterns.

[1424] Step 4:

[1425] The generative AI generates new service content based on the user's attributes, hobbies, and skills. It also analyzes the user's emotional information using an emotion engine and adjusts the content of the service accordingly.

[1426] Step 5:

[1427] The generation AI sends the generated service information to the server.

[1428] Step 6:

[1429] The server stores the received service information in a database.

[1430] Processing steps for executing a service

[1431] Step 1:

[1432] The server retrieves new service information and notifies the user via email or in-app notification.

[1433] Step 2:

[1434] The user confirms the notification and accesses the service participation request form.

[1435] Step 3:

[1436] The user inputs the participation information and presses the "Submit" button.

[1437] Step 4:

[1438] The terminal transmits participation request data to the server.

[1439] Step 5:

[1440] The server centrally manages the participation request information and sends it to the generation AI.

[1441] Step 6:

[1442] The generative AI considers the user's skills and past performance to assign an appropriate role to the user, taking into account the user's emotional state through the addition of information from the emotion engine.

[1443] Step 7:

[1444] The server stores the assignment results in a database and notifies the user.

[1445] Processing steps for collecting feedback and creating new services

[1446] Step 1:

[1447] After the service is performed, the server automatically sends the user a link to a feedback form.

[1448] Step 2:

[1449] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[1450] Step 3:

[1451] The terminal transmits the feedback data to the server.

[1452] Step 4:

[1453] The server sends the collected feedback data and user emotional information to the generation AI.

[1454] Step 5:

[1455] The generative AI analyzes the feedback and incorporates the user's emotions recognized by the emotion engine to generate new services. For example, it can reflect specific elements that the user expressed positive emotions about in the next service.

[1456] Step 6:

[1457] The generating AI sends the new service information to the server and repeats the process.

[1458] Example 2

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

[1460] Although conventional systems provided services based on the user's attributes, hobbies, and skills, they had issues with insufficient adjustment of services based on the user's emotional information and insufficient reflection of feedback.In addition, they did not generate services using generative AI or assign roles that incorporated emotional information, making it difficult to improve the user experience.

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

[1462] In this invention, the server includes: means for a user to register multiple attributes, hobbies, skills, and roles; means for sending the information entered by the user to the server in a specified format; means for validating the data received by the server and storing it in a database; means for acquiring user information by a regular trigger and sending it to a generation AI means; generation AI means for generating a new service based on the user's attributes, hobbies, skills, and emotional information; means for storing the generated service information in a database and notifying the user; means for receiving and managing the user's service participation preference information; generation AI means for analyzing the user's emotional information and assigning an appropriate role to the user; means for sending a user feedback form and collecting feedback data after the service is executed; and means for analyzing the collected feedback data and reflecting it in the next service.

[1463] This makes it possible to continuously provide services that reflect the user's individual hobbies, skills, and even emotions, improving the user experience.

[1464] "User" refers to an individual or organization that accesses the Metaverse System and uses the Services.

[1465] "Attributes" is a general term for personal information such as a user's age, sex, and occupation.

[1466] "Hobbies" refer to activities or areas of interest that a user enjoys in their free time.

[1467] "Skills" refer to specific abilities or expertise that a user possesses.

[1468] A "role" refers to the responsibility or position that a user must fulfill within a service.

[1469] "Server" is a general term for a computing device that provides functions such as validating user information, storing data, communicating with the generation AI, and generating and notifying new services.

[1470] "Generative AI means" refers to artificial intelligence technologies and algorithms for generating new service content based on user information.

[1471] "Validation" is the process of checking whether received data conforms to the expected format and content.

[1472] A "database" refers to a system for efficiently storing, managing, and searching structured data.

[1473] A "timed trigger" refers to a mechanism that automatically executes a specified operation or task at a specific time interval.

[1474] "Emotional information" refers to data that quantifies the user's emotional state through analysis.

[1475] "Feedback" refers to evaluations and opinions of users regarding the services provided.

[1476] MODE FOR CARRYING OUT THE INVENTION

[1477] This invention describes a specific implementation method of a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, and obtains feedback, and also recognizes user emotions using an emotion engine to reflect these in the generation of services. This metaverse system is configured using the following hardware and software:

[1478] Hardware and software used

[1479] Terminal: A device through which a user accesses the Metaverse system. Examples include PCs, smartphones, and tablets.

[1480] Server: Provides functions such as managing user information, data validation, communication with the generation AI, accessing the database, generating new services, and notifications. An example is a cloud server (such as AWS EC2).

[1481] Database: A system for storing, managing, and searching structured data. Examples include MySQL and PostgreSQL.

[1482] Generative AI: Artificial intelligence technology that generates new service content based on user information. Examples include generative AI models such as GPT-4.

[1483] Emotion engine: An engine that analyzes user emotional information and reflects it in service generation. An example is Affectiva.

[1484] Specific implementation methods of the system

[1485] 1. User Registration:

[1486] The user accesses the metaverse system using a terminal and displays the login screen. The login screen displays a form for entering attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[1487] The terminal formats the entered information in JSON format and sends a POST request to the server. The server validates the received data, checking for required fields and confirming the data format. If validation is successful, the information is saved in the database and a "Registration successful" message is sent back to the user.

[1488] 2. Service planning using generative AI:

[1489] The server runs a script using a scheduled trigger (e.g., a cron job) to retrieve user information from a database. The server then sends the retrieved user information to the generation AI via a REST API. The generation AI analyzes the user information and identifies countertrends and patterns using specific algorithms (e.g., clustering). The generation AI generates new service content based on the user's attributes, hobbies, and skills. During this process, it uses an emotion engine to analyze the user's emotional information and adjusts the service content based on that. The generated service information is returned to the server, which then stores it in a database.

[1490] 3. Running the service:

[1491] The server obtains new service information and notifies the user via email or in-app notification (e.g., SendGrid, Firebase Cloud Messaging). The user checks the notification and accesses the service participation request form. The user enters the participation request information and presses the "Submit" button. The device sends the participation request data to the server. The server centrally manages the participation request information and sends it to the generation AI. The generation AI assigns an appropriate role to the user based on the information from the emotion engine.

[1492] 4. Feedback collection and new service creation:

[1493] After the service is performed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The device sends the feedback data to the server. The server sends the collected feedback data and the user's emotional information to the generation AI. The generation AI analyzes the feedback and generates a new service based on the data from the emotion engine. Positive feedback elements are reflected in the next service.

[1494] Examples of concrete examples and prompts

[1495] As an example, here is a prompt to input to a generative AI model:

[1496] "Create a new metaverse service based on user information. The following is the information for each user:

[1497] Age: 25

[1498] Gender: Male

[1499] Occupation: Software Engineer

[1500] Hobbies: Games, music

[1501] Skills: Programming, design

[1502] Desired role: Executor

[1503] Additionally, the emotion engine analysis indicates that this user is currently excited and looking for new challenges. Please generate new services that reflect this information.

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

[1505] User Registration

[1506] Step 1:

[1507] The user accesses the metaverse system using a terminal, and a login screen appears.

[1508] Input: Accessed by the user through a terminal.

[1509] Output: The login screen is displayed.

[1510] Step 2:

[1511] On the login screen, users enter information about their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.), and then press the "Register" button.

[1512] Input: The user enters information about their attributes, hobbies, skills, and desired role.

[1513] Output: Information entered by the user is sent to the terminal.

[1514] Step 3:

[1515] The terminal formats the input information in JSON format and sends a POST request to the server.

[1516] Input: Information entered by the user.

[1517] Output: The formatted user information is sent to the server.

[1518] Step 4:

[1519] The server validates the received user information, checks for required fields and confirms the data format. If validation is successful, the data is saved in the database.

[1520] Input: User information received by the server.

[1521] Output: Validation result. If successful, the information is saved to the database. After saving, a "Registration successful" message is returned to the user.

[1522] Service planning using generative AI

[1523] Step 5:

[1524] The server runs the script using a scheduled trigger (e.g., a cron job) and retrieves user information from the database.

[1525] Input: The script to be executed by the scheduled trigger.

[1526] Output: User information retrieved from the database.

[1527] Step 6:

[1528] The server sends the acquired user information to the generation AI via a REST API.

[1529] Input: The retrieved user information.

[1530] Output: The user information sent.

[1531] Step 7:

[1532] Generative AI analyzes user information and uses specific algorithms (e.g., clustering) to identify countertrends and patterns.

[1533] Input: The submitted user information.

[1534] Output: Pattern recognition results and new service content.

[1535] Step 8:

[1536] The generation AI generates new service content based on the user's attributes, hobbies, skills, and emotional information, and sends the generated service information to the server.

[1537] Input: Pattern recognition results and user attributes, hobbies, skills, and emotional information.

[1538] Output: The generated service information.

[1539] Step 9:

[1540] The server stores the received service information in a database.

[1541] Input: The generated service information.

[1542] Output: Service information stored in a database.

[1543] Running the service

[1544] Step 10:

[1545] The server retrieves new service information and notifies the user via email or in-app notification.

[1546] Input: Service information stored in the database.

[1547] Output: Service information sent via email and in-app notifications.

[1548] Step 11:

[1549] The user confirms the notification, accesses the service participation request form, enters the participation information, and presses the "Submit" button.

[1550] Input: Service participation information.

[1551] Output: The participation request information sent by the user is sent to the terminal.

[1552] Step 12:

[1553] The terminal transmits participation request data to the server.

[1554] Input: The participation information entered by the user.

[1555] Output: The participation request data sent to the server.

[1556] Step 13:

[1557] The server centrally manages the participation request information and sends it to the generation AI, which then assigns appropriate roles to users based on the information from the emotion engine.

[1558] Input: participation preference and emotion engine data.

[1559] Output: Data that assigns the most suitable role to the user.

[1560] Step 14:

[1561] The server stores the assignment results in a database and notifies the user.

[1562] Input: Assignment result.

[1563] Output: Assignment results stored in the database and notifications sent to the user.

[1564] Feedback collection and new service creation

[1565] Step 15:

[1566] After the service is executed, the server automatically sends the user a link to a feedback form.

[1567] Input: Trigger for service execution completion.

[1568] Output: The feedback form link sent to the user.

[1569] Step 16:

[1570] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[1571] Input: User ratings and comments.

[1572] Output: The feedback data sent.

[1573] Step 17:

[1574] The terminal transmits the feedback data to the server.

[1575] Input: Feedback information entered by the user.

[1576] Output: Feedback data sent to the server.

[1577] Step 18:

[1578] The server sends the collected feedback data and emotional information to the generation AI.

[1579] Input: Collected feedback data and sentiment information.

[1580] Output: Feedback data and emotional information sent to the generative AI.

[1581] Step 19:

[1582] The generative AI analyzes the feedback and generates new services based on the emotion engine data, incorporating positive feedback elements into the next service.

[1583] Input: Submitted feedback data and sentiment information.

[1584] Output: Data required for the next service generation.

[1585] This allows us to continue to provide optimal services based on the individuality and emotions of each user.

[1586] (Application example 2)

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

[1588] Conventional metaverse systems have had difficulty providing services that fully reflect the diverse needs and emotional states of users. Additionally, product recommendations in virtual environments are not personalized, which hinders the improvement of the user experience.

[1589] The specification processing by the specification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for a user to register multiple attributes, hobbies, skills, and roles; a generation AI means for generating a new service based on the user's registration information; a means for notifying the user of the generated service; a means for receiving and managing participation requests; a means for collecting feedback from the user and using it to generate the next service; an emotion engine means for recognizing the user's emotions and adjusting the service content in real time; and a means for making product suggestions in a virtual environment. This makes it possible to provide personalized services and product suggestions that reflect the user's individual needs and emotions.

[1590] A "user" is a person who accesses the system and registers their attributes, hobbies, skills, and roles.

[1591] "Attributes" are basic information including the user's age, gender, occupation, and so on.

[1592] A "hobby" is an activity that a user likes to do (e.g., games, music, sports, etc.).

[1593] A "skill" is a specific ability or expertise that a user has (e.g., programming, design, writing, etc.).

[1594] A "role" is the position a user desires to assume within the system (e.g., executor, evaluator, etc.).

[1595] The "generative AI means" is an artificial intelligence that generates new services based on the user's registered information and assigns the most suitable role to the user.

[1596] The "notification means" is a means for notifying the user of the generated service information.

[1597] The "means for receiving and managing participation requests" is a means for collecting and managing information on users' desire to participate in the service.

[1598] The "means for collecting and utilizing feedback" refers to a means for collecting user feedback and utilizing it in creating the next service.

[1599] The "emotion engine means" is an engine for recognizing the user's emotions and adjusting the service content in real time.

[1600] A "virtual environment" is a virtual space that users can access via the Internet to browse and purchase products.

[1601] The "means for making product suggestions" is a means for suggesting appropriate products to the user.

[1602] MODE FOR CARRYING OUT THE INVENTION

[1603] This invention describes a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, and obtains feedback, and also recognizes user emotions using an emotion engine, which is then reflected in the service content in real time. The invention is specifically implemented by combining the various means shown below.

[1604] User Registration

[1605] A user accesses the metaverse system using a device such as a smartphone and displays a login screen. A form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button. The device formats the entered information in JSON or XML format and sends a POST request to the server.

[1606] Service planning using generative AI

[1607] The server executes a script at a scheduled trigger and retrieves user information from the database. The server then sends the retrieved user information to the generation AI via a REST API or internal communication protocol. The generation AI analyzes the sent user information and uses a specific algorithm to identify reverse trends and patterns. The generation AI generates new service content based on the user's attributes, hobbies, and skills. Here, an emotion engine is used to analyze the user's emotional information and adjust the service content based on that. The generated service information is returned to the server, which stores it in a database.

[1608] Service execution and user notification

[1609] The server obtains new service information and notifies the user via email or in-app notification. The user checks the notification and accesses the service participation request form. The user enters the participation request information and presses the "Submit" button. The device sends the participation request data to the server. The server centrally manages the participation request information and sends it to the generation AI. Here, the generation AI takes into account information from the emotion engine and considers the user's emotional state to assign an appropriate role to the user. The server saves the assignment results in a database and notifies the user.

[1610] Collecting and analyzing feedback

[1611] After the service is performed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The device sends the feedback data to the server. The server sends the collected feedback data and the user's emotional information to the generation AI. The generation AI analyzes the feedback, incorporates the user's emotions recognized by the emotion engine, and uses them to generate new services.

[1612] Specific examples

[1613] For example, by inputting the following prompt sentence into a generative AI model, it is possible to suggest the best product for the user.

[1614] Prompt Sentence Examples

[1615] "I'm a 30-year-old male engineer whose hobbies are games and music. Please suggest products and services that will interest him."

[1616] This enables the generative AI to provide personalized services and product suggestions that reflect the individual needs and emotions of the user.

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

[1618] Step 1:

[1619] A user accesses the metaverse system using a device such as a smartphone and displays a login screen. A form is displayed in which the user enters their attributes, hobbies, skills, and desired role. This information is formatted by the device into JSON or XML format and sent to the server as a POST request.

[1620] Input: User-entered attributes, hobbies, skills, and roles

[1621] Output: The formatted user information is sent to the server

[1622] Step 2:

[1623] The server validates the received user information, checking for required fields and confirming the data format. If validation is successful, it saves the information in the database and returns a "Registration successful" message to the user. If validation fails, it notifies the user with an error message.

[1624] Input: User information sent from the device

[1625] Output: Validation results and saved data or error messages

[1626] Step 3:

[1627] The server periodically executes a trigger script to retrieve accumulated user information from the database. This user information is then sent to the generation AI via a REST API or internal communication protocol. The generation AI analyzes the user registration information and uses specific algorithms to identify trends and patterns.

[1628] Input: User information retrieved from the database

[1629] Output: Analyzed trends and patterns

[1630] Step 4:

[1631] The generation AI generates new service content based on the user's attributes, hobbies, skills, and emotional information provided by the emotion engine. This information is returned to the server, which stores it in a database. The generated service information includes details such as a service overview, start date and time, and participation conditions.

[1632] Input: Analyzed user attributes, hobbies, skills, and emotional information

[1633] Output: Generated new service information

[1634] Step 5:

[1635] The server sends the newly generated service information to the user via email or in-app notification. The user receives the notification and clicks the link in the notification to access the service registration form.

[1636] Input: Generated new service information

[1637] Output: Notification to the user

[1638] Step 6:

[1639] The user enters their desired information into the service participation request form and presses the "Submit" button. The device then sends this participation request information to the server. The server then centrally manages the participation request information and sends it to the generation AI.

[1640] Input: User-entered participation information

[1641] Output: The participation request sent to the server

[1642] Step 7:

[1643] The generative AI takes into account the data from the emotion engine and the user's emotional state to assign an appropriate role to the user. The assignment results are sent back to the server and stored in a database. The server then notifies the user of the assignment results.

[1644] Input: User participation preference information and emotion engine data

[1645] Output: Assignment result notified to the user

[1646] Step 8:

[1647] After the service is executed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and impressions of the service, and submits it. The terminal then sends the feedback data to the server.

[1648] Input: User feedback information

[1649] Output: Feedback information sent to the server

[1650] Step 9:

[1651] The server sends the collected feedback data and user emotion information to the generation AI, which analyzes the feedback and incorporates the user emotion recognized by the emotion engine to generate new services.

[1652] Input: User feedback data and emotional information

[1653] Output: New services generated based on the analyzed feedback results

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

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

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

[1657] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1671] This invention describes a specific implementation method of a metaverse system, including a series of processes such as registering user information, generating new services using generation AI, notifying users, collecting participation requests, and obtaining feedback. The following content shows how this invention can be specifically implemented based on the claims of the invention.

[1672] User Registration

[1673] The user accesses the metaverse system using a terminal and displays the login screen. Here, a form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[1674] The terminal sends the input information to the server, formatting the data in JSON or XML format and sending a POST request to the server.

[1675] The server validates the received data and stores it in the database. If validation is successful, the server returns a "Registration successful" message to the user.

[1676] Service planning using generative AI

[1677] The server periodically retrieves user information from the database and sends it to the generation AI. This can be achieved by running a script at a fixed time (every day at midnight), for example.

[1678] The Generative AI generates new services based on the submitted user information, trends, and past feedback data, and determines the specific service content based on the user's interests and skills.

[1679] The generated service information is returned to the server, which then stores it in a database, along with detailed information such as the service overview, start date and time, and participation conditions.

[1680] Running the service

[1681] The server notifies users of new services via email or in-app notifications, and includes details of the service, how to join, and deadlines for joining.

[1682] Users input their participation request and evaluation of the service through their terminal. By entering the necessary information in the participation request form and pressing the "Submit" button, the participation request is sent to the server.

[1683] The server centrally manages the collected participation information and sends it to the generation AI. The generation AI takes into account the participants' skills and past performance and assigns appropriate roles to users. The server stores the assignment results in a database and notifies the user.

[1684] Feedback collection and new service creation

[1685] After the service is executed, the server automatically collects feedback from the user by sending a link to a feedback form via automated email or in-app message.

[1686] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[1687] The server sends the collected feedback data to the generation AI, which analyzes it and uses it to plan new services.

[1688] As a result, the present invention realizes a new metaverse system that continuously provides services based on the user's individual hobbies and skills, improving the user experience.

[1689] The processing flow will be explained below.

[1690] User registration process steps

[1691] Step 1:

[1692] The user uses the terminal to access the login screen of the metaverse system.

[1693] Step 2:

[1694] Users enter information into a form that asks for attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.).

[1695] Step 3:

[1696] The user presses the "Register" button to confirm the entered information.

[1697] Step 4:

[1698] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[1699] Step 5:

[1700] The server validates the received data, checking for required fields and confirming the data format.

[1701] Step 6:

[1702] If the data validation is successful, the server saves the information in the database and returns a "Registration successful" message to the user.

[1703] Processing steps for service planning using generative AI

[1704] Step 1:

[1705] The server executes the script by a scheduled trigger and retrieves user information from the database.

[1706] Step 2:

[1707] The server sends the acquired user information to the generating AI using a REST API or internal communication protocol.

[1708] Step 3:

[1709] The generative AI analyzes the submitted user information and uses specific algorithms to identify trends and patterns.

[1710] Step 4:

[1711] The generative AI generates new service content based on the user's attributes, hobbies, and skills.

[1712] Step 5:

[1713] The generation AI sends the generated service information to the server.

[1714] Step 6:

[1715] The server stores the received service information in a database.

[1716] Processing steps for executing a service

[1717] Step 1:

[1718] The server retrieves new service information and notifies the user via email or in-app notification.

[1719] Step 2:

[1720] The user confirms the notification and accesses the service participation request form.

[1721] Step 3:

[1722] The user inputs the participation information and presses the "Submit" button.

[1723] Step 4:

[1724] The terminal transmits participation request data to the server.

[1725] Step 5:

[1726] The server centrally manages the participation request information and sends it to the generation AI.

[1727] Step 6:

[1728] The generative AI takes into account the user's skills and past performance and assigns them appropriate roles.

[1729] Step 7:

[1730] The server stores the assignment results in a database and notifies the user.

[1731] Processing steps for collecting feedback and creating new services

[1732] Step 1:

[1733] After the service is performed, the server automatically sends the user a link to a feedback form.

[1734] Step 2:

[1735] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[1736] Step 3:

[1737] The terminal transmits the feedback data to the server.

[1738] Step 4:

[1739] The server sends the collected feedback data to the generation AI.

[1740] Step 5:

[1741] The generative AI analyzes the feedback and identifies new ideas and improvements to use in the next service generation.

[1742] Step 6:

[1743] The generating AI sends the new service information to the server and repeats the process.

[1744] Example 1

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

[1746] Conventional metaverse systems have had difficulty providing services that fully reflect the characteristics and interests of users. Furthermore, the feedback function for reflecting generated service evaluations in the next service plan was insufficient. Furthermore, the assignment of appropriate roles in the service was not automated, which could result in a decline in service quality. The present invention aims to provide a metaverse system that solves these problems and improves the user experience.

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

[1748] In this invention, the server includes: a means for a user to register multiple attributes, hobbies, skills, and roles; a means for formatting the registered information in JSON or XML format and sending it to the server; a means for validating the received user information and saving it in a database; a generation AI means for generating a new service based on the user information and past feedback data; a means for saving the generated service information in a database and notifying the user; a means for collecting user information wishing to participate in the service and saving it in a database; a means for sending the collected participation information to the generation AI, assigning appropriate roles, and saving it in the database; and a means for collecting feedback from users after the service is executed and sending it to the generation AI. This enables the continuous provision of a service that reflects the user's characteristics and interests, the improvement of the service based on feedback, and the automatic assignment of optimal roles to participating users.

[1749] A "user" is an entity that accesses the metaverse system and inputs and registers attributes, hobbies, skills, and roles.

[1750] "Terminal" means a computer or mobile device used by a user to access the metaverse system.

[1751] The "server" is a central device that receives information sent by users, validates it, stores it in a database, and works with the generation AI to generate and manage new services.

[1752] "Generative AI" is an artificial intelligence system that generates new services based on user information and past feedback data.

[1753] "Attributes" are basic personal information that users register in the system, such as age, gender, and occupation.

[1754] "Hobbies" refers to activities or interests that a user is interested in, and is information that is registered in the system.

[1755] "Skills" refers to specific skills or knowledge that a user possesses, such as programming or design.

[1756] "Role" refers to the role a user desires to play within the metaverse, including executor, evaluator, etc.

[1757] "JSON" stands for JavaScript Object Notation, a lightweight data interchange format for representing data in a human- and machine-readable format.

[1758] "XML" stands for Extensible Markup Language, a markup language used to exchange and store data.

[1759] "Validation" is the process of checking that received user information is in the correct format.

[1760] "Database" refers to a system for storing and managing user information and generated service information.

[1761] "Feedback" refers to evaluations and impressions of the service collected from users after using the service.

[1762] "Participation request" is information that conveys to the system the user's desire to participate in a particular service.

[1763] This paper describes a specific implementation method for a metaverse system that executes a series of processes including user information registration, new service generation by generation AI, notification, collection of participation requests, and feedback acquisition. The distinctive features of this invention include the detailed registration of user information, service generation based on that information, and the importance of feedback.

[1764] User Registration

[1765] A user accesses the metaverse system using a terminal and displays a login screen. Here, the user is presented with a form to input their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). For example, user "A" inputs his / her age "25," gender "male," occupation "engineer," hobby "games," skill "programming," and desired role "executor."

[1766] The device formats the input information in JSON or XML format and sends it to the server via a POST request. This formatted data is then made available to the server. For example, a JSON payload like the following is generated:

[1767] {

[1768] "age": 25,

[1769] "gender": "male",

[1770] "occupation": "engineer",

[1771] "hobby": "gaming",

[1772] "skill": "programming",

[1773] "role_preference": "executor"

[1774] }

[1775] The server validates the received data and stores it in a database, for example by executing the following query against the database:

[1776] INSERT INTO users (age, gender, occupation, hobby, skill, role_preference) VALUES (25, 'male', 'engineer', 'gaming', 'programming', 'executor');

[1777] If validation is successful, the server sends a "Registration successful" message to the user.

[1778] Service planning using generative AI

[1779] The server periodically retrieves user information from the database, for example, at midnight every day, and sends it to the generation AI. This operation is performed through a script or similar.

[1780] The generative AI generates new services based on the received user information and past feedback data. For example, it proposes an "AI programming contest" based on the user information and past feedback.

[1781] The generated service information is returned to the server, which stores it in a database. For example, the following SQL query is executed:

[1782] INSERT INTO services (name, description, start_date, end_date) VALUES ('AI programming contest', 'A contest to test participants' programming skills', '2024-01-01', '2024-01-31');

[1783] To notify you of services and collect your participation preferences

[1784] The server will notify the user of the new service information generated by the server via email or in-app notification. For example, the following notification message will be sent:

[1785] "We're launching a new service, the AI ​​Programming Contest! Click the link for more details."

[1786] After receiving the notification, the user uses the terminal to enter their participation request for the service. For example, they enter their desired participation date and role in the participation request form, and then press the "Submit" button to send their participation request to the server.

[1787] The device formats the entered participation information in JSON format and sends it to the server. The transmitted data is as follows:

[1788] {

[1789] "user_id": 1,

[1790] "service_id": 1,

[1791] "participation_date": "2024-01-03",

[1792] "role": "executor"

[1793] }

[1794] Participant role assignment and notification

[1795] The server centrally manages the collected participation information and sends it to the generation AI, which then takes into account the participants' skills and performance and assigns appropriate roles to users.

[1796] The server stores the role assignment result in a database and notifies the user, for example, by sending a notification saying, "Your role is technical lead."

[1797] Feedback collection and new service creation

[1798] After the service is executed, the server automatically collects feedback from the user by sending a link to a feedback form via automated email or in-app message.

[1799] The user accesses the feedback form, enters their evaluation and thoughts about the service, and submits it. The entered feedback information is sent to the server.

[1800] The server sends the collected feedback data to the generation AI, which analyzes it and uses it to generate the next new service.

[1801] This will realize a new metaverse system that continuously provides services based on the individual hobbies and skills of users, improving the user experience.

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

[1803] Step 1: User Registration

[1804] Input: The user accesses the metaverse system using a terminal and inputs their age, gender, occupation, hobbies, skills, and desired role.

[1805] Action: User "A" inputs his / her age "25 years old", gender "male", occupation "engineer", hobby "gaming", skill "programming", and desired role "executor".

[1806] Data processing: The terminal formats the input information in JSON or XML format and sends it to the server as a POST request.

[1807] {

[1808] "age": 25,

[1809] "gender": "male",

[1810] "occupation": "engineer",

[1811] "hobby": "gaming",

[1812] "skill": "programming",

[1813] "role_preference": "executor"

[1814] }

[1815] Output: The formatted data sent to the server.

[1816] Step 2: Validate and save the data

[1817] Input: User information received by the server from the terminal.

[1818] Data Calculation: The server validates the received data and formats it for storage in the database.

[1819] INSERT INTO users (age, gender, occupation, hobby, skill, role_preference) VALUES (25, 'male', 'engineer', 'gaming', 'programming', 'executor');

[1820] Output: User information stored in the database. If validation is successful, a "Registration successful" message is sent to the user.

[1821] Step 3: Obtaining user information for creating a new service

[1822] Input: A trigger to periodically (e.g., every day at midnight) retrieve user information from the database.

[1823] Operation: The server executes SELECT FROM users; to retrieve all user information.

[1824] Output: User information to send to the generation AI.

[1825] Step 4: Generating new services using generative AI

[1826] Input: User information and past feedback data sent from the server.

[1827] Data calculation: Generative AI analyzes the received information and generates new services based on the user's interests and skills.

[1828] Operation: A service called "AI Programming Contest" is created.

[1829] Output: The generated service information.

[1830] Step 5: Save and notify generated service information

[1831] Input: New service information sent from the generation AI.

[1832] Data processing: The server saves the new service information in the database.

[1833] INSERT INTO services (name, description, start_date, end_date) VALUES ('AI programming contest', 'Contest utilizing programming skills', '2024-01-01', '2024-01-31');

[1834] Action: The server sends a notification to the user saying, "A new service, 'AI Programming Contest', is starting!"

[1835] Output: New service information notified to the user.

[1836] Step 6: Enter and submit your participation request

[1837] Input: The user inputs their desire to join the new service.

[1838] Action: Enter your desired participation date and role in the participation request form and press the "Submit" button. For example, enter January 3, 2024, and enter "Role" as "executor."

[1839] Data processing: The terminal reformats the input information in JSON format again and sends it to the server.

[1840] {

[1841] "user_id": 1,

[1842] "service_id": 1,

[1843] "participation_date": "2024-01-03",

[1844] "role": "executor"

[1845] }

[1846] Output: The participation request sent to the server.

[1847] Step 7: Manage participation preferences and assign roles

[1848] Input: Participation request information sent from the device.

[1849] Data processing: The server stores the participation information in a database and then sends it to the generation AI.

[1850] Data calculation: Generative AI assigns appropriate roles based on participants' information.

[1851] Action: "Yamada Taro" is assigned the role of "Technical Leader."

[1852] Output: An updated database containing the allocation results.

[1853] Step 8: Save and notify role assignment results

[1854] Input: Role assignment results sent from the generation AI.

[1855] Data processing: The server stores the allocation results in a database.

[1856] UPDATE participation_requests SET assigned_role = 'executor' WHERE user_id = 1 AND service_id = 1;

[1857] Action: The server sends a notification to the user stating "Your role is Tech Lead."

[1858] Output: Role assignment result notified to the user.

[1859] Step 9: Collect and send feedback

[1860] Input: Feedback request from user after service execution.

[1861] Action: The server sends the user a link to a feedback form.

[1862] Data processing: The information entered by the user in the feedback form is sent to the server.

[1863] {

[1864] "user_id": 1,

[1865] "service_id": 1,

[1866] "feedback": "The service was very helpful"

[1867] }

[1868] Output: Feedback information sent to the server.

[1869] Step 10: Analyze feedback data and reflect it in the creation of new services

[1870] Input: Feedback data submitted by the user.

[1871] Data calculation: The server sends feedback data to the generation AI, which analyzes it.

[1872] Operation: Based on the analysis results, feedback is reflected in the creation of new services.

[1873] Output: Plan for the next new service that reflects feedback.

[1874] Through these steps, we will realize a metaverse system that improves the user experience by generating services, collecting feedback, and assigning roles based on the user's characteristics and interests.

[1875] (Application example 1)

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

[1877] Conventional metaverse systems and online shopping sites do not adequately propose services based on a user's individual hobbies and skills. As a result, users have difficulty finding the services that best suit them, resulting in a poor user experience. Furthermore, the lack of a mechanism for efficiently utilizing feedback to improve services makes it difficult to improve service quality. The objective of this invention is to solve these problems and provide a system that enables purchasing suggestions and services tailored to the user's individual needs.

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

[1879] In this invention, the server includes a means for users to register multiple attributes, hobbies, skills, and roles; a generation AI means for generating new services based on the user's registered information; a means for notifying the user of the generated services; a means for generating personalized purchasing proposals based on the user's purchasing history, interests, and attributes; and a means for notifying the smart device of the generated purchasing proposals. This allows users to receive services and product proposals that are best suited to them, improving their user experience. Furthermore, by analyzing feedback information and reflecting it in future services, the quality of the service can be continuously improved.

[1880] "User" refers to an individual or corporation that accesses the metaverse system or online shopping site and registers information such as attributes, hobbies, skills, and role.

[1881] "Attributes" refers to basic information such as a user's age, gender, occupation, and location.

[1882] "Hobbies" refers to activities or subjects that interest a user, such as music, sports, reading, etc.

[1883] "Skills" refer to specific skills or abilities that a user possesses, such as programming, design, writing, etc.

[1884] "Role" refers to the specific role a user wishes to play within the system, e.g., performer, evaluator, etc.

[1885] "Generative AI means" refers to artificial intelligence that generates new services and purchasing suggestions based on users' registered information.

[1886] "Service" refers to a specific activity, project, or content generated by Generative AI Means and made available to Users.

[1887] "Purchase Suggestions" refers to personalized product and service suggestions generated by generative AI means based on a user's preferences, purchasing history, and attributes.

[1888] "Notification means" refers to means for informing users of generated services or purchase offers, such as email notifications or in-app notifications.

[1889] "Feedback" refers to the act of a user providing evaluations, impressions, opinions, etc. regarding a service or purchase proposal.

[1890] "Smart device" refers to a smartphone, tablet, smart glasses, head-mounted display, or robot used by a user.

[1891] The present invention relates to a metaverse system and an online shopping site that includes a series of processes such as registering user information, generating new services using a generation AI, notifying users, collecting participation requests, and obtaining feedback. Specific embodiments for implementing the present invention are described in detail below.

[1892] A system embodying the invention includes the following main components:

[1893] A terminal for registering and managing user information

[1894] A server that uses generative AI to generate new services and purchase proposals

[1895] Communication method for notifying smart devices

[1896] A means of collecting and analyzing user feedback

[1897] 1. User Registration

[1898] The user accesses the system using a terminal and displays the login screen. A form is displayed in which the user can enter attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button. The terminal then sends the entered information to the server. This data is formatted in JSON or XML format and sent to the server via a POST request. The server validates the received data and saves it in a database. If validation is successful, the server sends the user a "Registration successful" message.

[1899] 2. Service planning and purchasing proposals using generative AI

[1900] The server periodically retrieves user information from the database and sends it to the generation AI. Based on this, the generation AI generates suitable service and product suggestions based on the user information. The generative AI model is built using frameworks such as TensorFlow. The generated service information and purchase suggestions are returned to the server and stored in a database. Detailed information such as the service overview, start date and time, and participation conditions are also stored.

[1901] 3. Service notifications and purchase offer notifications

[1902] The server notifies the user of newly generated services and purchase proposals via email or in-app notifications. The notification includes information such as service overview, participation method, and participation deadline. At the same time, the user is also notified of the purchase proposals generated by the generative AI model.

[1903] 4. Gathering Participation and Feedback

[1904] Users input their participation request and evaluation into the service via their device. By entering the necessary information into the participation request form and pressing the "Submit" button, their participation request is sent to the server. The collected participation request information is centrally managed and sent to the generation AI. The generation AI assigns appropriate roles to users, taking into account their skills and past performance. The server stores the results of this assignment in a database and notifies the user.

[1905] 5. Use feedback

[1906] After the service is performed, the server automatically collects feedback from the user. A link to a feedback form is sent via automated email or in-app message. The user accesses the feedback form, enters their evaluation and thoughts about the service, and submits it. The server sends the collected feedback data to the generation AI, which analyzes it and uses it to plan new services. This makes it possible to continuously provide purchasing suggestions and services based on the user's individual hobbies and skills, improving the user experience.

[1907] Prompt Sentence Examples

[1908] An example of a prompt sentence when generating a service for the generation AI is:

[1909] "Generate content based on the following user data to propose the next project. User Data: { 'Age': 25, 'Gender': 'Male', 'Occupation': 'Engineer', 'Interests': ['Music'], 'Skills': ['Programming'], 'Role': 'Executor'}"

[1910] It is possible to input this information into a generative AI model in the following way.

[1911] The above is an embodiment of the present invention, which makes it possible to provide purchasing suggestions and services tailored to the user's needs, thereby achieving a more sophisticated user experience.

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

[1913] Step 1:

[1914] Users use a terminal to access the system through a login screen, where they enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). This information is entered into a form on the terminal, and by pressing the "Register" button, the data is converted into JSON format and sent to the server. The server validates the received data and saves it in a database. If validation is successful, the server sends a "Registration successful" message to the user.

[1915] Step 2:

[1916] The server periodically retrieves user information from the database and sends it to the generative AI model. In this step, a program executes a scheduled trigger to automatically retrieve user data. The retrieved data includes the user's attributes, hobbies, skills, and role information, and provides prompts to the generative AI model based on this information. Based on the prompts, the generative AI model generates new services and purchasing suggestions. The generated results are returned to the server and stored in the database.

[1917] Step 3:

[1918] The server notifies users of newly generated services and purchase offers via email or in-app notifications. The notifications include a service overview, start date and time, participation conditions, and purchase offers generated by the generative AI model. This information is retrieved from the database and sent to the corresponding users.

[1919] Step 4:

[1920] Users enter their participation request and evaluation into the service via their device. By entering the necessary information into the participation request form and pressing the "Submit" button, their participation request is sent to the server. The collected participation request information is managed centrally and sent to the generative AI model. The generative AI model assigns appropriate roles to users, taking into account their skills and past performance. The server stores the results of this assignment in a database and notifies the user.

[1921] Step 5:

[1922] After the service is performed, the server automatically collects feedback from the user. A link to a feedback form is sent via automated email or in-app message. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The server sends the collected feedback data to the generative AI model, which analyzes it and uses it to plan new services. This makes it possible to continuously provide purchasing suggestions and services based on the user's individual hobbies and skills, improving the user experience.

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

[1924] This invention describes a specific implementation method of a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, obtains feedback, and also recognizes user emotions using an emotion engine and reflects them in the generation of services. The content shown below shows how this invention can be specifically implemented based on the claims of the invention.

[1925] User Registration

[1926] The user accesses the metaverse system using a terminal and displays a login screen. A form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[1927] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[1928] The server validates the received data, checking for required fields and confirming the data format. If validation is successful, it saves the information in the database and returns a "Registration successful" message to the user.

[1929] Service planning using generative AI

[1930] The server executes the script using a scheduled trigger and retrieves user information from the database.

[1931] The server sends the acquired user information to the generating AI via a REST API or internal communication protocol.

[1932] The Generator AI analyzes the submitted user information and uses specific algorithms to identify counter trends and patterns.

[1933] The generative AI generates new service content based on the user's attributes, hobbies, and skills. It also analyzes the user's emotional information using an emotion engine and adjusts the content of the service accordingly.

[1934] The generated service information is returned to the server, which then stores it in a database. Detailed information such as the service overview, start date and time, and participation conditions is saved.

[1935] Running the service

[1936] The server retrieves new service information and notifies the user via email or in-app notification.

[1937] The user confirms the notification and accesses the service participation request form.

[1938] The user inputs the participation information and presses the "Submit" button.

[1939] The terminal transmits participation request data to the server.

[1940] The server centrally manages the participation request information and sends it to the generation AI, which then takes into account the information from the emotion engine and the user's emotional state to assign an appropriate role to the user.

[1941] The server stores the assignment results in a database and notifies the user.

[1942] Feedback collection and new service creation

[1943] After the service is performed, the server automatically sends the user a link to a feedback form.

[1944] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[1945] The terminal transmits the feedback data to the server.

[1946] The server sends the collected feedback data and user emotional information to the generation AI.

[1947] The generative AI analyzes the feedback and incorporates the user's emotions recognized by the emotion engine to generate new services. For example, it can reflect specific elements that the user expressed positive emotions about in the next service.

[1948] As a result, the present invention realizes a new metaverse system that continuously provides services that reflect the individual hobbies, skills, and even emotions of users, thereby improving the user experience.

[1949] The processing flow will be explained below.

[1950] User registration process steps

[1951] Step 1:

[1952] The user uses the terminal to access the login screen of the metaverse system.

[1953] Step 2:

[1954] Users enter information into a form that asks for attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.).

[1955] Step 3:

[1956] The user presses the "Register" button to confirm the entered information.

[1957] Step 4:

[1958] The terminal formats the input information in JSON or XML format and sends a POST request to the server.

[1959] Step 5:

[1960] The server validates the received data, checking for required items and confirming the data format.

[1961] Step 6:

[1962] If the data validation is successful, the server saves the information in the database and returns a "Registration successful" message to the user.

[1963] Processing steps for service planning using generative AI

[1964] Step 1:

[1965] The server executes the script using a scheduled trigger and retrieves user information from the database.

[1966] Step 2:

[1967] The server sends the acquired user information to the generating AI via a REST API or internal communication protocol.

[1968] Step 3:

[1969] The generative AI analyzes the submitted user information and uses specific algorithms to identify trends and patterns.

[1970] Step 4:

[1971] The generative AI generates new service content based on the user's attributes, hobbies, and skills. It also analyzes the user's emotional information using an emotion engine and adjusts the content of the service accordingly.

[1972] Step 5:

[1973] The generation AI sends the generated service information to the server.

[1974] Step 6:

[1975] The server stores the received service information in a database.

[1976] Processing steps for executing a service

[1977] Step 1:

[1978] The server retrieves new service information and notifies the user via email or in-app notification.

[1979] Step 2:

[1980] The user confirms the notification and accesses the service participation request form.

[1981] Step 3:

[1982] The user inputs the participation information and presses the "Submit" button.

[1983] Step 4:

[1984] The terminal transmits participation request data to the server.

[1985] Step 5:

[1986] The server centrally manages the participation request information and sends it to the generation AI.

[1987] Step 6:

[1988] The generative AI considers the user's skills and past performance to assign an appropriate role to the user, taking into account the user's emotional state through the addition of information from the emotion engine.

[1989] Step 7:

[1990] The server stores the assignment results in a database and notifies the user.

[1991] Processing steps for collecting feedback and creating new services

[1992] Step 1:

[1993] After the service is performed, the server automatically sends the user a link to a feedback form.

[1994] Step 2:

[1995] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[1996] Step 3:

[1997] The terminal transmits the feedback data to the server.

[1998] Step 4:

[1999] The server sends the collected feedback data and user emotional information to the generation AI.

[2000] Step 5:

[2001] The generative AI analyzes the feedback and incorporates the user's emotions recognized by the emotion engine to generate new services. For example, it can reflect specific elements that the user expressed positive emotions about in the next service.

[2002] Step 6:

[2003] The generating AI sends the new service information to the server and repeats the process.

[2004] Example 2

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

[2006] Although conventional systems provided services based on the user's attributes, hobbies, and skills, they had issues with insufficient adjustment of services based on the user's emotional information and insufficient reflection of feedback.In addition, they did not generate services using generative AI or assign roles that incorporated emotional information, making it difficult to improve the user experience.

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

[2008] In this invention, the server includes: means for a user to register multiple attributes, hobbies, skills, and roles; means for sending the information entered by the user to the server in a specified format; means for validating the data received by the server and storing it in a database; means for acquiring user information by a regular trigger and sending it to a generation AI means; generation AI means for generating a new service based on the user's attributes, hobbies, skills, and emotional information; means for storing the generated service information in a database and notifying the user; means for receiving and managing the user's service participation preference information; generation AI means for analyzing the user's emotional information and assigning an appropriate role to the user; means for sending a user feedback form and collecting feedback data after the service is executed; and means for analyzing the collected feedback data and reflecting it in the next service.

[2009] This makes it possible to continuously provide services that reflect the user's individual hobbies, skills, and even emotions, improving the user experience.

[2010] "User" refers to an individual or organization that accesses the Metaverse System and uses the Services.

[2011] "Attributes" is a general term for personal information such as a user's age, sex, and occupation.

[2012] "Hobbies" refer to activities or areas of interest that a user enjoys in their free time.

[2013] "Skills" refer to specific abilities or expertise that a user possesses.

[2014] A "role" refers to the responsibility or position that a user must fulfill within a service.

[2015] "Server" is a general term for a computing device that provides functions such as validating user information, storing data, communicating with the generation AI, and generating and notifying new services.

[2016] "Generative AI means" refers to artificial intelligence technologies and algorithms for generating new service content based on user information.

[2017] "Validation" is the process of checking whether received data conforms to the expected format and content.

[2018] A "database" refers to a system for efficiently storing, managing, and searching structured data.

[2019] A "timed trigger" refers to a mechanism that automatically executes a specified operation or task at a specific time interval.

[2020] "Emotional information" refers to data that quantifies the user's emotional state through analysis.

[2021] "Feedback" refers to evaluations and opinions of users regarding the services provided.

[2022] MODE FOR CARRYING OUT THE INVENTION

[2023] This invention describes a specific implementation method of a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, and obtains feedback, and also recognizes user emotions using an emotion engine to reflect these in the generation of services. This metaverse system is configured using the following hardware and software:

[2024] Hardware and software used

[2025] Terminal: A device through which a user accesses the Metaverse system. Examples include PCs, smartphones, and tablets.

[2026] Server: Provides functions such as managing user information, data validation, communication with the generation AI, accessing the database, generating new services, and notifications. An example is a cloud server (such as AWS EC2).

[2027] Database: A system for storing, managing, and searching structured data. Examples include MySQL and PostgreSQL.

[2028] Generative AI: Artificial intelligence technology that generates new service content based on user information. Examples include generative AI models such as GPT-4.

[2029] Emotion engine: An engine that analyzes user emotional information and reflects it in service generation. An example is Affectiva.

[2030] Specific implementation methods of the system

[2031] 1. User Registration:

[2032] The user accesses the metaverse system using a terminal and displays the login screen. The login screen displays a form for entering attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button.

[2033] The terminal formats the entered information in JSON format and sends a POST request to the server. The server validates the received data, checking for required fields and confirming the data format. If validation is successful, the information is saved in the database and a "Registration successful" message is sent back to the user.

[2034] 2. Service planning using generative AI:

[2035] The server runs a script using a scheduled trigger (e.g., a cron job) to retrieve user information from a database. The server then sends the retrieved user information to the generation AI via a REST API. The generation AI analyzes the user information and identifies countertrends and patterns using specific algorithms (e.g., clustering). The generation AI generates new service content based on the user's attributes, hobbies, and skills. During this process, it uses an emotion engine to analyze the user's emotional information and adjusts the service content based on that. The generated service information is returned to the server, which then stores it in a database.

[2036] 3. Running the service:

[2037] The server obtains new service information and notifies the user via email or in-app notification (e.g., SendGrid, Firebase Cloud Messaging). The user checks the notification and accesses the service participation request form. The user enters the participation request information and presses the "Submit" button. The device sends the participation request data to the server. The server centrally manages the participation request information and sends it to the generation AI. The generation AI assigns an appropriate role to the user based on the information from the emotion engine.

[2038] 4. Feedback collection and new service creation:

[2039] After the service is performed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The device sends the feedback data to the server. The server sends the collected feedback data and the user's emotional information to the generation AI. The generation AI analyzes the feedback and generates a new service based on the data from the emotion engine. Positive feedback elements are reflected in the next service.

[2040] Examples of concrete examples and prompts

[2041] As an example, here is a prompt to input to a generative AI model:

[2042] "Create a new metaverse service based on user information. The following is the information for each user:

[2043] Age: 25

[2044] Gender: Male

[2045] Occupation: Software Engineer

[2046] Hobbies: Games, music

[2047] Skills: Programming, design

[2048] Desired role: Executor

[2049] Additionally, the emotion engine analysis indicates that this user is currently excited and looking for new challenges. Please generate new services that reflect this information.

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

[2051] User Registration

[2052] Step 1:

[2053] The user accesses the metaverse system using a terminal, and a login screen appears.

[2054] Input: Accessed by the user through a terminal.

[2055] Output: The login screen is displayed.

[2056] Step 2:

[2057] On the login screen, users enter information about their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.), and then press the "Register" button.

[2058] Input: The user enters information about their attributes, hobbies, skills, and desired role.

[2059] Output: Information entered by the user is sent to the terminal.

[2060] Step 3:

[2061] The terminal formats the input information in JSON format and sends a POST request to the server.

[2062] Input: Information entered by the user.

[2063] Output: The formatted user information is sent to the server.

[2064] Step 4:

[2065] The server validates the received user information, checks for required fields and confirms the data format. If validation is successful, the data is saved in the database.

[2066] Input: User information received by the server.

[2067] Output: Validation result. If successful, the information is saved to the database. After saving, a "Registration successful" message is returned to the user.

[2068] Service planning using generative AI

[2069] Step 5:

[2070] The server runs the script using a scheduled trigger (e.g., a cron job) and retrieves user information from the database.

[2071] Input: The script to be executed by the scheduled trigger.

[2072] Output: User information retrieved from the database.

[2073] Step 6:

[2074] The server sends the acquired user information to the generation AI via a REST API.

[2075] Input: The retrieved user information.

[2076] Output: The user information sent.

[2077] Step 7:

[2078] Generative AI analyzes user information and uses specific algorithms (e.g., clustering) to identify countertrends and patterns.

[2079] Input: The submitted user information.

[2080] Output: Pattern recognition results and new service content.

[2081] Step 8:

[2082] The generation AI generates new service content based on the user's attributes, hobbies, skills, and emotional information, and sends the generated service information to the server.

[2083] Input: Pattern recognition results and user attributes, hobbies, skills, and emotional information.

[2084] Output: The generated service information.

[2085] Step 9:

[2086] The server stores the received service information in a database.

[2087] Input: The generated service information.

[2088] Output: Service information stored in a database.

[2089] Running the service

[2090] Step 10:

[2091] The server retrieves new service information and notifies the user via email or in-app notification.

[2092] Input: Service information stored in the database.

[2093] Output: Service information sent via email and in-app notifications.

[2094] Step 11:

[2095] The user confirms the notification, accesses the service participation request form, enters the participation information, and presses the "Submit" button.

[2096] Input: Service participation information.

[2097] Output: The participation request information sent by the user is sent to the terminal.

[2098] Step 12:

[2099] The terminal transmits participation request data to the server.

[2100] Input: The participation information entered by the user.

[2101] Output: The participation request data sent to the server.

[2102] Step 13:

[2103] The server centrally manages the participation request information and sends it to the generation AI, which then assigns appropriate roles to users based on the information from the emotion engine.

[2104] Input: participation preference and emotion engine data.

[2105] Output: Data that assigns the most suitable role to the user.

[2106] Step 14:

[2107] The server stores the assignment results in a database and notifies the user.

[2108] Input: Assignment result.

[2109] Output: Assignment results stored in the database and notifications sent to the user.

[2110] Feedback collection and new service creation

[2111] Step 15:

[2112] After the service is executed, the server automatically sends the user a link to a feedback form.

[2113] Input: Trigger for service execution completion.

[2114] Output: The feedback form link sent to the user.

[2115] Step 16:

[2116] Users access the feedback form, enter their ratings and impressions of the service, and submit them.

[2117] Input: User ratings and comments.

[2118] Output: The feedback data sent.

[2119] Step 17:

[2120] The terminal transmits the feedback data to the server.

[2121] Input: Feedback information entered by the user.

[2122] Output: Feedback data sent to the server.

[2123] Step 18:

[2124] The server sends the collected feedback data and emotional information to the generation AI.

[2125] Input: Collected feedback data and sentiment information.

[2126] Output: Feedback data and emotional information sent to the generative AI.

[2127] Step 19:

[2128] The generative AI analyzes the feedback and generates new services based on the emotion engine data, incorporating positive feedback elements into the next service.

[2129] Input: Submitted feedback data and sentiment information.

[2130] Output: Data required for the next service generation.

[2131] This allows us to continue to provide optimal services based on the individuality and emotions of each user.

[2132] (Application example 2)

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

[2134] Conventional metaverse systems have had difficulty providing services that fully reflect the diverse needs and emotional states of users. Additionally, product recommendations in virtual environments are not personalized, which hinders the improvement of the user experience.

[2135] The specification processing by the specification processing unit 290 of the data processing device 12 in Application Example 2 is realized by the following means. In this invention, the server includes: means for a user to register multiple attributes, hobbies, skills, and roles; a generation AI means for generating a new service based on the user's registration information; a means for notifying the user of the generated service; a means for receiving and managing participation requests; a means for collecting feedback from the user and using it to generate the next service; an emotion engine means for recognizing the user's emotions and adjusting the service content in real time; and a means for making product suggestions in a virtual environment. This makes it possible to provide personalized services and product suggestions that reflect the user's individual needs and emotions.

[2136] A "user" is a person who accesses the system and registers their attributes, hobbies, skills, and roles.

[2137] "Attributes" are basic information including the user's age, gender, occupation, and so on.

[2138] A "hobby" is an activity that a user likes to do (e.g., games, music, sports, etc.).

[2139] A "skill" is a specific ability or expertise that a user has (e.g., programming, design, writing, etc.).

[2140] A "role" is the position a user desires to assume within the system (e.g., executor, evaluator, etc.).

[2141] The "generative AI means" is an artificial intelligence that generates new services based on the user's registered information and assigns the most suitable role to the user.

[2142] The "notification means" is a means for notifying the user of the generated service information.

[2143] The "means for receiving and managing participation requests" is a means for collecting and managing information on users' desire to participate in the service.

[2144] The "means for collecting and utilizing feedback" refers to a means for collecting user feedback and utilizing it in creating the next service.

[2145] The "emotion engine means" is an engine for recognizing the user's emotions and adjusting the service content in real time.

[2146] A "virtual environment" is a virtual space that users can access via the Internet to browse and purchase products.

[2147] The "means for making product suggestions" is a means for suggesting appropriate products to the user.

[2148] MODE FOR CARRYING OUT THE INVENTION

[2149] This invention describes a metaverse system that registers user information, generates new services using a generation AI, notifies users, collects participation requests, and obtains feedback, and also recognizes user emotions using an emotion engine, which is then reflected in the service content in real time. The invention is specifically implemented by combining the various means shown below.

[2150] User Registration

[2151] A user accesses the metaverse system using a device such as a smartphone and displays a login screen. A form is displayed in which the user can enter their attributes (age, gender, occupation, etc.), hobbies (games, music, sports, etc.), skills (programming, design, writing, etc.), and desired role (executor, evaluator, etc.). The user enters the information and presses the "Register" button. The device formats the entered information in JSON or XML format and sends a POST request to the server.

[2152] Service planning using generative AI

[2153] The server executes a script at a scheduled trigger and retrieves user information from the database. The server then sends the retrieved user information to the generation AI via a REST API or internal communication protocol. The generation AI analyzes the sent user information and uses a specific algorithm to identify reverse trends and patterns. The generation AI generates new service content based on the user's attributes, hobbies, and skills. Here, an emotion engine is used to analyze the user's emotional information and adjust the service content based on that. The generated service information is returned to the server, which stores it in a database.

[2154] Service execution and user notification

[2155] The server obtains new service information and notifies the user via email or in-app notification. The user checks the notification and accesses the service participation request form. The user enters the participation request information and presses the "Submit" button. The device sends the participation request data to the server. The server centrally manages the participation request information and sends it to the generation AI. Here, the generation AI takes into account information from the emotion engine and considers the user's emotional state to assign an appropriate role to the user. The server saves the assignment results in a database and notifies the user.

[2156] Collecting and analyzing feedback

[2157] After the service is performed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and thoughts on the service, and submits it. The device sends the feedback data to the server. The server sends the collected feedback data and the user's emotional information to the generation AI. The generation AI analyzes the feedback, incorporates the user's emotions recognized by the emotion engine, and uses them to generate new services.

[2158] Specific examples

[2159] For example, by inputting the following prompt sentence into a generative AI model, it is possible to suggest the best product for the user.

[2160] Prompt Sentence Examples

[2161] "I'm a 30-year-old male engineer whose hobbies are games and music. Please suggest products and services that will interest him."

[2162] This enables the generative AI to provide personalized services and product suggestions that reflect the individual needs and emotions of the user.

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

[2164] Step 1:

[2165] A user accesses the metaverse system using a device such as a smartphone and displays a login screen. A form is displayed in which the user enters their attributes, hobbies, skills, and desired role. This information is formatted by the device into JSON or XML format and sent to the server as a POST request.

[2166] Input: User-entered attributes, hobbies, skills, and roles

[2167] Output: The formatted user information is sent to the server

[2168] Step 2:

[2169] The server validates the received user information, checking for required fields and confirming the data format. If validation is successful, it saves the information in the database and returns a "Registration successful" message to the user. If validation fails, it notifies the user with an error message.

[2170] Input: User information sent from the device

[2171] Output: Validation results and saved data or error messages

[2172] Step 3:

[2173] The server periodically executes a trigger script to retrieve accumulated user information from the database. This user information is then sent to the generation AI via a REST API or internal communication protocol. The generation AI analyzes the user registration information and uses specific algorithms to identify trends and patterns.

[2174] Input: User information retrieved from the database

[2175] Output: Analyzed trends and patterns

[2176] Step 4:

[2177] The generation AI generates new service content based on the user's attributes, hobbies, skills, and emotional information provided by the emotion engine. This information is returned to the server, which stores it in a database. The generated service information includes details such as a service overview, start date and time, and participation conditions.

[2178] Input: Analyzed user attributes, hobbies, skills, and emotional information

[2179] Output: Generated new service information

[2180] Step 5:

[2181] The server sends the newly generated service information to the user via email or in-app notification. The user receives the notification and clicks the link in the notification to access the service registration form.

[2182] Input: Generated new service information

[2183] Output: Notification to the user

[2184] Step 6:

[2185] The user enters their desired information into the service participation request form and presses the "Submit" button. The device then sends this participation request information to the server. The server then centrally manages the participation request information and sends it to the generation AI.

[2186] Input: User-entered participation information

[2187] Output: The participation request sent to the server

[2188] Step 7:

[2189] The generative AI takes into account the data from the emotion engine and the user's emotional state to assign an appropriate role to the user. The assignment results are sent back to the server and stored in a database. The server then notifies the user of the assignment results.

[2190] Input: User participation preference information and emotion engine data

[2191] Output: Assignment result notified to the user

[2192] Step 8:

[2193] After the service is executed, the server automatically sends the user a link to a feedback form. The user accesses the feedback form, enters their evaluation and impressions of the service, and submits it. The terminal then sends the feedback data to the server.

[2194] Input: User feedback information

[2195] Output: Feedback information sent to the server

[2196] Step 9:

[2197] The server sends the collected feedback data and user emotion information to the generation AI, which analyzes the feedback and incorporates the user emotion recognized by the emotion engine to generate new services.

[2198] Input: User feedback data and emotional information

[2199] Output: New services generated based on the analyzed feedback results

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

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

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

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

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

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

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

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

[2208] The emotion map defines two emotions that promote learning. One is a negative emotion on...

Claims

1. A means for a user to register a plurality of attributes, hobbies, skills, and roles; A generating AI means for generating new services based on user registration information; means for notifying a user of the generated service; a means of receiving and managing participation requests; and A means of collecting user feedback and using it to create the next service. A system including:

2. 2. The system according to claim 1, further comprising a generating AI means for assigning a role suitable for a particular user based on the user's registration information.

3. The system according to claim 1, further comprising means for analyzing the feedback information and reflecting the information in the next service.

Images