System

Abstract

To provide a system for analyzing risk profiles of users by utilizing generated AI and proposing an optimum insurance plan.SOLUTION: A means for the user to input risk profile information, a means for the server to receive and store the risk profile information in a database, a means for the server to transmit the risk profile information to a generative artificial intelligence, a means for the generative artificial intelligence to analyze the risk profile information and select an appropriate insurance plan, a means for the generative artificial intelligence to return the selected insurance plan to the server, a means for the server to present the returned insurance plan to the user, a means for the user to customize the insurance plan and finalize the final insurance plan, a means for the server to receive and store the finalized insurance plan in the database, a means for the server to transmit the finalized insurance plan to the insurance company system, and a means for the server to notify the user of the completion of the insurance application.SELECTED DRAWING: Figure 1

Description

[Technical Field]

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

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

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

[0004] With a wide variety of insurance options available, it is difficult for many users to select the optimal insurance plan suited to their individual risks. Finding the optimal insurance plan based on one's own risk profile is particularly problematic, requiring a great deal of time and effort. Furthermore, if users lack the ability to accurately assess their own risks and select the appropriate insurance plan, they run the risk of making the wrong choice. To solve these problems, a system is needed that can accurately analyze users' risk profiles and efficiently propose optimal insurance plans. [Means for solving the problem]

[0005] The present invention provides a system that utilizes a generation AI to analyze a user's risk profile and propose an optimal insurance plan. This system includes the following means: a means for a user to input risk profile information, and a means for a server to receive the risk profile information and store it in a database. The system also includes a means for the server to send the risk profile information to a generation AI, a means for the generation AI to analyze the risk profile information and select an appropriate insurance plan, and a means for the server to return the insurance plan selected by the generation AI to the server. The system also includes a means for the server to present the returned insurance plan to the user, and a means for the user to customize the insurance plan and finalize the final insurance plan. The system also includes a means for the server to receive the finalized insurance plan and store it in a database, a means for sending the finalized insurance plan to an insurance company's system, and a means for notifying the user that the insurance application has been completed.

[0006] "Risk profile information" refers to various data related to a user's specific risks, such as the user's age, occupation, health status, and hobbies.

[0007] "Server" means a computer system for receiving, storing, and processing risk profile information.

[0008] "Generative AI" is a system that includes machine learning algorithms and natural language processing technology to analyze risk profile information and select the most appropriate insurance plan.

[0009] An "insurance plan" is an insurance product designed to address specific risks, such as life insurance, medical insurance, accident insurance, or fire insurance.

[0010] A "user" is an individual who accesses the system, enters their risk profile information, and selects an insurance plan.

[0011] "Database" means an information management system for storing risk profile information and selected insurance plans.

[0012] An "insurance company system" is a computer system operated by an insurance company for accepting and processing insurance applications.

[0013] The "notification means" is a method for notifying the user of the completion of the insurance application and other information via email or a web page.

[0014] "Means for customization" refers to a method by which a user can individually set and adjust special clauses, options, etc. for a proposed insurance plan.

[0015] "Analyzing" is the process of interpreting data based on risk profile information and determining the optimal insurance plan.

[0016] "Storage means" means a method for temporarily or permanently recording received data. [Brief explanation of the drawings]

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

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

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

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

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

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

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

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

[0025] [First embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0038] The present invention is a system that analyzes a user's risk profile and proposes an appropriate insurance plan. This system is realized by the mutual cooperation of three parties: a server, a terminal, and a user. The specific program processing and its flow are explained below.

[0039] First, the user accesses the system using their own terminal. The system displays a form for the user to enter risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies. Once the user enters this information and clicks the submit button, the information is sent to the server.

[0040] Next, the server receives the risk profile information sent by the user and stores it in a database. Once stored, the server sends the risk profile information to the AI ​​generator. This transmission uses a data format such as JSON.

[0041] The Generative AI (Generative Artificial Intelligence) analyzes the received risk profile information. This analysis uses natural language processing and machine learning algorithms. As a result of the analysis, the Generative AI selects the insurance plan that best suits the user's risk profile from 10 candidates. The selected insurance plan is then sent back from the Generative AI to the server.

[0042] The server receives the insurance plan returned by the generation AI and displays it to the user. The user can review the proposed insurance plan and, if necessary, view detailed information or customize it. For example, they can add specific riders or adjust the scope of coverage. Once the user has finally decided on an insurance plan that satisfies them, the information is sent to the server.

[0043] The server receives the confirmed insurance plan and stores it in the database. Then it sends this information to the insurance company's system, which completes the insurance application. Finally, the server notifies the user that the insurance application has been completed. This can be done by email or on a web page.

[0044] Specific examples

[0045] For example, if a 30-year-old single man uses the system, the following process takes place. First, the user enters information such as age "30," occupation "IT company engineer," health condition "good," and hobby "outdoor activities." The server receives this information and sends it to the generation AI. Since the user likes outdoor activities, the generation AI considers the applicability of accident insurance and travel insurance and presents an appropriate plan. The user reviews these plans and customizes them, focusing particularly on medical insurance. The server then sends the application information to the insurance company and notifies the user of completion.

[0046] In this way, the system of the present invention can efficiently analyze a user's risk profile and provide an optimal insurance plan.

[0047] The processing flow will be explained below.

[0048] Step 1:

[0049] A user accesses the system using a web browser or application by entering the system's URL and clicking the access button.

[0050] Step 2:

[0051] The server is then contacted and displays a form for filling out a risk profile, which includes fields for entering information such as age, occupation, health status, and hobbies.

[0052] Step 3:

[0053] The user enters risk profile information and clicks the "Submit" button. For example, the user enters information such as age "30 years old," occupation "IT engineer," health condition "good," and hobby "outdoor activities."

[0054] Step 4:

[0055] The server receives the data submitted through the form and stores it in a database, which is stored in an SQL database.

[0056] Step 5:

[0057] The server sends the stored risk profile information to the generation AI using JSON format data.

[0058] Step 6:

[0059] The generative AI analyzes the received risk profile information using natural language processing (NLP) techniques and machine learning models.

[0060] Step 7:

[0061] Based on the risk profile information, the generative AI selects the most suitable insurance plan from 10 candidate plans using an algorithm.

[0062] Step 8:

[0063] The generation AI returns the selected insurance plan to the server in JSON format.

[0064] Step 9:

[0065] The server presents the insurance plans received from the generation AI to the user, who is then shown a dynamically generated list of insurance plans on an HTML page.

[0066] Step 10:

[0067] The user reviews the insurance plan presented to them and customizes it as needed, for example, by adding specific riders or adjusting the scope of coverage.

[0068] Step 11:

[0069] The user finally decides on a customized insurance plan that satisfies him and clicks the "Confirm" button.

[0070] Step 12:

[0071] The server receives the finalized insurance plan and stores it in a database, which is stored in an SQL database.

[0072] Step 13:

[0073] The server sends the finalized insurance plan to the insurance company's system using REST API or SOAP protocol.

[0074] Step 14:

[0075] The server notifies the user that the insurance application is complete, either by email or via a web page.

[0076] Example 1

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

[0078] In modern society, it is important to easily provide optimal insurance plans to individual users. However, conventional methods require users to collect and compare large amounts of information, which is time-consuming. Furthermore, insurance plan proposals are not based on the user's specific risk profile, which often results in an inappropriate selection of the optimal plan. In addition, the process for users to confirm their customized insurance plan and apply to an insurance company is complicated and inefficient. Thus, there is a need for a system that can accurately analyze a user's risk profile, propose an appropriate insurance plan, and complete the insurance application quickly and efficiently.

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

[0080] In this invention, the server includes a means for a user to input risk profile information, a means for the server to receive the risk profile information and store it in a database, and a means for the server to transmit the risk profile information to the AI ​​generator. This makes it possible to efficiently collect the user's risk profile information and have the AI ​​generator analyze it. Furthermore, the AI ​​generator can provide an optimal insurance plan as a result of its analysis, allowing the user to quickly apply for a customized plan with an insurance company.

[0081] A "User" is any person or entity that provides risk profile information to the system for the purpose of receiving insurance plan offers.

[0082] The "server" is a computer system that receives risk profile information provided by users, stores it in a database, and transmits the information to the generation AI and processes the results.

[0083] "Risk profile information" refers to information necessary for selecting an insurance plan, such as a user's age, occupation, health condition, and hobbies.

[0084] "Database" means a system for organizing and storing user risk profile information and insurance plan information.

[0085] "Generative AI" is a program that uses machine learning and natural language processing technology to analyze a user's risk profile information and select the most appropriate insurance plan based on the results.

[0086] An "insurance plan" is a form of insurance contract that includes specific coverage and terms offered to a user.

[0087] "Customization" refers to a user adding riders or adjusting the scope of coverage to a proposed insurance plan.

[0088] An "interactive form" is a portion of a web page that contains dynamically operable input fields to facilitate user input of risk profile information.

[0089] An "insurance company" is a company that actually writes insurance contracts based on the insurance plans offered.

[0090] "Notification" is a message to inform the user of the completion of the insurance application or other important information.

[0091] The present invention is a system for analyzing a user's risk profile information and proposing an optimal insurance plan. This system is realized by operating multiple hardware and software components in cooperation with each other. Specific embodiments for implementing the present invention are described below.

[0092] First, a user accesses the system using a device (PC, smartphone, tablet, etc.). The device used here requires a common web browser (Google Chrome, Mozilla Firefox, Apple Safari, etc.) and a network connection. When the user enters the system's URL and accesses it, a login screen appears and the user enters their authentication information to log in to the system.

[0093] After a successful login, the server presents the user with a form to enter their risk profile information. The form is written in HTML, CSS, and JavaScript and includes input fields for age, occupation, health status, hobbies, etc.

[0094] When a user enters their risk profile information and clicks the submit button, the form data is converted to JSON format by JavaScript and sent to the server via HTTPS. For example, a 30-year-old single man enters the following information: age: 30, occupation: IT engineer, health status: good, and hobby: outdoor activities.

[0095] The server receives the risk profile information sent by the user and stores it in a database (e.g., MySQL or PostgreSQL), where it also performs data validation and validation checks.

[0096] The server then sends the stored risk profile information to the Generation AI, which uses an advanced AI model such as GPT-4. The data is in JSON format and passed to the Generation AI via a RESTful API.

[0097] The Generator AI uses natural language processing (NLP) techniques and machine learning algorithms (for example, using the PyTorch or TensorFlow frameworks) to analyze the received risk profile information. As a result of this analysis, the Generator AI selects the optimal insurance plan from 10 candidates. This candidate plan is then sent back to the server in JSON format.

[0098] The server receives the insurance plan returned by the generation AI and displays it in HTML format to the user, who can then review the proposed insurance plan through a web browser, add specific riders, or adjust the coverage.

[0099] Furthermore, when the user customizes and confirms the insurance plan, the customization information is sent again to the server in JSON format. After the server receives the confirmed insurance plan, it stores it in the database. The final insurance plan information is sent from the server to the insurance company's system. Security protocols (e.g., OAuth) are also applied during the transmission via the insurance company's API.

[0100] Finally, the server notifies the user that the insurance application has been completed. The notification can be sent via email or a web page. Email notifications are sent using the SMTP protocol, and web notifications are sent via JavaScript.

[0101] An example of a prompt sentence is input to the generative AI model in text format, such as, "A 30-year-old single male, an engineer at an IT company, in good health, and whose hobby is outdoor activities. Please suggest the best insurance plan for this user." Based on this prompt, the generative AI selects an insurance plan that matches the user's risk profile.

[0102] As described above, the server, user, and generation AI work together to create a system that efficiently proposes the optimal insurance plan to the user and speeds up the application process.

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

[0104] Step 1: The user accesses the system using a terminal

[0105] Specific operation: A user opens a web browser on a device such as a PC, smartphone, or tablet, and enters the system's URL to access it. At this time, the user enters authentication information (user name and password) on the login screen to log in to the system.

[0106] Input: System URL, user authentication information (username, password)

[0107] Output: The user is successfully logged in and the system home page is displayed.

[0108] Step 2: The server displays the input form

[0109] What it does: After a user successfully logs in, the server displays an HTML form for the user to enter their risk profile information. The form includes input fields for age, occupation, health status, hobbies, etc.

[0110] Input: User login success information

[0111] Output: An HTML form for entering risk profile information is displayed in the user's browser.

[0112] Step 3: User enters and submits risk profile information

[0113] Specific operation: The user enters the required risk profile information into the displayed form. When the user has completed the input, they click the "Submit" button. Upon clicking, JavaScript converts the form data into JSON format and sends it to the server via the HTTPS protocol.

[0114] Input: User's risk profile information (age, occupation, health status, hobbies, etc.)

[0115] Output: Risk profile information is sent to the server in JSON format.

[0116] Step 4: The server receives the information and stores it in a database

[0117] Specific operation: The server receives the JSON data sent by the user. After receiving it, the server checks the validity of the data, performs any necessary validation, and then saves it in a database (MySQL or PostgreSQL) using SQL commands.

[0118] Input: Risk profile information in JSON format

[0119] Output: Risk profile information stored in a database

[0120] Step 5: The server sends the information to the generated AI

[0121] Specific operation: The server sends the saved risk profile information to the generation AI. This is done via a RESTful API, and the data is again in JSON format. A request is made to the API endpoint.

[0122] Input: Risk profile information stored in the database

[0123] Output: Risk profile information in JSON format is sent to the generation AI

[0124] Step 6: Generative AI analyzes the information and selects an insurance plan

[0125] How it works: The Generator AI performs an analysis based on the received risk profile information. This analysis uses NLP techniques and machine learning algorithms (e.g., PyTorch and TensorFlow frameworks). Based on the analysis, the Generator AI selects the most suitable insurance plan from 10 candidates based on the user's risk profile.

[0126] Input: Risk profile information in JSON format

[0127] Output: Insurance plan data in JSON format (10 options)

[0128] Step 7: The generative AI sends the results back to the server

[0129] Specific operation: The insurance plan selected by the generation AI is returned to the server in JSON format. The return is also done using a RESTful API.

[0130] Input: Insurance plan data in JSON format (10 options)

[0131] Output: Insurance plan data in JSON format is sent to the server

[0132] Step 8: Server displays insurance plan to user

[0133] Specific operation: The server receives the insurance plans returned by the generation AI and displays them to the user in HTML format. The user's device browser displays a list of selected insurance plans.

[0134] Input: Insurance plan data in JSON format (10 options)

[0135] Output: A list of insurance plans in HTML format, displayed in the user's browser.

[0136] Step 9: User reviews and customizes plan

[0137] How it works: The user reviews the insurance plans displayed, selects a specific plan, adds riders, or adjusts coverage. These customization operations are also performed using JavaScript, and the selection information is again converted to JSON format and sent to the server.

[0138] Input: User customization operations (adding special clauses, adjusting coverage, etc.)

[0139] Output: Customized insurance plan information is sent to the server in JSON format.

[0140] Step 10: The server receives and stores the final plan

[0141] Specific operation: The server receives the customized insurance plan information and saves it back to the database. The save operation is also performed using SQL statements. Data integrity checks are performed to ensure accurate data is saved.

[0142] Input: Customized insurance plan information in JSON format

[0143] Output: Customized insurance plan information stored in a database

[0144] Step 11: Server sends information to insurance company

[0145] What happens: The server sends the final insurance plan information to the insurance company's system, again via an API and applying security protocols (e.g., OAuth) as needed.

[0146] Input: Final insurance plan information stored in the database

[0147] Output: Insurance plan information sent to the insurance company's system

[0148] Step 12: The server notifies the user

[0149] Specific operation: The server notifies the user that the insurance application has been completed. This notification can be sent via email or a web page. Emails are sent using the SMTP protocol, and web notifications are sent via JavaScript.

[0150] Input: Final insurance plan information submitted

[0151] Output: Notification of insurance application completion sent to the user

[0152] As mentioned above, we have explained in detail how specific inputs and outputs, as well as data processing and calculations are performed at each step. This will enable the realization of a system that efficiently analyzes a user's risk profile information and proposes the most suitable insurance plan.

[0153] (Application example 1)

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

[0155] Current security plan offerings face the challenge of making it difficult to select the optimal plan based on a user's individual risk profile. Furthermore, it is difficult for users to determine which security measures are optimal, which can result in excessive or insufficient measures being selected. This not only reduces the efficiency and effectiveness of security, but also leads to cost waste. This invention aims to solve these challenges by providing a system that automatically selects and proposes the optimal security plan based on the user's risk profile.

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

[0157] In this invention, the server includes a means for a user to input risk profile information, a means for the server to receive the risk profile information and store it in a database, and a means for the server to transmit the risk profile information to a generating artificial intelligence. This provides a system including a means for the generating artificial intelligence to analyze the risk profile information and select an appropriate security plan, a means for the generating artificial intelligence to return the security plan selected by the generating artificial intelligence to the server, a means for the server to present the returned security plan to the user, a means for the user to customize the security plan and finalize the final security plan, a means for the server to receive the finalized security plan and store it in a database, a means for the server to transmit the finalized security plan to a security provider's system, and a means for the server to notify the user that the security plan is complete. This allows users to easily select and customize an appropriate security plan and implement effective security measures.

[0158] "User" means an individual or entity that inputs risk profile information into the system and selects and customizes a security plan.

[0159] "Risk profile information" is data that includes information such as a user's age, occupation, residential area, frequency of internet use, and past intrusion experiences.

[0160] A "server" is a hardware or software system that receives risk profile information from users, stores it in a database, and transmits it to the generation AI.

[0161] "Database" means a data management system for storing risk profile information and established security plans received by the Server.

[0162] "Generative artificial intelligence (generative AI)" refers to artificial intelligence technology that analyzes risk profile information received from users and selects the optimal security plan.

[0163] "Security plan" refers to specific proposals for security measures required by users, including home security systems, cybersecurity measures, and personal information protection.

[0164] "Security provider" means a company or organization that implements and provides the security plan selected and confirmed by the user.

[0165] "Collaboration" refers to the process by which multiple systems or services work together and exchange information.

[0166] "Security Measures" refers to the means used to protect Users' personal information and physical property, and includes technical, organizational, and physical measures.

[0167] A system embodying the present invention is one in which a user inputs risk profile information and an optimal security plan is proposed and customized. Specific embodiments are described below.

[0168] First, a user accesses the system using their own device (e.g., a smartphone). The system displays a form for the user to enter risk profile information. This form includes fields for entering information such as age, occupation, residential area, frequency of internet use, and past breaches. When the user enters this information and clicks the submit button, the information is sent to the server in JSON format.

[0169] Next, the server receives the risk profile information sent by the user and stores it in a database. The database uses a cloud-based data management system such as AWS RDS (MySQL). Once stored, the server sends the risk profile information to a generation AI. The generation AI is implemented in Python and uses machine learning models using scikit-learn and TensorFlow.

[0170] The Generator AI analyzes the received risk profile information and selects an appropriate security plan. This analysis utilizes a machine learning algorithm that generates optimal output based on specific input information. As a result of the analysis, the Generator AI selects the security plan that best suits the user's risk profile from multiple candidates. The selected security plan is then sent back from the Generator AI to the server.

[0171] The server receives the security plan returned by the generation AI and displays it to the user. The user can review the proposed security plan and, if necessary, view detailed information or customize it. For example, they can add specific security measures or adjust the scope of services. Once the user has finalized a security plan that satisfies them, the information is sent back to the server.

[0172] The server receives the confirmed security plan and stores it in its database. It then sends this information to the security provider's system, which completes the security service application. Finally, the server notifies the user that the security plan has been completed. This notification is sent via email or a web page.

[0173] Specific examples

[0174] For example, if a 35-year-old single man uses the system, the following process takes place. First, the user enters information such as age (35), occupation (systems engineer), residential area (Tokyo), frequency of internet use (daily), and no prior hacking experience. The server receives this information and sends it to the generation AI. Based on the user's data, the generation AI presents appropriate plans, such as a home security system, antivirus software, and personal information protection service. The user reviews these plans and adds or adjusts measures that are particularly important to them. The server then sends the confirmed information to the security provider and notifies the user of completion.

[0175] Example prompts for generative AI models

[0176] "Please suggest the best security plan based on the user's risk profile information. Here is the user information:

[0177] Age: 35

[0178] Occupation: Systems Engineer

[0179] Living area: Tokyo

[0180] Internet usage frequency: Daily

[0181] Previous breaches: None

[0182] In this way, the present invention can efficiently analyze a user's risk profile and provide an optimal security plan.

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

[0184] Step 1:

[0185] The user accesses the system using their own terminal. The terminal displays a form for entering risk profile information. The user enters information such as age, occupation, residential area, frequency of internet use, and past breaches, and clicks the submit button.

[0186] Input: Risk profile information entered by the user into a form (age, occupation, region of residence, frequency of internet use, previous breaches).

[0187] Output: Risk profile information sent to the server in JSON format.

[0188] Step 2:

[0189] The server receives the risk profile information sent by the user and stores this information in a database.

[0190] Input: Risk profile information sent from the device.

[0191] Output: Risk profile information stored in a database.

[0192] Step 3:

[0193] The server sends the risk profile information stored in the database to the Generating Artificial Intelligence (Generating AI) using JSON format data.

[0194] Input: Risk profile information stored in the database.

[0195] Output: Risk profile information sent to the generating AI.

[0196] Step 4:

[0197] The Generator AI analyzes the received risk profile information and, specifically, uses natural language processing and machine learning algorithms to select the most appropriate security plan for the user.

[0198] Input: Risk profile information sent by the server.

[0199] Output: A suitable security plan is selected.

[0200] Step 5:

[0201] The generation AI returns the selected security plan to the server.

[0202] Input: An appropriate security plan selected by the generative AI.

[0203] Output: The security plan sent back to the server by the generation AI.

[0204] Step 6:

[0205] The server then presents the received security plan to the user's terminal, where the user can review the plan and customize it as needed.

[0206] Input: The security plan sent back to the server.

[0207] Output: The security plan displayed on the user's device.

[0208] Step 7:

[0209] The user customizes the security plan and finalizes it, which is then sent from the device to the server.

[0210] Input: User customized security plan.

[0211] Output: Finalized security plan.

[0212] Step 8:

[0213] The server receives the finalized security plan and stores it in the database again.

[0214] Input: The final confirmed security plan submitted by the user.

[0215] Output: The final security plan stored in the database.

[0216] Step 9:

[0217] The server sends the finalized security plan to the security provider's system, thereby completing the application for security services.

[0218] Input: The final security plan stored in the database.

[0219] Output: The security plan sent to the security contractor's system.

[0220] Step 10:

[0221] The server will notify the user that the security service subscription has been completed. This notification will be sent via email or a web page.

[0222] Input: Record of completed transmission from server to security company.

[0223] Output: Completion notification sent to the user.

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

[0225] This invention is a system that analyzes a user's risk profile and proposes the optimal insurance plan through a system that combines generative AI and an emotion engine. The specific program processing and flow are explained below.

[0226] First, the user accesses the system using their own terminal. The system homepage is displayed, and the user accesses a form for entering risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies.

[0227] The server then embeds an emotion engine into the input form, and while the user is entering information, the emotion engine collects and analyzes emotion data from the user's facial expressions and tone of voice. The obtained emotion data is then sent to the server along with risk profile information.

[0228] The server receives the risk profile information and emotional data sent by the user and stores it in a database. Once saved, the server sends this information to the generation AI, which then analyzes the received risk profile information and emotional data. This analysis uses natural language processing (NLP) technology and machine learning algorithms. In addition, by taking emotional data into account, it becomes possible to select an insurance plan that reflects the user's emotional state.

[0229] The AI ​​selects an appropriate insurance plan from 10 options based on the risk profile and emotional data. For example, if the user has low risk tolerance, it will prioritize a plan that provides a greater sense of security. The AI ​​then returns the selected insurance plan to the server.

[0230] The server presents the insurance plans received from the generation AI to the user. The user reviews these plans and customizes them as necessary. At this time, the emotion engine can re-analyze the user's reactions and reflect them in the customization suggestions. For example, if the user is unsure about the plan contents, the emotion engine will detect this and display a more detailed explanation.

[0231] Once the user has finalized the customized insurance plan that satisfies them, the finalized information is sent to the server. The server stores the finalized insurance plan in the database again and sends this information to the insurance company's system. Once the insurance application is complete, the server notifies the user of the completion. This can be done by email or on a web page.

[0232] Specific examples

[0233] For example, a 30-year-old single man uses the system and enters his age (30), occupation (IT engineer), health condition (good), and hobby (outdoor activities). The emotion engine detects that the user is feeling a little anxious as he enters the information. Based on this risk profile and emotion data, the generative AI selects an insurance plan that emphasizes greater peace of mind. The plan may include medical insurance and life insurance, and detailed explanations and special terms and conditions are provided to enhance peace of mind. The user customizes these plans and finally confirms them.

[0234] This allows the system of the present invention to comprehensively analyze the user's risk profile and emotional state and effectively propose the most suitable insurance plan.

[0235] The processing flow will be explained below.

[0236] Step 1:

[0237] The user accesses the system using a terminal. The system homepage is displayed, and the user clicks the "Enter Risk Profile Information" button.

[0238] Step 2:

[0239] The server displays a form for entering risk profile information, including fields for age, occupation, health status, hobbies, etc.

[0240] Step 3:

[0241] As users begin to enter their risk profile information, the emotion engine kicks in and begins collecting emotional data from the user's facial expressions and vocal tone, for example, by analyzing the data in real time using the camera and microphone.

[0242] Step 4:

[0243] The user enters all the risk profile information and clicks the "Submit" button. Example: The user enters age "30 years old", occupation "IT engineer", health condition "good", and hobby "outdoor activities".

[0244] Step 5:

[0245] The emotion engine analyzes the user's emotion data and estimates their current emotional state, such as anxiety, relief, or excitement.

[0246] Step 6:

[0247] The server receives the risk profile information submitted through the form and the emotion data obtained from the emotion engine, and stores them in a database. The data is stored in an SQL database.

[0248] Step 7:

[0249] The server sends risk profile information and emotion data to the generation AI via the module, using JSON format data.

[0250] Step 8:

[0251] The generative AI analyzes risk profile information and sentiment data to select an appropriate insurance plan from 10 options. For example, if peace of mind is a priority, medical insurance and life insurance may be included.

[0252] Step 9:

[0253] The generation AI returns the selected insurance plan to the server in JSON format.

[0254] Step 10:

[0255] The server presents the insurance plans received from the generation AI to the user, who can then view the dynamically generated list of insurance plans on an HTML page.

[0256] Step 11:

[0257] The user reviews the insurance plan and customizes it as needed. At this point, the emotion engine is activated again to analyze the user's reactions. For example, if the user is feeling uneasy about a particular plan, it sends that information to the server.

[0258] Step 12:

[0259] The server provides the user with additional information or other suggestions based on the analysis results of the emotion engine, thereby increasing the user's sense of security.

[0260] Step 13:

[0261] The user finally decides on a customized insurance plan that satisfies him and clicks the "Confirm" button.

[0262] Step 14:

[0263] The server saves the confirmed insurance plan back to the database. The data is saved in an SQL database.

[0264] Step 15:

[0265] The server sends the finalized insurance plan to the insurance company's system using REST API or SOAP protocol.

[0266] Step 16:

[0267] The server notifies the user that the insurance application is complete, either by email or via a web page.

[0268] Example 2

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

[0270] Conventional insurance proposal systems propose insurance plans based solely on the user's risk profile information, making it difficult to propose optimal insurance plans that take the user's emotional state into account. Furthermore, since the proposed plans cannot reflect the user's emotions and reactions at the time of input, user satisfaction may decline. This leaves users feeling anxious and uncertain, making it difficult to select an appropriate insurance plan.

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

[0272] In this invention, the server includes a means for a user to input risk profile information, a means for an emotion engine to collect and analyze emotion data from the user's facial expressions and tone of voice, a means for transmitting the collected emotion data together with the risk profile information to the server, and a means for a generating artificial intelligence to analyze the risk profile information and emotion data and select an appropriate insurance plan. This makes it possible to propose an optimal insurance plan that comprehensively considers the user's risk profile information and emotional state.

[0273] "User" refers to an individual who utilizes the system to input risk profile information and propose and customize insurance plans.

[0274] "Terminal" refers to a device operated by a user to access the system and input information.

[0275] "Server" refers to the system component that receives, stores, and analyzes user input information and connects with the generation AI and database.

[0276] "Risk profile information" refers to personal information that users enter into the system, including information related to risk assessment, such as age, occupation, health status, and hobbies.

[0277] "Emotion Engine" refers to the software component that collects and analyzes emotional data from a user's facial expressions and vocal tone in real time.

[0278] "Emotion data" refers to data that indicates the user's emotional state, obtained by the emotion engine analyzing the user's facial expressions and tone of voice.

[0279] "Generative AI" refers to algorithms and models that analyze risk profile information and emotional data to select appropriate insurance plans.

[0280] "Insurance plan" refers to the composition and features of multiple insurance products selected by the generation AI and presented to the user.

[0281] "Database" refers to data storage for storing risk profile information, sentiment data, confirmed insurance plans, etc.

[0282] "Insurance company system" refers to an external system to which the server sends finalized insurance plans and manages insurance applications.

[0283] "Customization" refers to the act of a user adjusting or modifying the insurance plan presented to them to suit their own needs and circumstances.

[0284] "Confirmation" refers to the act of the user finally selecting a customized insurance plan and sending it to the server.

[0285] "Notification" refers to a communication method used by the server to inform the user of the completion of the insurance application or other important information.

[0286] The present invention analyzes a user's risk profile through a system that combines a generative AI and an emotion engine, and proposes an optimal insurance plan. Specific embodiments are described below.

[0287] First, a user accesses the system using their own device. The system's homepage is displayed, and the user accesses a form for entering risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies. Input is typically done using a keyboard or touchscreen.

[0288] The server then embeds an emotion engine into the input form, and while the user is entering data, it uses a camera and microphone to collect emotion data from the user's facial expressions and tone of voice. The emotion engine analyzes the collected data in real time and determines the user's emotional state. For example, if the user looks anxious, "anxiety" is detected as the emotion data.

[0289] The server receives the risk profile information and emotion data sent by the user and stores them in a database. Once stored, the server sends this information to the generative AI, which then analyzes the risk profile information and emotion data using natural language processing (NLP) techniques and machine learning algorithms. The generative AI model used here is an advanced natural language generation model such as GPT-3.

[0290] Based on the analysis results, the generative AI selects an appropriate insurance plan from 10 candidates. For example, if the user has low risk tolerance and feels anxious, an insurance plan with content that gives them more peace of mind will be selected. The selected insurance plan is then sent back to the server.

[0291] The server presents the insurance plan received from the generation AI to the user. The user reviews the plan and customizes it as needed. During this customization, the emotion engine again analyzes the user's reaction and, for example, if the user feels anxious, presents detailed explanations and additional options.

[0292] Once the user has finalized the customized insurance plan that satisfies them, the information is sent to the server. The server stores the finalized insurance plan in the database again and sends this information to the insurance company's system. Once the insurance application is complete, the server notifies the user of the completion. This can be done by email or on a web page.

[0293] Specific examples

[0294] For example, use the following prompt:

[0295] The user is a single man, aged 30, works as an engineer in an IT company, is in good health, and enjoys outdoor activities. The user is entering his information with some trepidation. Please suggest an insurance plan that emphasizes peace of mind.

[0296] Based on this prompt, the generative AI can comprehensively analyze the user's profile and emotional state to suggest an appropriate insurance plan, which the user can then review and customize before making a final decision.

[0297] As a result, the present invention can propose optimal insurance plans that comprehensively take into account the user's risk profile and emotional state, and that will provide high levels of user satisfaction.

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

[0299] Step 1: User enters risk profile information

[0300] Users access the system using their own terminal and enter their risk profile information. The system homepage is displayed on the terminal, and a form is presented to enter information such as age, occupation, health status, and hobbies. The entered data is sent from the terminal to the server.

[0301] Input: User's risk profile information (age, occupation, health status, hobbies)

[0302] Output: Risk profile information sent to the server

[0303] Step 2: Collecting sentiment data in real time

[0304] The server embeds an emotion engine into the input form, and uses a camera and microphone to collect emotion data from the user's facial expressions and tone of voice as they input information. The emotion engine analyzes this data in real time to determine the user's emotional state.

[0305] Input: User's facial expression data, voice tone data

[0306] Output: Real-time emotion data to the server

[0307] Step 3: Send and store data

[0308] The server receives the risk profile information and emotion data sent by the user, stores this data in the system's database, and simultaneously sends the risk profile information and emotion data to the generation AI.

[0309] Input: Risk profile information, emotion data

[0310] Output: Save to database, send data to generation AI

[0311] Step 4: Data analysis with generative AI

[0312] The generative AI receives risk profile information and emotional data sent from the server and analyzes them using natural language processing (NLP) technology and machine learning algorithms. As a result of the analysis, an insurance plan that reflects the user's risk tendencies and emotional state is selected.

[0313] Input: Risk profile information, emotion data

[0314] Output: Analysis results (insurance plan based on user's risk propensity and emotional state)

[0315] Step 5: Select an insurance plan

[0316] Based on the analysis results, the generative AI selects the optimal insurance plan from 10 candidates. For example, if the user has low risk tolerance and is feeling anxious, the insurance plan with the most reassuring content will be selected.

[0317] Input: Analysis results by generative AI

[0318] Output: Selected insurance plans (10 candidates)

[0319] Step 6: Present to the user and customize

[0320] The server presents the insurance plan received from the generation AI to the user. The user reviews the presented plan and customizes it as necessary. At this time, the emotion engine again analyzes the user's reaction and, for example, if the user feels uneasy, presents detailed explanations and additional options.

[0321] Input: Selected insurance plan, user response data

[0322] Output: Customized insurance plan, additional instructions and options

[0323] Step 7: Finalize and notify

[0324] Once the user is satisfied with the customized insurance plan and finalizes it, the information is sent to the server. The server saves the finalized insurance plan in the database and sends it to the insurance company's system. Once the insurance application is complete, the server notifies the user.

[0325] Enter: Customized Insurance Plan

[0326] Output: Save to database, send to insurance company's system, notify user of completion

[0327] (Application example 2)

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

[0329] Conventional systems cannot consider the user's emotional state or real-time emotional data when analyzing the user's risk profile and proposing an appropriate plan, and as a result, the plan provided often does not adapt to the user's actual needs or emotional state. To solve this problem, a system that utilizes the user's real-time emotional data to provide a more personalized plan is needed.

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

[0331] In this invention, the server includes: means for a user to input risk profile information; means for the server to receive the risk profile information and store it in a database; means for the server to collect and receive emotion data in addition to the risk profile information; means including an emotion engine that analyzes sensor data from the smart device to generate emotion data; means for the server to transmit the risk profile information and emotion data to a generating artificial intelligence; means for the generating artificial intelligence to analyze the risk profile information and emotion data and select an appropriate plan; means for the generating artificial intelligence to return the selected plan to the server; means for the server to present the returned plan to the user; means for the user to customize the plan and finalize the final plan; means for the server to receive the finalized plan and store it in a database; means for the server to transmit the finalized plan to a related system; and means for the server to notify the user that the application has been completed. This makes it possible to provide a personalized plan that is adapted to the user's actual needs and emotional state by utilizing the user's emotion data.

[0332] "Risk profile information" is information that indicates the risk characteristics of a user, such as the user's age, occupation, health condition, and hobbies.

[0333] "Emotion data" is data that indicates the user's emotional state, generated from the user's facial expression, tone of voice, etc.

[0334] The "emotion engine" is a system that analyzes sensor data from smart devices to generate user emotion data.

[0335] "Generative AI" or "generative artificial intelligence" is artificial intelligence that analyzes a user's risk profile information and emotional data and selects an appropriate plan.

[0336] A "smart device" is an electronic device equipped with a camera and microphone that is used to capture emotional data.

[0337] The "database" is a storage device for storing information such as risk profile information, emotion data, and confirmed plans received by the server.

[0338] A "server" is a computer system responsible for processing information received from users, storing it in a database, and transmitting the information to related systems.

[0339] A "plan" is an appropriate insurance or spending plan selected based on the user's risk profile information and sentiment data.

[0340] "Relevant system" means the insurance company's system that receives the finalized plan or any other appropriate system.

[0341] The present invention is a system that analyzes a user's risk profile information and emotion data and proposes an appropriate plan. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS The following describes in detail specific embodiments of the present invention.

[0342] Initial Setup

[0343] A user installs the application on their smartphone and enters basic information (age, occupation, income, hobbies, etc.) when they first launch the application. This initial setting information becomes the data necessary for the user's risk profile.

[0344] Collecting Emotional Data

[0345] The smartphone's camera and microphone are used to collect facial expressions and vocal tones while the user is entering information. This emotional data is analyzed by the emotion engine and converted into a numerical emotion score.

[0346] Data transmission and analysis

[0347] The server stores the risk profile information and emotion data received from the user in a database, and simultaneously transmits this data to the generation AI.

[0348] The Generative AI analyzes the received risk profile information and emotion data to select the optimal plan, using natural language processing (NLP) technology and machine learning algorithms.

[0349] Plan proposal and customization

[0350] The artificial intelligence generator sends the selected plan back to the server, which then displays it on the user's smartphone, where the user can confirm the details.

[0351] Users can customize the proposed plan, and the emotion engine will again analyze the user's reactions and adjust the plan accordingly.

[0352] For example, if a user is unsure about a suggestion, a detailed explanation is automatically added.

[0353] Confirmation and Notification

[0354] When the user finally decides on a customized plan to his satisfaction, the server stores the decision information in a database and transmits it to the related systems.

[0355] The server will notify the user of the completion of the application via email or the app's notification function.

[0356] Specific use cases

[0357] For example, if a 30-year-old single man uses this system, he will enter his age as "30," his occupation as "IT company engineer," and his income as "5 million yen," and will supplement it with information about his hobby as "outdoor activities." The emotion engine will also detect that the user is feeling a little uneasy when entering the information. Based on this risk profile and emotion data, the generation AI will select a plan that places more emphasis on peace of mind. The plan may include health insurance, life insurance, and special provisions for outdoor activities. In this case, the generation AI will use the following prompt:

[0358] Age: 30, Income: 5 million yen, Emotional score: 0.8, Please suggest an appropriate spending plan.

[0359] Hardware and software used

[0360] Smart devices: Emotional data is collected using the smartphone's camera and microphone.

[0361] Emotion Engine: Uses Keras to perform facial recognition and speech analysis to generate emotion scores.

[0362] Generative AI: Run a GPT-2 model using Hugging Face's Transformers library to analyze risk profile information and emotion data.

[0363] Servers and databases: Serve as the infrastructure for storing and analyzing user and confirmation information.

[0364] In this way, by utilizing the user's emotional data, the present invention can provide a personalized plan that is adapted to the user's actual needs and emotional state.

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

[0366] Step 1:

[0367] The user installs and launches the smartphone app. When the app is launched for the first time, it prompts the user to enter basic information (age, occupation, income, hobbies, etc.). This allows risk profile information to be collected. The entered data is sent to the server and stored in a database.

[0368] Input: Basic information such as age, occupation, income, hobbies, etc.

[0369] Output: Risk profile information stored on the server

[0370] Step 2:

[0371] While the user is entering information, the device's camera and microphone are activated to collect emotion data, such as facial expressions and tone of voice. The emotion engine analyzes this data and generates a numerical emotion score.

[0372] Input: facial expression data, voice tone data

[0373] Output: Numerical sentiment score

[0374] Step 3:

[0375] The server stores the risk profile information and emotion score in a database and sends it to the AI ​​for analysis, which then generates a prompt as data necessary for analysis.

[0376] Input: Risk profile information, sentiment score

[0377] Output: Prompt and data sent to the generation AI

[0378] Step 4:

[0379] The generation AI performs data analysis based on the received risk profile information and emotion scores. The analysis uses natural language processing technology and machine learning algorithms to select the plan that best suits the user's needs. The generation AI then returns the selection results to the server.

[0380] Input: prompt statement, risk profile information, sentiment score

[0381] Output: The optimal plan sent back to the server

[0382] Step 5:

[0383] The server displays the plan returned by the generation AI on the user's smartphone. The user can review the plan and customize it as needed. During the customization process, the emotion engine analyzes the user's reactions and adjusts the plan accordingly.

[0384] Input: Plan selected by the generation AI, user's reaction (facial expression, voice)

[0385] Output: A plan customized by the user

[0386] Step 6:

[0387] Once the user has finalized the customized plan to their satisfaction, the information is sent to the server, which stores the finalized information in a database and sends it to the relevant systems.

[0388] Input: Customized Plan

[0389] Output: Finalized plan stored in database, plan sent to relevant systems

[0390] Step 7:

[0391] The server notifies the user of the completion of the application via email or the app's notification function.

[0392] Input: Confirmed plan information

[0393] Output: Completion notification sent to the user

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

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

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

[0397] [Second embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0410] The present invention is a system that analyzes a user's risk profile and proposes an appropriate insurance plan. This system is realized by the mutual cooperation of three parties: a server, a terminal, and a user. The specific program processing and its flow are explained below.

[0411] First, the user accesses the system using their own terminal. The system displays a form for the user to enter risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies. Once the user enters this information and clicks the submit button, the information is sent to the server.

[0412] Next, the server receives the risk profile information sent by the user and stores it in a database. Once stored, the server sends the risk profile information to the AI ​​generator. This transmission uses a data format such as JSON.

[0413] The Generative AI (Generative Artificial Intelligence) analyzes the received risk profile information. This analysis uses natural language processing and machine learning algorithms. As a result of the analysis, the Generative AI selects the insurance plan that best suits the user's risk profile from 10 candidates. The selected insurance plan is then sent back from the Generative AI to the server.

[0414] The server receives the insurance plan returned by the generation AI and displays it to the user. The user can review the proposed insurance plan and, if necessary, view detailed information or customize it. For example, they can add specific riders or adjust the scope of coverage. Once the user has finally decided on an insurance plan that satisfies them, the information is sent to the server.

[0415] The server receives the confirmed insurance plan and stores it in the database. Then it sends this information to the insurance company's system, which completes the insurance application. Finally, the server notifies the user that the insurance application has been completed. This can be done by email or on a web page.

[0416] Specific examples

[0417] For example, if a 30-year-old single man uses the system, the following process takes place. First, the user enters information such as age "30," occupation "IT company engineer," health condition "good," and hobby "outdoor activities." The server receives this information and sends it to the generation AI. Since the user likes outdoor activities, the generation AI considers the applicability of accident insurance and travel insurance and presents an appropriate plan. The user reviews these plans and customizes them, focusing particularly on medical insurance. The server then sends the application information to the insurance company and notifies the user of completion.

[0418] In this way, the system of the present invention can efficiently analyze a user's risk profile and provide an optimal insurance plan.

[0419] The processing flow will be explained below.

[0420] Step 1:

[0421] A user accesses the system using a web browser or application by entering the system's URL and clicking the access button.

[0422] Step 2:

[0423] The server is then contacted and displays a form for filling out a risk profile, which includes fields for entering information such as age, occupation, health status, and hobbies.

[0424] Step 3:

[0425] The user enters risk profile information and clicks the "Submit" button. For example, the user enters information such as age "30 years old," occupation "IT engineer," health condition "good," and hobby "outdoor activities."

[0426] Step 4:

[0427] The server receives the data submitted through the form and stores it in a database, which is stored in an SQL database.

[0428] Step 5:

[0429] The server sends the stored risk profile information to the generation AI using JSON format data.

[0430] Step 6:

[0431] The generative AI analyzes the received risk profile information using natural language processing (NLP) techniques and machine learning models.

[0432] Step 7:

[0433] Based on the risk profile information, the generative AI selects the most suitable insurance plan from 10 candidate plans using an algorithm.

[0434] Step 8:

[0435] The generation AI returns the selected insurance plan to the server in JSON format.

[0436] Step 9:

[0437] The server presents the insurance plans received from the generation AI to the user, who is then shown a dynamically generated list of insurance plans on an HTML page.

[0438] Step 10:

[0439] The user reviews the insurance plan presented to them and customizes it as needed, for example, by adding specific riders or adjusting the scope of coverage.

[0440] Step 11:

[0441] The user finally decides on a customized insurance plan that satisfies him and clicks the "Confirm" button.

[0442] Step 12:

[0443] The server receives the finalized insurance plan and stores it in a database, which is stored in an SQL database.

[0444] Step 13:

[0445] The server sends the finalized insurance plan to the insurance company's system using REST API or SOAP protocol.

[0446] Step 14:

[0447] The server notifies the user that the insurance application is complete, either by email or via a web page.

[0448] Example 1

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

[0450] In modern society, it is important to easily provide optimal insurance plans to individual users. However, conventional methods require users to collect and compare large amounts of information, which is time-consuming. Furthermore, insurance plan proposals are not based on the user's specific risk profile, which often results in an inappropriate selection of the optimal plan. In addition, the process for users to confirm their customized insurance plan and apply to an insurance company is complicated and inefficient. Thus, there is a need for a system that can accurately analyze a user's risk profile, propose an appropriate insurance plan, and complete the insurance application quickly and efficiently.

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

[0452] In this invention, the server includes a means for a user to input risk profile information, a means for the server to receive the risk profile information and store it in a database, and a means for the server to transmit the risk profile information to the AI ​​generator. This makes it possible to efficiently collect the user's risk profile information and have the AI ​​generator analyze it. Furthermore, the AI ​​generator can provide an optimal insurance plan as a result of its analysis, allowing the user to quickly apply for a customized plan with an insurance company.

[0453] A "User" is any person or entity that provides risk profile information to the system for the purpose of receiving insurance plan offers.

[0454] The "server" is a computer system that receives risk profile information provided by users, stores it in a database, and transmits the information to the generation AI and processes the results.

[0455] "Risk profile information" refers to information necessary for selecting an insurance plan, such as a user's age, occupation, health condition, and hobbies.

[0456] "Database" means a system for organizing and storing user risk profile information and insurance plan information.

[0457] "Generative AI" is a program that uses machine learning and natural language processing technology to analyze a user's risk profile information and select the most appropriate insurance plan based on the results.

[0458] An "insurance plan" is a form of insurance contract that includes specific coverage and terms offered to a user.

[0459] "Customization" refers to a user adding riders or adjusting the scope of coverage to a proposed insurance plan.

[0460] An "interactive form" is a portion of a web page that contains dynamically operable input fields to facilitate user input of risk profile information.

[0461] An "insurance company" is a company that actually writes insurance contracts based on the insurance plans offered.

[0462] "Notification" is a message to inform the user of the completion of the insurance application or other important information.

[0463] The present invention is a system for analyzing a user's risk profile information and proposing an optimal insurance plan. This system is realized by operating multiple hardware and software components in cooperation with each other. Specific embodiments for implementing the present invention are described below.

[0464] First, a user accesses the system using a device (PC, smartphone, tablet, etc.). The device used here requires a common web browser (Google Chrome, Mozilla Firefox, Apple Safari, etc.) and a network connection. When the user enters the system's URL and accesses it, a login screen appears and the user enters their authentication information to log in to the system.

[0465] After a successful login, the server presents the user with a form to enter their risk profile information. The form is written in HTML, CSS, and JavaScript and includes input fields for age, occupation, health status, hobbies, etc.

[0466] When a user enters their risk profile information and clicks the submit button, the form data is converted to JSON format by JavaScript and sent to the server via HTTPS. For example, a 30-year-old single man enters the following information: age: 30, occupation: IT engineer, health status: good, and hobby: outdoor activities.

[0467] The server receives the risk profile information sent by the user and stores it in a database (e.g., MySQL or PostgreSQL), where it also performs data validation and validation checks.

[0468] The server then sends the stored risk profile information to the Generation AI, which uses an advanced AI model such as GPT-4. The data is in JSON format and passed to the Generation AI via a RESTful API.

[0469] The Generator AI uses natural language processing (NLP) techniques and machine learning algorithms (for example, using the PyTorch or TensorFlow frameworks) to analyze the received risk profile information. As a result of this analysis, the Generator AI selects the optimal insurance plan from 10 candidates. This candidate plan is then sent back to the server in JSON format.

[0470] The server receives the insurance plan returned by the generation AI and displays it in HTML format to the user, who can then review the proposed insurance plan through a web browser, add specific riders, or adjust the coverage.

[0471] Furthermore, when the user customizes and confirms the insurance plan, the customization information is sent again to the server in JSON format. After the server receives the confirmed insurance plan, it stores it in the database. The final insurance plan information is sent from the server to the insurance company's system. Security protocols (e.g., OAuth) are also applied during the transmission via the insurance company's API.

[0472] Finally, the server notifies the user that the insurance application has been completed. The notification can be sent via email or a web page. Email notifications are sent using the SMTP protocol, and web notifications are sent via JavaScript.

[0473] An example of a prompt sentence is input to the generative AI model in text format, such as, "A 30-year-old single male, an engineer at an IT company, in good health, and whose hobby is outdoor activities. Please suggest the best insurance plan for this user." Based on this prompt, the generative AI selects an insurance plan that matches the user's risk profile.

[0474] As described above, the server, user, and generation AI work together to create a system that efficiently proposes the optimal insurance plan to the user and speeds up the application process.

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

[0476] Step 1: The user accesses the system using a terminal

[0477] Specific operation: A user opens a web browser on a device such as a PC, smartphone, or tablet, and enters the system's URL to access it. At this time, the user enters authentication information (user name and password) on the login screen to log in to the system.

[0478] Input: System URL, user authentication information (username, password)

[0479] Output: The user is successfully logged in and the system home page is displayed.

[0480] Step 2: The server displays the input form

[0481] What it does: After a user successfully logs in, the server displays an HTML form for the user to enter their risk profile information. The form includes input fields for age, occupation, health status, hobbies, etc.

[0482] Input: User login success information

[0483] Output: An HTML form for entering risk profile information is displayed in the user's browser.

[0484] Step 3: User enters and submits risk profile information

[0485] Specific operation: The user enters the required risk profile information into the displayed form. When the user has completed the input, they click the "Submit" button. Upon clicking, JavaScript converts the form data into JSON format and sends it to the server via the HTTPS protocol.

[0486] Input: User's risk profile information (age, occupation, health status, hobbies, etc.)

[0487] Output: Risk profile information is sent to the server in JSON format.

[0488] Step 4: The server receives the information and stores it in a database

[0489] Specific operation: The server receives the JSON data sent by the user. After receiving it, the server checks the validity of the data, performs any necessary validation, and then saves it in a database (MySQL or PostgreSQL) using SQL commands.

[0490] Input: Risk profile information in JSON format

[0491] Output: Risk profile information stored in a database

[0492] Step 5: The server sends the information to the generated AI

[0493] Specific operation: The server sends the saved risk profile information to the generation AI. This is done via a RESTful API, and the data is again in JSON format. A request is made to the API endpoint.

[0494] Input: Risk profile information stored in the database

[0495] Output: Risk profile information in JSON format is sent to the generation AI

[0496] Step 6: Generative AI analyzes the information and selects an insurance plan

[0497] How it works: The Generator AI performs an analysis based on the received risk profile information. This analysis uses NLP techniques and machine learning algorithms (e.g., PyTorch and TensorFlow frameworks). Based on the analysis, the Generator AI selects the most suitable insurance plan from 10 candidates based on the user's risk profile.

[0498] Input: Risk profile information in JSON format

[0499] Output: Insurance plan data in JSON format (10 options)

[0500] Step 7: The generative AI sends the results back to the server

[0501] Specific operation: The insurance plan selected by the generation AI is returned to the server in JSON format. The return is also done using a RESTful API.

[0502] Input: Insurance plan data in JSON format (10 options)

[0503] Output: Insurance plan data in JSON format is sent to the server

[0504] Step 8: Server displays insurance plan to user

[0505] Specific operation: The server receives the insurance plans returned by the generation AI and displays them to the user in HTML format. The user's device browser displays a list of selected insurance plans.

[0506] Input: Insurance plan data in JSON format (10 options)

[0507] Output: A list of insurance plans in HTML format, displayed in the user's browser.

[0508] Step 9: User reviews and customizes plan

[0509] How it works: The user reviews the insurance plans displayed, selects a specific plan, adds riders, or adjusts coverage. These customization operations are also performed using JavaScript, and the selection information is again converted to JSON format and sent to the server.

[0510] Input: User customization operations (adding special clauses, adjusting coverage, etc.)

[0511] Output: Customized insurance plan information is sent to the server in JSON format.

[0512] Step 10: The server receives and stores the final plan

[0513] Specific operation: The server receives the customized insurance plan information and saves it back to the database. The save operation is also performed using SQL statements. Data integrity checks are performed to ensure accurate data is saved.

[0514] Input: Customized insurance plan information in JSON format

[0515] Output: Customized insurance plan information stored in a database

[0516] Step 11: Server sends information to insurance company

[0517] What happens: The server sends the final insurance plan information to the insurance company's system, again via an API and applying security protocols (e.g., OAuth) as needed.

[0518] Input: Final insurance plan information stored in the database

[0519] Output: Insurance plan information sent to the insurance company's system

[0520] Step 12: The server notifies the user

[0521] Specific operation: The server notifies the user that the insurance application has been completed. This notification can be sent via email or a web page. Emails are sent using the SMTP protocol, and web notifications are sent via JavaScript.

[0522] Input: Final insurance plan information submitted

[0523] Output: Notification of insurance application completion sent to the user

[0524] As mentioned above, we have explained in detail how specific inputs and outputs, as well as data processing and calculations are performed at each step. This will enable the realization of a system that efficiently analyzes a user's risk profile information and proposes the most suitable insurance plan.

[0525] (Application example 1)

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

[0527] Current security plan offerings face the challenge of making it difficult to select the optimal plan based on a user's individual risk profile. Furthermore, it is difficult for users to determine which security measures are optimal, which can result in excessive or insufficient measures being selected. This not only reduces the efficiency and effectiveness of security, but also leads to cost waste. This invention aims to solve these challenges by providing a system that automatically selects and proposes the optimal security plan based on the user's risk profile.

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

[0529] In this invention, the server includes a means for a user to input risk profile information, a means for the server to receive the risk profile information and store it in a database, and a means for the server to transmit the risk profile information to a generating artificial intelligence. This provides a system including a means for the generating artificial intelligence to analyze the risk profile information and select an appropriate security plan, a means for the generating artificial intelligence to return the security plan selected by the generating artificial intelligence to the server, a means for the server to present the returned security plan to the user, a means for the user to customize the security plan and finalize the final security plan, a means for the server to receive the finalized security plan and store it in a database, a means for the server to transmit the finalized security plan to a security provider's system, and a means for the server to notify the user that the security plan is complete. This allows users to easily select and customize an appropriate security plan and implement effective security measures.

[0530] "User" means an individual or entity that inputs risk profile information into the system and selects and customizes a security plan.

[0531] "Risk profile information" is data that includes information such as a user's age, occupation, residential area, frequency of internet use, and past intrusion experiences.

[0532] A "server" is a hardware or software system that receives risk profile information from users, stores it in a database, and transmits it to the generation AI.

[0533] "Database" means a data management system for storing risk profile information and established security plans received by the Server.

[0534] "Generative artificial intelligence (generative AI)" refers to artificial intelligence technology that analyzes risk profile information received from users and selects the optimal security plan.

[0535] "Security plan" refers to specific proposals for security measures required by users, including home security systems, cybersecurity measures, and personal information protection.

[0536] "Security provider" means a company or organization that implements and provides the security plan selected and confirmed by the user.

[0537] "Collaboration" refers to the process by which multiple systems or services work together and exchange information.

[0538] "Security Measures" refers to the means used to protect Users' personal information and physical property, and includes technical, organizational, and physical measures.

[0539] A system embodying the present invention is one in which a user inputs risk profile information and an optimal security plan is proposed and customized. Specific embodiments are described below.

[0540] First, a user accesses the system using their own device (e.g., a smartphone). The system displays a form for the user to enter risk profile information. This form includes fields for entering information such as age, occupation, residential area, frequency of internet use, and past breaches. When the user enters this information and clicks the submit button, the information is sent to the server in JSON format.

[0541] Next, the server receives the risk profile information sent by the user and stores it in a database. The database uses a cloud-based data management system such as AWS RDS (MySQL). Once stored, the server sends the risk profile information to a generation AI. The generation AI is implemented in Python and uses machine learning models using scikit-learn and TensorFlow.

[0542] The Generator AI analyzes the received risk profile information and selects an appropriate security plan. This analysis utilizes a machine learning algorithm that generates optimal output based on specific input information. As a result of the analysis, the Generator AI selects the security plan that best suits the user's risk profile from multiple candidates. The selected security plan is then sent back from the Generator AI to the server.

[0543] The server receives the security plan returned by the generation AI and displays it to the user. The user can review the proposed security plan and, if necessary, view detailed information or customize it. For example, they can add specific security measures or adjust the scope of services. Once the user has finalized a security plan that satisfies them, the information is sent back to the server.

[0544] The server receives the confirmed security plan and stores it in its database. It then sends this information to the security provider's system, which completes the security service application. Finally, the server notifies the user that the security plan has been completed. This notification is sent via email or a web page.

[0545] Specific examples

[0546] For example, if a 35-year-old single man uses the system, the following process takes place. First, the user enters information such as age (35), occupation (systems engineer), residential area (Tokyo), frequency of internet use (daily), and no prior hacking experience. The server receives this information and sends it to the generation AI. Based on the user's data, the generation AI presents appropriate plans, such as a home security system, antivirus software, and personal information protection service. The user reviews these plans and adds or adjusts measures that are particularly important to them. The server then sends the confirmed information to the security provider and notifies the user of completion.

[0547] Example prompts for generative AI models

[0548] "Please suggest the best security plan based on the user's risk profile information. Here is the user information:

[0549] Age: 35

[0550] Occupation: Systems Engineer

[0551] Living area: Tokyo

[0552] Internet usage frequency: Daily

[0553] Previous breaches: None

[0554] In this way, the present invention can efficiently analyze a user's risk profile and provide an optimal security plan.

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

[0556] Step 1:

[0557] The user accesses the system using their own terminal. The terminal displays a form for entering risk profile information. The user enters information such as age, occupation, residential area, frequency of internet use, and past breaches, and clicks the submit button.

[0558] Input: Risk profile information entered by the user into a form (age, occupation, region of residence, frequency of internet use, previous breaches).

[0559] Output: Risk profile information sent to the server in JSON format.

[0560] Step 2:

[0561] The server receives the risk profile information sent by the user and stores this information in a database.

[0562] Input: Risk profile information sent from the device.

[0563] Output: Risk profile information stored in a database.

[0564] Step 3:

[0565] The server sends the risk profile information stored in the database to the Generating Artificial Intelligence (Generating AI) using JSON format data.

[0566] Input: Risk profile information stored in the database.

[0567] Output: Risk profile information sent to the generating AI.

[0568] Step 4:

[0569] The Generator AI analyzes the received risk profile information and, specifically, uses natural language processing and machine learning algorithms to select the most appropriate security plan for the user.

[0570] Input: Risk profile information sent by the server.

[0571] Output: A suitable security plan is selected.

[0572] Step 5:

[0573] The generation AI returns the selected security plan to the server.

[0574] Input: An appropriate security plan selected by the generative AI.

[0575] Output: The security plan sent back to the server by the generation AI.

[0576] Step 6:

[0577] The server then presents the received security plan to the user's terminal, where the user can review the plan and customize it as needed.

[0578] Input: The security plan sent back to the server.

[0579] Output: The security plan displayed on the user's device.

[0580] Step 7:

[0581] The user customizes the security plan and finalizes it, which is then sent from the device to the server.

[0582] Input: User customized security plan.

[0583] Output: Finalized security plan.

[0584] Step 8:

[0585] The server receives the finalized security plan and stores it in the database again.

[0586] Input: The final confirmed security plan submitted by the user.

[0587] Output: The final security plan stored in the database.

[0588] Step 9:

[0589] The server sends the finalized security plan to the security provider's system, thereby completing the application for security services.

[0590] Input: The final security plan stored in the database.

[0591] Output: The security plan sent to the security contractor's system.

[0592] Step 10:

[0593] The server will notify the user that the security service subscription has been completed. This notification will be sent via email or a web page.

[0594] Input: Record of completed transmission from server to security company.

[0595] Output: Completion notification sent to the user.

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

[0597] This invention is a system that analyzes a user's risk profile and proposes the optimal insurance plan through a system that combines generative AI and an emotion engine. The specific program processing and flow are explained below.

[0598] First, the user accesses the system using their own terminal. The system homepage is displayed, and the user accesses a form for entering risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies.

[0599] The server then embeds an emotion engine into the input form, and while the user is entering information, the emotion engine collects and analyzes emotion data from the user's facial expressions and tone of voice. The obtained emotion data is then sent to the server along with risk profile information.

[0600] The server receives the risk profile information and emotional data sent by the user and stores it in a database. Once saved, the server sends this information to the generation AI, which then analyzes the received risk profile information and emotional data. This analysis uses natural language processing (NLP) technology and machine learning algorithms. In addition, by taking emotional data into account, it becomes possible to select an insurance plan that reflects the user's emotional state.

[0601] The AI ​​selects an appropriate insurance plan from 10 options based on the risk profile and emotional data. For example, if the user has low risk tolerance, it will prioritize a plan that provides a greater sense of security. The AI ​​then returns the selected insurance plan to the server.

[0602] The server presents the insurance plans received from the generation AI to the user. The user reviews these plans and customizes them as necessary. At this time, the emotion engine can re-analyze the user's reactions and reflect them in the customization suggestions. For example, if the user is unsure about the plan contents, the emotion engine will detect this and display a more detailed explanation.

[0603] Once the user has finalized the customized insurance plan that satisfies them, the finalized information is sent to the server. The server stores the finalized insurance plan in the database again and sends this information to the insurance company's system. Once the insurance application is complete, the server notifies the user of the completion. This can be done by email or on a web page.

[0604] Specific examples

[0605] For example, a 30-year-old single man uses the system and enters his age (30), occupation (IT engineer), health condition (good), and hobby (outdoor activities). The emotion engine detects that the user is feeling a little anxious as he enters the information. Based on this risk profile and emotion data, the generative AI selects an insurance plan that emphasizes greater peace of mind. The plan may include medical insurance and life insurance, and detailed explanations and special terms and conditions are provided to enhance peace of mind. The user customizes these plans and finally confirms them.

[0606] This allows the system of the present invention to comprehensively analyze the user's risk profile and emotional state and effectively propose the most suitable insurance plan.

[0607] The processing flow will be explained below.

[0608] Step 1:

[0609] The user accesses the system using a terminal. The system homepage is displayed, and the user clicks the "Enter Risk Profile Information" button.

[0610] Step 2:

[0611] The server displays a form for entering risk profile information, including fields for age, occupation, health status, hobbies, etc.

[0612] Step 3:

[0613] As users begin to enter their risk profile information, the emotion engine kicks in and begins collecting emotional data from the user's facial expressions and vocal tone, for example, by analyzing the data in real time using the camera and microphone.

[0614] Step 4:

[0615] The user enters all the risk profile information and clicks the "Submit" button. Example: The user enters age "30 years old", occupation "IT engineer", health condition "good", and hobby "outdoor activities".

[0616] Step 5:

[0617] The emotion engine analyzes the user's emotion data and estimates their current emotional state, such as anxiety, relief, or excitement.

[0618] Step 6:

[0619] The server receives the risk profile information submitted through the form and the emotion data obtained from the emotion engine, and stores them in a database. The data is stored in an SQL database.

[0620] Step 7:

[0621] The server sends risk profile information and emotion data to the generation AI via the module, using JSON format data.

[0622] Step 8:

[0623] The generative AI analyzes risk profile information and sentiment data to select an appropriate insurance plan from 10 options. For example, if peace of mind is a priority, medical insurance and life insurance may be included.

[0624] Step 9:

[0625] The generation AI returns the selected insurance plan to the server in JSON format.

[0626] Step 10:

[0627] The server presents the insurance plans received from the generation AI to the user, who can then view the dynamically generated list of insurance plans on an HTML page.

[0628] Step 11:

[0629] The user reviews the insurance plan and customizes it as needed. At this point, the emotion engine is activated again to analyze the user's reactions. For example, if the user is feeling uneasy about a particular plan, it sends that information to the server.

[0630] Step 12:

[0631] The server provides the user with additional information or other suggestions based on the analysis results of the emotion engine, thereby increasing the user's sense of security.

[0632] Step 13:

[0633] The user finally decides on a customized insurance plan that satisfies him and clicks the "Confirm" button.

[0634] Step 14:

[0635] The server saves the confirmed insurance plan back to the database. The data is saved in an SQL database.

[0636] Step 15:

[0637] The server sends the finalized insurance plan to the insurance company's system using REST API or SOAP protocol.

[0638] Step 16:

[0639] The server notifies the user that the insurance application is complete, either by email or via a web page.

[0640] Example 2

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

[0642] Conventional insurance proposal systems propose insurance plans based solely on the user's risk profile information, making it difficult to propose optimal insurance plans that take the user's emotional state into account. Furthermore, since the proposed plans cannot reflect the user's emotions and reactions at the time of input, user satisfaction may decline. This leaves users feeling anxious and uncertain, making it difficult to select an appropriate insurance plan.

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

[0644] In this invention, the server includes a means for a user to input risk profile information, a means for an emotion engine to collect and analyze emotion data from the user's facial expressions and tone of voice, a means for transmitting the collected emotion data together with the risk profile information to the server, and a means for a generating artificial intelligence to analyze the risk profile information and emotion data and select an appropriate insurance plan. This makes it possible to propose an optimal insurance plan that comprehensively considers the user's risk profile information and emotional state.

[0645] "User" refers to an individual who utilizes the system to input risk profile information and propose and customize insurance plans.

[0646] "Terminal" refers to a device operated by a user to access the system and input information.

[0647] "Server" refers to the system component that receives, stores, and analyzes user input information and connects with the generation AI and database.

[0648] "Risk profile information" refers to personal information that users enter into the system, including information related to risk assessment, such as age, occupation, health status, and hobbies.

[0649] "Emotion Engine" refers to the software component that collects and analyzes emotional data from a user's facial expressions and vocal tone in real time.

[0650] "Emotion data" refers to data that indicates the user's emotional state, obtained by the emotion engine analyzing the user's facial expressions and tone of voice.

[0651] "Generative AI" refers to algorithms and models that analyze risk profile information and emotional data to select appropriate insurance plans.

[0652] "Insurance plan" refers to the composition and features of multiple insurance products selected by the generation AI and presented to the user.

[0653] "Database" refers to data storage for storing risk profile information, sentiment data, confirmed insurance plans, etc.

[0654] "Insurance company system" refers to an external system to which the server sends finalized insurance plans and manages insurance applications.

[0655] "Customization" refers to the act of a user adjusting or modifying the insurance plan presented to them to suit their own needs and circumstances.

[0656] "Confirmation" refers to the act of the user finally selecting a customized insurance plan and sending it to the server.

[0657] "Notification" refers to a communication method used by the server to inform the user of the completion of the insurance application or other important information.

[0658] The present invention analyzes a user's risk profile through a system that combines a generative AI and an emotion engine, and proposes an optimal insurance plan. Specific embodiments are described below.

[0659] First, a user accesses the system using their own device. The system's homepage is displayed, and the user accesses a form for entering risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies. Input is typically done using a keyboard or touchscreen.

[0660] The server then embeds an emotion engine into the input form, and while the user is entering data, it uses a camera and microphone to collect emotion data from the user's facial expressions and tone of voice. The emotion engine analyzes the collected data in real time and determines the user's emotional state. For example, if the user looks anxious, "anxiety" is detected as the emotion data.

[0661] The server receives the risk profile information and emotion data sent by the user and stores them in a database. Once stored, the server sends this information to the generative AI, which then analyzes the risk profile information and emotion data using natural language processing (NLP) techniques and machine learning algorithms. The generative AI model used here is an advanced natural language generation model such as GPT-3.

[0662] Based on the analysis results, the generative AI selects an appropriate insurance plan from 10 candidates. For example, if the user has low risk tolerance and feels anxious, an insurance plan with content that gives them more peace of mind will be selected. The selected insurance plan is then sent back to the server.

[0663] The server presents the insurance plan received from the generation AI to the user. The user reviews the plan and customizes it as needed. During this customization, the emotion engine again analyzes the user's reaction and, for example, if the user feels anxious, presents detailed explanations and additional options.

[0664] Once the user has finalized the customized insurance plan that satisfies them, the information is sent to the server. The server stores the finalized insurance plan in the database again and sends this information to the insurance company's system. Once the insurance application is complete, the server notifies the user of the completion. This can be done by email or on a web page.

[0665] Specific examples

[0666] For example, use the following prompt:

[0667] The user is a single man, aged 30, works as an engineer in an IT company, is in good health, and enjoys outdoor activities. The user is entering his information with some trepidation. Please suggest an insurance plan that emphasizes peace of mind.

[0668] Based on this prompt, the generative AI can comprehensively analyze the user's profile and emotional state to suggest an appropriate insurance plan, which the user can then review and customize before making a final decision.

[0669] As a result, the present invention can propose optimal insurance plans that comprehensively take into account the user's risk profile and emotional state, and that will provide high levels of user satisfaction.

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

[0671] Step 1: User enters risk profile information

[0672] Users access the system using their own terminal and enter their risk profile information. The system homepage is displayed on the terminal, and a form is presented to enter information such as age, occupation, health status, and hobbies. The entered data is sent from the terminal to the server.

[0673] Input: User's risk profile information (age, occupation, health status, hobbies)

[0674] Output: Risk profile information sent to the server

[0675] Step 2: Collecting sentiment data in real time

[0676] The server embeds an emotion engine into the input form, and uses a camera and microphone to collect emotion data from the user's facial expressions and tone of voice as they input information. The emotion engine analyzes this data in real time to determine the user's emotional state.

[0677] Input: User's facial expression data, voice tone data

[0678] Output: Real-time emotion data to the server

[0679] Step 3: Send and store data

[0680] The server receives the risk profile information and emotion data sent by the user, stores this data in the system's database, and simultaneously sends the risk profile information and emotion data to the generation AI.

[0681] Input: Risk profile information, emotion data

[0682] Output: Save to database, send data to generation AI

[0683] Step 4: Data analysis with generative AI

[0684] The generative AI receives risk profile information and emotional data sent from the server and analyzes them using natural language processing (NLP) technology and machine learning algorithms. As a result of the analysis, an insurance plan that reflects the user's risk tendencies and emotional state is selected.

[0685] Input: Risk profile information, emotion data

[0686] Output: Analysis results (insurance plan based on user's risk propensity and emotional state)

[0687] Step 5: Select an insurance plan

[0688] Based on the analysis results, the generative AI selects the optimal insurance plan from 10 candidates. For example, if the user has low risk tolerance and is feeling anxious, the insurance plan with the most reassuring content will be selected.

[0689] Input: Analysis results by generative AI

[0690] Output: Selected insurance plans (10 candidates)

[0691] Step 6: Present to the user and customize

[0692] The server presents the insurance plan received from the generation AI to the user. The user reviews the presented plan and customizes it as necessary. At this time, the emotion engine again analyzes the user's reaction and, for example, if the user feels uneasy, presents detailed explanations and additional options.

[0693] Input: Selected insurance plan, user response data

[0694] Output: Customized insurance plan, additional instructions and options

[0695] Step 7: Finalize and notify

[0696] Once the user is satisfied with the customized insurance plan and finalizes it, the information is sent to the server. The server saves the finalized insurance plan in the database and sends it to the insurance company's system. Once the insurance application is complete, the server notifies the user.

[0697] Enter: Customized Insurance Plan

[0698] Output: Save to database, send to insurance company's system, notify user of completion

[0699] (Application example 2)

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

[0701] Conventional systems cannot consider the user's emotional state or real-time emotional data when analyzing the user's risk profile and proposing an appropriate plan, and as a result, the plan provided often does not adapt to the user's actual needs or emotional state. To solve this problem, a system that utilizes the user's real-time emotional data to provide a more personalized plan is needed.

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

[0703] In this invention, the server includes: means for a user to input risk profile information; means for the server to receive the risk profile information and store it in a database; means for the server to collect and receive emotion data in addition to the risk profile information; means including an emotion engine that analyzes sensor data from the smart device to generate emotion data; means for the server to transmit the risk profile information and emotion data to a generating artificial intelligence; means for the generating artificial intelligence to analyze the risk profile information and emotion data and select an appropriate plan; means for the generating artificial intelligence to return the selected plan to the server; means for the server to present the returned plan to the user; means for the user to customize the plan and finalize the final plan; means for the server to receive the finalized plan and store it in a database; means for the server to transmit the finalized plan to a related system; and means for the server to notify the user that the application has been completed. This makes it possible to provide a personalized plan that is adapted to the user's actual needs and emotional state by utilizing the user's emotion data.

[0704] "Risk profile information" is information that indicates the risk characteristics of a user, such as the user's age, occupation, health condition, and hobbies.

[0705] "Emotion data" is data that indicates the user's emotional state, generated from the user's facial expression, tone of voice, etc.

[0706] The "emotion engine" is a system that analyzes sensor data from smart devices to generate user emotion data.

[0707] "Generative AI" or "generative artificial intelligence" is artificial intelligence that analyzes a user's risk profile information and emotional data and selects an appropriate plan.

[0708] A "smart device" is an electronic device equipped with a camera and microphone that is used to capture emotional data.

[0709] The "database" is a storage device for storing information such as risk profile information, emotion data, and confirmed plans received by the server.

[0710] A "server" is a computer system responsible for processing information received from users, storing it in a database, and transmitting the information to related systems.

[0711] A "plan" is an appropriate insurance or spending plan selected based on the user's risk profile information and sentiment data.

[0712] "Relevant system" means the insurance company's system that receives the finalized plan or any other appropriate system.

[0713] The present invention is a system that analyzes a user's risk profile information and emotion data and proposes an appropriate plan. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS The following describes in detail specific embodiments of the present invention.

[0714] Initial Setup

[0715] A user installs the application on their smartphone and enters basic information (age, occupation, income, hobbies, etc.) when they first launch the application. This initial setting information becomes the data necessary for the user's risk profile.

[0716] Collecting Emotional Data

[0717] The smartphone's camera and microphone are used to collect facial expressions and vocal tones while the user is entering information. This emotional data is analyzed by the emotion engine and converted into a numerical emotion score.

[0718] Data transmission and analysis

[0719] The server stores the risk profile information and emotion data received from the user in a database, and simultaneously transmits this data to the generation AI.

[0720] The Generative AI analyzes the received risk profile information and emotion data to select the optimal plan, using natural language processing (NLP) technology and machine learning algorithms.

[0721] Plan proposal and customization

[0722] The artificial intelligence generator sends the selected plan back to the server, which then displays it on the user's smartphone, where the user can confirm the details.

[0723] Users can customize the proposed plan, and the emotion engine will again analyze the user's reactions and adjust the plan accordingly.

[0724] For example, if a user is unsure about a suggestion, a detailed explanation is automatically added.

[0725] Confirmation and Notification

[0726] When the user finally decides on a customized plan to his satisfaction, the server stores the decision information in a database and transmits it to the related systems.

[0727] The server will notify the user of the completion of the application via email or the app's notification function.

[0728] Specific use cases

[0729] For example, if a 30-year-old single man uses this system, he will enter his age as "30," his occupation as "IT company engineer," and his income as "5 million yen," and will supplement it with information about his hobby as "outdoor activities." The emotion engine will also detect that the user is feeling a little uneasy when entering the information. Based on this risk profile and emotion data, the generation AI will select a plan that places more emphasis on peace of mind. The plan may include health insurance, life insurance, and special provisions for outdoor activities. In this case, the generation AI will use the following prompt:

[0730] Age: 30, Income: 5 million yen, Emotional score: 0.8, Please suggest an appropriate spending plan.

[0731] Hardware and software used

[0732] Smart devices: Emotional data is collected using the smartphone's camera and microphone.

[0733] Emotion Engine: Uses Keras to perform facial recognition and speech analysis to generate emotion scores.

[0734] Generative AI: Run a GPT-2 model using Hugging Face's Transformers library to analyze risk profile information and emotion data.

[0735] Servers and databases: Serve as the infrastructure for storing and analyzing user and confirmation information.

[0736] In this way, by utilizing the user's emotional data, the present invention can provide a personalized plan that is adapted to the user's actual needs and emotional state.

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

[0738] Step 1:

[0739] The user installs and launches the smartphone app. When the app is launched for the first time, it prompts the user to enter basic information (age, occupation, income, hobbies, etc.). This allows risk profile information to be collected. The entered data is sent to the server and stored in a database.

[0740] Input: Basic information such as age, occupation, income, hobbies, etc.

[0741] Output: Risk profile information stored on the server

[0742] Step 2:

[0743] While the user is entering information, the device's camera and microphone are activated to collect emotion data, such as facial expressions and tone of voice. The emotion engine analyzes this data and generates a numerical emotion score.

[0744] Input: facial expression data, voice tone data

[0745] Output: Numerical sentiment score

[0746] Step 3:

[0747] The server stores the risk profile information and emotion score in a database and sends it to the AI ​​for analysis, which then generates a prompt as data necessary for analysis.

[0748] Input: Risk profile information, sentiment score

[0749] Output: Prompt and data sent to the generation AI

[0750] Step 4:

[0751] The generation AI performs data analysis based on the received risk profile information and emotion scores. The analysis uses natural language processing technology and machine learning algorithms to select the plan that best suits the user's needs. The generation AI then returns the selection results to the server.

[0752] Input: prompt statement, risk profile information, sentiment score

[0753] Output: The optimal plan sent back to the server

[0754] Step 5:

[0755] The server displays the plan returned by the generation AI on the user's smartphone. The user can review the plan and customize it as needed. During the customization process, the emotion engine analyzes the user's reactions and adjusts the plan accordingly.

[0756] Input: Plan selected by the generation AI, user's reaction (facial expression, voice)

[0757] Output: A plan customized by the user

[0758] Step 6:

[0759] Once the user has finalized the customized plan to their satisfaction, the information is sent to the server, which stores the finalized information in a database and sends it to the relevant systems.

[0760] Input: Customized Plan

[0761] Output: Finalized plan stored in database, plan sent to relevant systems

[0762] Step 7:

[0763] The server notifies the user of the completion of the application via email or the app's notification function.

[0764] Input: Confirmed plan information

[0765] Output: Completion notification sent to the user

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

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

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

[0769] [Third embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

[0782] The present invention is a system that analyzes a user's risk profile and proposes an appropriate insurance plan. This system is realized by the mutual cooperation of three parties: a server, a terminal, and a user. The specific program processing and its flow are explained below.

[0783] First, the user accesses the system using their own terminal. The system displays a form for the user to enter risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies. Once the user enters this information and clicks the submit button, the information is sent to the server.

[0784] Next, the server receives the risk profile information sent by the user and stores it in a database. Once stored, the server sends the risk profile information to the AI ​​generator. This transmission uses a data format such as JSON.

[0785] The Generative AI (Generative Artificial Intelligence) analyzes the received risk profile information. This analysis uses natural language processing and machine learning algorithms. As a result of the analysis, the Generative AI selects the insurance plan that best suits the user's risk profile from 10 candidates. The selected insurance plan is then sent back from the Generative AI to the server.

[0786] The server receives the insurance plan returned by the generation AI and displays it to the user. The user can review the proposed insurance plan and, if necessary, view detailed information or customize it. For example, they can add specific riders or adjust the scope of coverage. Once the user has finally decided on an insurance plan that satisfies them, the information is sent to the server.

[0787] The server receives the confirmed insurance plan and stores it in the database. Then it sends this information to the insurance company's system, which completes the insurance application. Finally, the server notifies the user that the insurance application has been completed. This can be done by email or on a web page.

[0788] Specific examples

[0789] For example, if a 30-year-old single man uses the system, the following process takes place. First, the user enters information such as age "30," occupation "IT company engineer," health condition "good," and hobby "outdoor activities." The server receives this information and sends it to the generation AI. Since the user likes outdoor activities, the generation AI considers the applicability of accident insurance and travel insurance and presents an appropriate plan. The user reviews these plans and customizes them, focusing particularly on medical insurance. The server then sends the application information to the insurance company and notifies the user of completion.

[0790] In this way, the system of the present invention can efficiently analyze a user's risk profile and provide an optimal insurance plan.

[0791] The processing flow will be explained below.

[0792] Step 1:

[0793] A user accesses the system using a web browser or application by entering the system's URL and clicking the access button.

[0794] Step 2:

[0795] The server is then contacted and displays a form for filling out a risk profile, which includes fields for entering information such as age, occupation, health status, and hobbies.

[0796] Step 3:

[0797] The user enters risk profile information and clicks the "Submit" button. For example, the user enters information such as age "30 years old," occupation "IT engineer," health condition "good," and hobby "outdoor activities."

[0798] Step 4:

[0799] The server receives the data submitted through the form and stores it in a database, which is stored in an SQL database.

[0800] Step 5:

[0801] The server sends the stored risk profile information to the generation AI using JSON format data.

[0802] Step 6:

[0803] The generative AI analyzes the received risk profile information using natural language processing (NLP) techniques and machine learning models.

[0804] Step 7:

[0805] Based on the risk profile information, the generative AI selects the most suitable insurance plan from 10 candidate plans using an algorithm.

[0806] Step 8:

[0807] The generation AI returns the selected insurance plan to the server in JSON format.

[0808] Step 9:

[0809] The server presents the insurance plans received from the generation AI to the user, who is then shown a dynamically generated list of insurance plans on an HTML page.

[0810] Step 10:

[0811] The user reviews the insurance plan presented to them and customizes it as needed, for example, by adding specific riders or adjusting the scope of coverage.

[0812] Step 11:

[0813] The user finally decides on a customized insurance plan that satisfies him and clicks the "Confirm" button.

[0814] Step 12:

[0815] The server receives the finalized insurance plan and stores it in a database, which is stored in an SQL database.

[0816] Step 13:

[0817] The server sends the finalized insurance plan to the insurance company's system using REST API or SOAP protocol.

[0818] Step 14:

[0819] The server notifies the user that the insurance application is complete, either by email or via a web page.

[0820] Example 1

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

[0822] In modern society, it is important to easily provide optimal insurance plans to individual users. However, conventional methods require users to collect and compare large amounts of information, which is time-consuming. Furthermore, insurance plan proposals are not based on the user's specific risk profile, which often results in an inappropriate selection of the optimal plan. In addition, the process for users to confirm their customized insurance plan and apply to an insurance company is complicated and inefficient. Thus, there is a need for a system that can accurately analyze a user's risk profile, propose an appropriate insurance plan, and complete the insurance application quickly and efficiently.

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

[0824] In this invention, the server includes a means for a user to input risk profile information, a means for the server to receive the risk profile information and store it in a database, and a means for the server to transmit the risk profile information to the AI ​​generator. This makes it possible to efficiently collect the user's risk profile information and have the AI ​​generator analyze it. Furthermore, the AI ​​generator can provide an optimal insurance plan as a result of its analysis, allowing the user to quickly apply for a customized plan with an insurance company.

[0825] A "User" is any person or entity that provides risk profile information to the system for the purpose of receiving insurance plan offers.

[0826] The "server" is a computer system that receives risk profile information provided by users, stores it in a database, and transmits the information to the generation AI and processes the results.

[0827] "Risk profile information" refers to information necessary for selecting an insurance plan, such as a user's age, occupation, health condition, and hobbies.

[0828] "Database" means a system for organizing and storing user risk profile information and insurance plan information.

[0829] "Generative AI" is a program that uses machine learning and natural language processing technology to analyze a user's risk profile information and select the most appropriate insurance plan based on the results.

[0830] An "insurance plan" is a form of insurance contract that includes specific coverage and terms offered to a user.

[0831] "Customization" refers to a user adding riders or adjusting the scope of coverage to a proposed insurance plan.

[0832] An "interactive form" is a portion of a web page that contains dynamically operable input fields to facilitate user input of risk profile information.

[0833] An "insurance company" is a company that actually writes insurance contracts based on the insurance plans offered.

[0834] "Notification" is a message to inform the user of the completion of the insurance application or other important information.

[0835] The present invention is a system for analyzing a user's risk profile information and proposing an optimal insurance plan. This system is realized by operating multiple hardware and software components in cooperation with each other. Specific embodiments for implementing the present invention are described below.

[0836] First, a user accesses the system using a device (PC, smartphone, tablet, etc.). The device used here requires a common web browser (Google Chrome, Mozilla Firefox, Apple Safari, etc.) and a network connection. When the user enters the system's URL and accesses it, a login screen appears and the user enters their authentication information to log in to the system.

[0837] After a successful login, the server presents the user with a form to enter their risk profile information. The form is written in HTML, CSS, and JavaScript and includes input fields for age, occupation, health status, hobbies, etc.

[0838] When a user enters their risk profile information and clicks the submit button, the form data is converted to JSON format by JavaScript and sent to the server via HTTPS. For example, a 30-year-old single man enters the following information: age: 30, occupation: IT engineer, health status: good, and hobby: outdoor activities.

[0839] The server receives the risk profile information sent by the user and stores it in a database (e.g., MySQL or PostgreSQL), where it also performs data validation and validation checks.

[0840] The server then sends the stored risk profile information to the Generation AI, which uses an advanced AI model such as GPT-4. The data is in JSON format and passed to the Generation AI via a RESTful API.

[0841] The Generator AI uses natural language processing (NLP) techniques and machine learning algorithms (for example, using the PyTorch or TensorFlow frameworks) to analyze the received risk profile information. As a result of this analysis, the Generator AI selects the optimal insurance plan from 10 candidates. This candidate plan is then sent back to the server in JSON format.

[0842] The server receives the insurance plan returned by the generation AI and displays it in HTML format to the user, who can then review the proposed insurance plan through a web browser, add specific riders, or adjust the coverage.

[0843] Furthermore, when the user customizes and confirms the insurance plan, the customization information is sent again to the server in JSON format. After the server receives the confirmed insurance plan, it stores it in the database. The final insurance plan information is sent from the server to the insurance company's system. Security protocols (e.g., OAuth) are also applied during the transmission via the insurance company's API.

[0844] Finally, the server notifies the user that the insurance application has been completed. The notification can be sent via email or a web page. Email notifications are sent using the SMTP protocol, and web notifications are sent via JavaScript.

[0845] An example of a prompt sentence is input to the generative AI model in text format, such as, "A 30-year-old single male, an engineer at an IT company, in good health, and whose hobby is outdoor activities. Please suggest the best insurance plan for this user." Based on this prompt, the generative AI selects an insurance plan that matches the user's risk profile.

[0846] As described above, the server, user, and generation AI work together to create a system that efficiently proposes the optimal insurance plan to the user and speeds up the application process.

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

[0848] Step 1: The user accesses the system using a terminal

[0849] Specific operation: A user opens a web browser on a device such as a PC, smartphone, or tablet, and enters the system's URL to access it. At this time, the user enters authentication information (user name and password) on the login screen to log in to the system.

[0850] Input: System URL, user authentication information (username, password)

[0851] Output: The user is successfully logged in and the system home page is displayed.

[0852] Step 2: The server displays the input form

[0853] What it does: After a user successfully logs in, the server displays an HTML form for the user to enter their risk profile information. The form includes input fields for age, occupation, health status, hobbies, etc.

[0854] Input: User login success information

[0855] Output: An HTML form for entering risk profile information is displayed in the user's browser.

[0856] Step 3: User enters and submits risk profile information

[0857] Specific operation: The user enters the required risk profile information into the displayed form. When the user has completed the input, they click the "Submit" button. Upon clicking, JavaScript converts the form data into JSON format and sends it to the server via the HTTPS protocol.

[0858] Input: User's risk profile information (age, occupation, health status, hobbies, etc.)

[0859] Output: Risk profile information is sent to the server in JSON format.

[0860] Step 4: The server receives the information and stores it in a database

[0861] Specific operation: The server receives the JSON data sent by the user. After receiving it, the server checks the validity of the data, performs any necessary validation, and then saves it in a database (MySQL or PostgreSQL) using SQL commands.

[0862] Input: Risk profile information in JSON format

[0863] Output: Risk profile information stored in a database

[0864] Step 5: The server sends the information to the generated AI

[0865] Specific operation: The server sends the saved risk profile information to the generation AI. This is done via a RESTful API, and the data is again in JSON format. A request is made to the API endpoint.

[0866] Input: Risk profile information stored in the database

[0867] Output: Risk profile information in JSON format is sent to the generation AI

[0868] Step 6: Generative AI analyzes the information and selects an insurance plan

[0869] How it works: The Generator AI performs an analysis based on the received risk profile information. This analysis uses NLP techniques and machine learning algorithms (e.g., PyTorch and TensorFlow frameworks). Based on the analysis, the Generator AI selects the most suitable insurance plan from 10 candidates based on the user's risk profile.

[0870] Input: Risk profile information in JSON format

[0871] Output: Insurance plan data in JSON format (10 options)

[0872] Step 7: The generative AI sends the results back to the server

[0873] Specific operation: The insurance plan selected by the generation AI is returned to the server in JSON format. The return is also done using a RESTful API.

[0874] Input: Insurance plan data in JSON format (10 options)

[0875] Output: Insurance plan data in JSON format is sent to the server

[0876] Step 8: Server displays insurance plan to user

[0877] Specific operation: The server receives the insurance plans returned by the generation AI and displays them to the user in HTML format. The user's device browser displays a list of selected insurance plans.

[0878] Input: Insurance plan data in JSON format (10 options)

[0879] Output: A list of insurance plans in HTML format, displayed in the user's browser.

[0880] Step 9: User reviews and customizes plan

[0881] How it works: The user reviews the insurance plans displayed, selects a specific plan, adds riders, or adjusts coverage. These customization operations are also performed using JavaScript, and the selection information is again converted to JSON format and sent to the server.

[0882] Input: User customization operations (adding special clauses, adjusting coverage, etc.)

[0883] Output: Customized insurance plan information is sent to the server in JSON format.

[0884] Step 10: The server receives and stores the final plan

[0885] Specific operation: The server receives the customized insurance plan information and saves it back to the database. The save operation is also performed using SQL statements. Data integrity checks are performed to ensure accurate data is saved.

[0886] Input: Customized insurance plan information in JSON format

[0887] Output: Customized insurance plan information stored in a database

[0888] Step 11: Server sends information to insurance company

[0889] What happens: The server sends the final insurance plan information to the insurance company's system, again via an API and applying security protocols (e.g., OAuth) as needed.

[0890] Input: Final insurance plan information stored in the database

[0891] Output: Insurance plan information sent to the insurance company's system

[0892] Step 12: The server notifies the user

[0893] Specific operation: The server notifies the user that the insurance application has been completed. This notification can be sent via email or a web page. Emails are sent using the SMTP protocol, and web notifications are sent via JavaScript.

[0894] Input: Final insurance plan information submitted

[0895] Output: Notification of insurance application completion sent to the user

[0896] As mentioned above, we have explained in detail how specific inputs and outputs, as well as data processing and calculations are performed at each step. This will enable the realization of a system that efficiently analyzes a user's risk profile information and proposes the most suitable insurance plan.

[0897] (Application example 1)

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

[0899] Current security plan offerings face the challenge of making it difficult to select the optimal plan based on a user's individual risk profile. Furthermore, it is difficult for users to determine which security measures are optimal, which can result in excessive or insufficient measures being selected. This not only reduces the efficiency and effectiveness of security, but also leads to cost waste. This invention aims to solve these challenges by providing a system that automatically selects and proposes the optimal security plan based on the user's risk profile.

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

[0901] In this invention, the server includes a means for a user to input risk profile information, a means for the server to receive the risk profile information and store it in a database, and a means for the server to transmit the risk profile information to a generating artificial intelligence. This provides a system including a means for the generating artificial intelligence to analyze the risk profile information and select an appropriate security plan, a means for the generating artificial intelligence to return the security plan selected by the generating artificial intelligence to the server, a means for the server to present the returned security plan to the user, a means for the user to customize the security plan and finalize the final security plan, a means for the server to receive the finalized security plan and store it in a database, a means for the server to transmit the finalized security plan to a security provider's system, and a means for the server to notify the user that the security plan is complete. This allows users to easily select and customize an appropriate security plan and implement effective security measures.

[0902] "User" means an individual or entity that inputs risk profile information into the system and selects and customizes a security plan.

[0903] "Risk profile information" is data that includes information such as a user's age, occupation, residential area, frequency of internet use, and past intrusion experiences.

[0904] A "server" is a hardware or software system that receives risk profile information from users, stores it in a database, and transmits it to the generation AI.

[0905] "Database" means a data management system for storing risk profile information and established security plans received by the Server.

[0906] "Generative artificial intelligence (generative AI)" refers to artificial intelligence technology that analyzes risk profile information received from users and selects the optimal security plan.

[0907] "Security plan" refers to specific proposals for security measures required by users, including home security systems, cybersecurity measures, and personal information protection.

[0908] "Security provider" means a company or organization that implements and provides the security plan selected and confirmed by the user.

[0909] "Collaboration" refers to the process by which multiple systems or services work together and exchange information.

[0910] "Security Measures" refers to the means used to protect Users' personal information and physical property, and includes technical, organizational, and physical measures.

[0911] A system embodying the present invention is one in which a user inputs risk profile information and an optimal security plan is proposed and customized. Specific embodiments are described below.

[0912] First, a user accesses the system using their own device (e.g., a smartphone). The system displays a form for the user to enter risk profile information. This form includes fields for entering information such as age, occupation, residential area, frequency of internet use, and past breaches. When the user enters this information and clicks the submit button, the information is sent to the server in JSON format.

[0913] Next, the server receives the risk profile information sent by the user and stores it in a database. The database uses a cloud-based data management system such as AWS RDS (MySQL). Once stored, the server sends the risk profile information to a generation AI. The generation AI is implemented in Python and uses machine learning models using scikit-learn and TensorFlow.

[0914] The Generator AI analyzes the received risk profile information and selects an appropriate security plan. This analysis utilizes a machine learning algorithm that generates optimal output based on specific input information. As a result of the analysis, the Generator AI selects the security plan that best suits the user's risk profile from multiple candidates. The selected security plan is then sent back from the Generator AI to the server.

[0915] The server receives the security plan returned by the generation AI and displays it to the user. The user can review the proposed security plan and, if necessary, view detailed information or customize it. For example, they can add specific security measures or adjust the scope of services. Once the user has finalized a security plan that satisfies them, the information is sent back to the server.

[0916] The server receives the confirmed security plan and stores it in its database. It then sends this information to the security provider's system, which completes the security service application. Finally, the server notifies the user that the security plan has been completed. This notification is sent via email or a web page.

[0917] Specific examples

[0918] For example, if a 35-year-old single man uses the system, the following process takes place. First, the user enters information such as age (35), occupation (systems engineer), residential area (Tokyo), frequency of internet use (daily), and no prior hacking experience. The server receives this information and sends it to the generation AI. Based on the user's data, the generation AI presents appropriate plans, such as a home security system, antivirus software, and personal information protection service. The user reviews these plans and adds or adjusts measures that are particularly important to them. The server then sends the confirmed information to the security provider and notifies the user of completion.

[0919] Example prompts for generative AI models

[0920] "Please suggest the best security plan based on the user's risk profile information. Here is the user information:

[0921] Age: 35

[0922] Occupation: Systems Engineer

[0923] Living area: Tokyo

[0924] Internet usage frequency: Daily

[0925] Previous breaches: None

[0926] In this way, the present invention can efficiently analyze a user's risk profile and provide an optimal security plan.

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

[0928] Step 1:

[0929] The user accesses the system using their own terminal. The terminal displays a form for entering risk profile information. The user enters information such as age, occupation, residential area, frequency of internet use, and past breaches, and clicks the submit button.

[0930] Input: Risk profile information entered by the user into a form (age, occupation, region of residence, frequency of internet use, previous breaches).

[0931] Output: Risk profile information sent to the server in JSON format.

[0932] Step 2:

[0933] The server receives the risk profile information sent by the user and stores this information in a database.

[0934] Input: Risk profile information sent from the device.

[0935] Output: Risk profile information stored in a database.

[0936] Step 3:

[0937] The server sends the risk profile information stored in the database to the Generating Artificial Intelligence (Generating AI) using JSON format data.

[0938] Input: Risk profile information stored in the database.

[0939] Output: Risk profile information sent to the generating AI.

[0940] Step 4:

[0941] The Generator AI analyzes the received risk profile information and, specifically, uses natural language processing and machine learning algorithms to select the most appropriate security plan for the user.

[0942] Input: Risk profile information sent by the server.

[0943] Output: A suitable security plan is selected.

[0944] Step 5:

[0945] The generation AI returns the selected security plan to the server.

[0946] Input: An appropriate security plan selected by the generative AI.

[0947] Output: The security plan sent back to the server by the generation AI.

[0948] Step 6:

[0949] The server then presents the received security plan to the user's terminal, where the user can review the plan and customize it as needed.

[0950] Input: The security plan sent back to the server.

[0951] Output: The security plan displayed on the user's device.

[0952] Step 7:

[0953] The user customizes the security plan and finalizes it, which is then sent from the device to the server.

[0954] Input: User customized security plan.

[0955] Output: Finalized security plan.

[0956] Step 8:

[0957] The server receives the finalized security plan and stores it in the database again.

[0958] Input: The final confirmed security plan submitted by the user.

[0959] Output: The final security plan stored in the database.

[0960] Step 9:

[0961] The server sends the finalized security plan to the security provider's system, thereby completing the application for security services.

[0962] Input: The final security plan stored in the database.

[0963] Output: The security plan sent to the security contractor's system.

[0964] Step 10:

[0965] The server will notify the user that the security service subscription has been completed. This notification will be sent via email or a web page.

[0966] Input: Record of completed transmission from server to security company.

[0967] Output: Completion notification sent to the user.

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

[0969] This invention is a system that analyzes a user's risk profile and proposes the optimal insurance plan through a system that combines generative AI and an emotion engine. The specific program processing and flow are explained below.

[0970] First, the user accesses the system using their own terminal. The system homepage is displayed, and the user accesses a form for entering risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies.

[0971] The server then embeds an emotion engine into the input form, and while the user is entering information, the emotion engine collects and analyzes emotion data from the user's facial expressions and tone of voice. The obtained emotion data is then sent to the server along with risk profile information.

[0972] The server receives the risk profile information and emotional data sent by the user and stores it in a database. Once saved, the server sends this information to the generation AI, which then analyzes the received risk profile information and emotional data. This analysis uses natural language processing (NLP) technology and machine learning algorithms. In addition, by taking emotional data into account, it becomes possible to select an insurance plan that reflects the user's emotional state.

[0973] The AI ​​selects an appropriate insurance plan from 10 options based on the risk profile and emotional data. For example, if the user has low risk tolerance, it will prioritize a plan that provides a greater sense of security. The AI ​​then returns the selected insurance plan to the server.

[0974] The server presents the insurance plans received from the generation AI to the user. The user reviews these plans and customizes them as necessary. At this time, the emotion engine can re-analyze the user's reactions and reflect them in the customization suggestions. For example, if the user is unsure about the plan contents, the emotion engine will detect this and display a more detailed explanation.

[0975] Once the user has finalized the customized insurance plan that satisfies them, the finalized information is sent to the server. The server stores the finalized insurance plan in the database again and sends this information to the insurance company's system. Once the insurance application is complete, the server notifies the user of the completion. This can be done by email or on a web page.

[0976] Specific examples

[0977] For example, a 30-year-old single man uses the system and enters his age (30), occupation (IT engineer), health condition (good), and hobby (outdoor activities). The emotion engine detects that the user is feeling a little anxious as he enters the information. Based on this risk profile and emotion data, the generative AI selects an insurance plan that emphasizes greater peace of mind. The plan may include medical insurance and life insurance, and detailed explanations and special terms and conditions are provided to enhance peace of mind. The user customizes these plans and finally confirms them.

[0978] This allows the system of the present invention to comprehensively analyze the user's risk profile and emotional state and effectively propose the most suitable insurance plan.

[0979] The processing flow will be explained below.

[0980] Step 1:

[0981] The user accesses the system using a terminal. The system homepage is displayed, and the user clicks the "Enter Risk Profile Information" button.

[0982] Step 2:

[0983] The server displays a form for entering risk profile information, including fields for age, occupation, health status, hobbies, etc.

[0984] Step 3:

[0985] As users begin to enter their risk profile information, the emotion engine kicks in and begins collecting emotional data from the user's facial expressions and vocal tone, for example, by analyzing the data in real time using the camera and microphone.

[0986] Step 4:

[0987] The user enters all the risk profile information and clicks the "Submit" button. Example: The user enters age "30 years old", occupation "IT engineer", health condition "good", and hobby "outdoor activities".

[0988] Step 5:

[0989] The emotion engine analyzes the user's emotion data and estimates their current emotional state, such as anxiety, relief, or excitement.

[0990] Step 6:

[0991] The server receives the risk profile information submitted through the form and the emotion data obtained from the emotion engine, and stores them in a database. The data is stored in an SQL database.

[0992] Step 7:

[0993] The server sends risk profile information and emotion data to the generation AI via the module, using JSON format data.

[0994] Step 8:

[0995] The generative AI analyzes risk profile information and sentiment data to select an appropriate insurance plan from 10 options. For example, if peace of mind is a priority, medical insurance and life insurance may be included.

[0996] Step 9:

[0997] The generation AI returns the selected insurance plan to the server in JSON format.

[0998] Step 10:

[0999] The server presents the insurance plans received from the generation AI to the user, who can then view the dynamically generated list of insurance plans on an HTML page.

[1000] Step 11:

[1001] The user reviews the insurance plan and customizes it as needed. At this point, the emotion engine is activated again to analyze the user's reactions. For example, if the user is feeling uneasy about a particular plan, it sends that information to the server.

[1002] Step 12:

[1003] The server provides the user with additional information or other suggestions based on the analysis results of the emotion engine, thereby increasing the user's sense of security.

[1004] Step 13:

[1005] The user finally decides on a customized insurance plan that satisfies him and clicks the "Confirm" button.

[1006] Step 14:

[1007] The server saves the confirmed insurance plan back to the database. The data is saved in an SQL database.

[1008] Step 15:

[1009] The server sends the finalized insurance plan to the insurance company's system using REST API or SOAP protocol.

[1010] Step 16:

[1011] The server notifies the user that the insurance application is complete, either by email or via a web page.

[1012] Example 2

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

[1014] Conventional insurance proposal systems propose insurance plans based solely on the user's risk profile information, making it difficult to propose optimal insurance plans that take the user's emotional state into account. Furthermore, since the proposed plans cannot reflect the user's emotions and reactions at the time of input, user satisfaction may decline. This leaves users feeling anxious and uncertain, making it difficult to select an appropriate insurance plan.

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

[1016] In this invention, the server includes a means for a user to input risk profile information, a means for an emotion engine to collect and analyze emotion data from the user's facial expressions and tone of voice, a means for transmitting the collected emotion data together with the risk profile information to the server, and a means for a generating artificial intelligence to analyze the risk profile information and emotion data and select an appropriate insurance plan. This makes it possible to propose an optimal insurance plan that comprehensively considers the user's risk profile information and emotional state.

[1017] "User" refers to an individual who utilizes the system to input risk profile information and propose and customize insurance plans.

[1018] "Terminal" refers to a device operated by a user to access the system and input information.

[1019] "Server" refers to the system component that receives, stores, and analyzes user input information and connects with the generation AI and database.

[1020] "Risk profile information" refers to personal information that users enter into the system, including information related to risk assessment, such as age, occupation, health status, and hobbies.

[1021] "Emotion Engine" refers to the software component that collects and analyzes emotional data from a user's facial expressions and vocal tone in real time.

[1022] "Emotion data" refers to data that indicates the user's emotional state, obtained by the emotion engine analyzing the user's facial expressions and tone of voice.

[1023] "Generative AI" refers to algorithms and models that analyze risk profile information and emotional data to select appropriate insurance plans.

[1024] "Insurance plan" refers to the composition and features of multiple insurance products selected by the generation AI and presented to the user.

[1025] "Database" refers to data storage for storing risk profile information, sentiment data, confirmed insurance plans, etc.

[1026] "Insurance company system" refers to an external system to which the server sends finalized insurance plans and manages insurance applications.

[1027] "Customization" refers to the act of a user adjusting or modifying the insurance plan presented to them to suit their own needs and circumstances.

[1028] "Confirmation" refers to the act of the user finally selecting a customized insurance plan and sending it to the server.

[1029] "Notification" refers to a communication method used by the server to inform the user of the completion of the insurance application or other important information.

[1030] The present invention analyzes a user's risk profile through a system that combines a generative AI and an emotion engine, and proposes an optimal insurance plan. Specific embodiments are described below.

[1031] First, a user accesses the system using their own device. The system's homepage is displayed, and the user accesses a form for entering risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies. Input is typically done using a keyboard or touchscreen.

[1032] The server then embeds an emotion engine into the input form, and while the user is entering data, it uses a camera and microphone to collect emotion data from the user's facial expressions and tone of voice. The emotion engine analyzes the collected data in real time and determines the user's emotional state. For example, if the user looks anxious, "anxiety" is detected as the emotion data.

[1033] The server receives the risk profile information and emotion data sent by the user and stores them in a database. Once stored, the server sends this information to the generative AI, which then analyzes the risk profile information and emotion data using natural language processing (NLP) techniques and machine learning algorithms. The generative AI model used here is an advanced natural language generation model such as GPT-3.

[1034] Based on the analysis results, the generative AI selects an appropriate insurance plan from 10 candidates. For example, if the user has low risk tolerance and feels anxious, an insurance plan with content that gives them more peace of mind will be selected. The selected insurance plan is then sent back to the server.

[1035] The server presents the insurance plan received from the generation AI to the user. The user reviews the plan and customizes it as needed. During this customization, the emotion engine again analyzes the user's reaction and, for example, if the user feels anxious, presents detailed explanations and additional options.

[1036] Once the user has finalized the customized insurance plan that satisfies them, the information is sent to the server. The server stores the finalized insurance plan in the database again and sends this information to the insurance company's system. Once the insurance application is complete, the server notifies the user of the completion. This can be done by email or on a web page.

[1037] Specific examples

[1038] For example, use the following prompt:

[1039] The user is a single man, aged 30, works as an engineer in an IT company, is in good health, and enjoys outdoor activities. The user is entering his information with some trepidation. Please suggest an insurance plan that emphasizes peace of mind.

[1040] Based on this prompt, the generative AI can comprehensively analyze the user's profile and emotional state to suggest an appropriate insurance plan, which the user can then review and customize before making a final decision.

[1041] As a result, the present invention can propose optimal insurance plans that comprehensively take into account the user's risk profile and emotional state, and that will provide high levels of user satisfaction.

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

[1043] Step 1: User enters risk profile information

[1044] Users access the system using their own terminal and enter their risk profile information. The system homepage is displayed on the terminal, and a form is presented to enter information such as age, occupation, health status, and hobbies. The entered data is sent from the terminal to the server.

[1045] Input: User's risk profile information (age, occupation, health status, hobbies)

[1046] Output: Risk profile information sent to the server

[1047] Step 2: Collecting sentiment data in real time

[1048] The server embeds an emotion engine into the input form, and uses a camera and microphone to collect emotion data from the user's facial expressions and tone of voice as they input information. The emotion engine analyzes this data in real time to determine the user's emotional state.

[1049] Input: User's facial expression data, voice tone data

[1050] Output: Real-time emotion data to the server

[1051] Step 3: Send and store data

[1052] The server receives the risk profile information and emotion data sent by the user, stores this data in the system's database, and simultaneously sends the risk profile information and emotion data to the generation AI.

[1053] Input: Risk profile information, emotion data

[1054] Output: Save to database, send data to generation AI

[1055] Step 4: Data analysis with generative AI

[1056] The generative AI receives risk profile information and emotional data sent from the server and analyzes them using natural language processing (NLP) technology and machine learning algorithms. As a result of the analysis, an insurance plan that reflects the user's risk tendencies and emotional state is selected.

[1057] Input: Risk profile information, emotion data

[1058] Output: Analysis results (insurance plan based on user's risk propensity and emotional state)

[1059] Step 5: Select an insurance plan

[1060] Based on the analysis results, the generative AI selects the optimal insurance plan from 10 candidates. For example, if the user has low risk tolerance and is feeling anxious, the insurance plan with the most reassuring content will be selected.

[1061] Input: Analysis results by generative AI

[1062] Output: Selected insurance plans (10 candidates)

[1063] Step 6: Present to the user and customize

[1064] The server presents the insurance plan received from the generation AI to the user. The user reviews the presented plan and customizes it as necessary. At this time, the emotion engine again analyzes the user's reaction and, for example, if the user feels uneasy, presents detailed explanations and additional options.

[1065] Input: Selected insurance plan, user response data

[1066] Output: Customized insurance plan, additional instructions and options

[1067] Step 7: Finalize and notify

[1068] Once the user is satisfied with the customized insurance plan and finalizes it, the information is sent to the server. The server saves the finalized insurance plan in the database and sends it to the insurance company's system. Once the insurance application is complete, the server notifies the user.

[1069] Enter: Customized Insurance Plan

[1070] Output: Save to database, send to insurance company's system, notify user of completion

[1071] (Application example 2)

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

[1073] Conventional systems cannot consider the user's emotional state or real-time emotional data when analyzing the user's risk profile and proposing an appropriate plan, and as a result, the plan provided often does not adapt to the user's actual needs or emotional state. To solve this problem, a system that utilizes the user's real-time emotional data to provide a more personalized plan is needed.

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

[1075] In this invention, the server includes: means for a user to input risk profile information; means for the server to receive the risk profile information and store it in a database; means for the server to collect and receive emotion data in addition to the risk profile information; means including an emotion engine that analyzes sensor data from the smart device to generate emotion data; means for the server to transmit the risk profile information and emotion data to a generating artificial intelligence; means for the generating artificial intelligence to analyze the risk profile information and emotion data and select an appropriate plan; means for the generating artificial intelligence to return the selected plan to the server; means for the server to present the returned plan to the user; means for the user to customize the plan and finalize the final plan; means for the server to receive the finalized plan and store it in a database; means for the server to transmit the finalized plan to a related system; and means for the server to notify the user that the application has been completed. This makes it possible to provide a personalized plan that is adapted to the user's actual needs and emotional state by utilizing the user's emotion data.

[1076] "Risk profile information" is information that indicates the risk characteristics of a user, such as the user's age, occupation, health condition, and hobbies.

[1077] "Emotion data" is data that indicates the user's emotional state, generated from the user's facial expression, tone of voice, etc.

[1078] The "emotion engine" is a system that analyzes sensor data from smart devices to generate user emotion data.

[1079] "Generative AI" or "generative artificial intelligence" is artificial intelligence that analyzes a user's risk profile information and emotional data and selects an appropriate plan.

[1080] A "smart device" is an electronic device equipped with a camera and microphone that is used to capture emotional data.

[1081] The "database" is a storage device for storing information such as risk profile information, emotion data, and confirmed plans received by the server.

[1082] A "server" is a computer system responsible for processing information received from users, storing it in a database, and transmitting the information to related systems.

[1083] A "plan" is an appropriate insurance or spending plan selected based on the user's risk profile information and sentiment data.

[1084] "Relevant system" means the insurance company's system that receives the finalized plan or any other appropriate system.

[1085] The present invention is a system that analyzes a user's risk profile information and emotion data and proposes an appropriate plan. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS The following describes in detail specific embodiments of the present invention.

[1086] Initial Setup

[1087] A user installs the application on their smartphone and enters basic information (age, occupation, income, hobbies, etc.) when they first launch the application. This initial setting information becomes the data necessary for the user's risk profile.

[1088] Collecting Emotional Data

[1089] The smartphone's camera and microphone are used to collect facial expressions and vocal tones while the user is entering information. This emotional data is analyzed by the emotion engine and converted into a numerical emotion score.

[1090] Data transmission and analysis

[1091] The server stores the risk profile information and emotion data received from the user in a database, and simultaneously transmits this data to the generation AI.

[1092] The Generative AI analyzes the received risk profile information and emotion data to select the optimal plan, using natural language processing (NLP) technology and machine learning algorithms.

[1093] Plan proposal and customization

[1094] The artificial intelligence generator sends the selected plan back to the server, which then displays it on the user's smartphone, where the user can confirm the details.

[1095] Users can customize the proposed plan, and the emotion engine will again analyze the user's reactions and adjust the plan accordingly.

[1096] For example, if a user is unsure about a suggestion, a detailed explanation is automatically added.

[1097] Confirmation and Notification

[1098] When the user finally decides on a customized plan to his satisfaction, the server stores the decision information in a database and transmits it to the related systems.

[1099] The server will notify the user of the completion of the application via email or the app's notification function.

[1100] Specific use cases

[1101] For example, if a 30-year-old single man uses this system, he will enter his age as "30," his occupation as "IT company engineer," and his income as "5 million yen," and will supplement it with information about his hobby as "outdoor activities." The emotion engine will also detect that the user is feeling a little uneasy when entering the information. Based on this risk profile and emotion data, the generation AI will select a plan that places more emphasis on peace of mind. The plan may include health insurance, life insurance, and special provisions for outdoor activities. In this case, the generation AI will use the following prompt:

[1102] Age: 30, Income: 5 million yen, Emotional score: 0.8, Please suggest an appropriate spending plan.

[1103] Hardware and software used

[1104] Smart devices: Emotional data is collected using the smartphone's camera and microphone.

[1105] Emotion Engine: Uses Keras to perform facial recognition and speech analysis to generate emotion scores.

[1106] Generative AI: Run a GPT-2 model using Hugging Face's Transformers library to analyze risk profile information and emotion data.

[1107] Servers and databases: Serve as the infrastructure for storing and analyzing user and confirmation information.

[1108] In this way, by utilizing the user's emotional data, the present invention can provide a personalized plan that is adapted to the user's actual needs and emotional state.

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

[1110] Step 1:

[1111] The user installs and launches the smartphone app. When the app is launched for the first time, it prompts the user to enter basic information (age, occupation, income, hobbies, etc.). This allows risk profile information to be collected. The entered data is sent to the server and stored in a database.

[1112] Input: Basic information such as age, occupation, income, hobbies, etc.

[1113] Output: Risk profile information stored on the server

[1114] Step 2:

[1115] While the user is entering information, the device's camera and microphone are activated to collect emotion data, such as facial expressions and tone of voice. The emotion engine analyzes this data and generates a numerical emotion score.

[1116] Input: facial expression data, voice tone data

[1117] Output: Numerical sentiment score

[1118] Step 3:

[1119] The server stores the risk profile information and emotion score in a database and sends it to the AI ​​for analysis, which then generates a prompt as data necessary for analysis.

[1120] Input: Risk profile information, sentiment score

[1121] Output: Prompt and data sent to the generation AI

[1122] Step 4:

[1123] The generation AI performs data analysis based on the received risk profile information and emotion scores. The analysis uses natural language processing technology and machine learning algorithms to select the plan that best suits the user's needs. The generation AI then returns the selection results to the server.

[1124] Input: prompt statement, risk profile information, sentiment score

[1125] Output: The optimal plan sent back to the server

[1126] Step 5:

[1127] The server displays the plan returned by the generation AI on the user's smartphone. The user can review the plan and customize it as needed. During the customization process, the emotion engine analyzes the user's reactions and adjusts the plan accordingly.

[1128] Input: Plan selected by the generation AI, user's reaction (facial expression, voice)

[1129] Output: A plan customized by the user

[1130] Step 6:

[1131] Once the user has finalized the customized plan to their satisfaction, the information is sent to the server, which stores the finalized information in a database and sends it to the relevant systems.

[1132] Input: Customized Plan

[1133] Output: Finalized plan stored in database, plan sent to relevant systems

[1134] Step 7:

[1135] The server notifies the user of the completion of the application via email or the app's notification function.

[1136] Input: Confirmed plan information

[1137] Output: Completion notification sent to the user

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

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

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

[1141] [Fourth embodiment]

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

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

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

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

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

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

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

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

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

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

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

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

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

[1155] The present invention is a system that analyzes a user's risk profile and proposes an appropriate insurance plan. This system is realized by the mutual cooperation of three parties: a server, a terminal, and a user. The specific program processing and its flow are explained below.

[1156] First, the user accesses the system using their own terminal. The system displays a form for the user to enter risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies. Once the user enters this information and clicks the submit button, the information is sent to the server.

[1157] Next, the server receives the risk profile information sent by the user and stores it in a database. Once stored, the server sends the risk profile information to the AI ​​generator. This transmission uses a data format such as JSON.

[1158] The Generative AI (Generative Artificial Intelligence) analyzes the received risk profile information. This analysis uses natural language processing and machine learning algorithms. As a result of the analysis, the Generative AI selects the insurance plan that best suits the user's risk profile from 10 candidates. The selected insurance plan is then sent back from the Generative AI to the server.

[1159] The server receives the insurance plan returned by the generation AI and displays it to the user. The user can review the proposed insurance plan and, if necessary, view detailed information or customize it. For example, they can add specific riders or adjust the scope of coverage. Once the user has finally decided on an insurance plan that satisfies them, the information is sent to the server.

[1160] The server receives the confirmed insurance plan and stores it in the database. Then it sends this information to the insurance company's system, which completes the insurance application. Finally, the server notifies the user that the insurance application has been completed. This can be done by email or on a web page.

[1161] Specific examples

[1162] For example, if a 30-year-old single man uses the system, the following process takes place. First, the user enters information such as age "30," occupation "IT company engineer," health condition "good," and hobby "outdoor activities." The server receives this information and sends it to the generation AI. Since the user likes outdoor activities, the generation AI considers the applicability of accident insurance and travel insurance and presents an appropriate plan. The user reviews these plans and customizes them, focusing particularly on medical insurance. The server then sends the application information to the insurance company and notifies the user of completion.

[1163] In this way, the system of the present invention can efficiently analyze a user's risk profile and provide an optimal insurance plan.

[1164] The processing flow will be explained below.

[1165] Step 1:

[1166] A user accesses the system using a web browser or application by entering the system's URL and clicking the access button.

[1167] Step 2:

[1168] The server is then contacted and displays a form for filling out a risk profile, which includes fields for entering information such as age, occupation, health status, and hobbies.

[1169] Step 3:

[1170] The user enters risk profile information and clicks the "Submit" button. For example, the user enters information such as age "30 years old," occupation "IT engineer," health condition "good," and hobby "outdoor activities."

[1171] Step 4:

[1172] The server receives the data submitted through the form and stores it in a database, which is stored in an SQL database.

[1173] Step 5:

[1174] The server sends the stored risk profile information to the generation AI using JSON format data.

[1175] Step 6:

[1176] The generative AI analyzes the received risk profile information using natural language processing (NLP) techniques and machine learning models.

[1177] Step 7:

[1178] Based on the risk profile information, the generative AI selects the most suitable insurance plan from 10 candidate plans using an algorithm.

[1179] Step 8:

[1180] The generation AI returns the selected insurance plan to the server in JSON format.

[1181] Step 9:

[1182] The server presents the insurance plans received from the generation AI to the user, who is then shown a dynamically generated list of insurance plans on an HTML page.

[1183] Step 10:

[1184] The user reviews the insurance plan presented to them and customizes it as needed, for example, by adding specific riders or adjusting the scope of coverage.

[1185] Step 11:

[1186] The user finally decides on a customized insurance plan that satisfies him and clicks the "Confirm" button.

[1187] Step 12:

[1188] The server receives the finalized insurance plan and stores it in a database, which is stored in an SQL database.

[1189] Step 13:

[1190] The server sends the finalized insurance plan to the insurance company's system using REST API or SOAP protocol.

[1191] Step 14:

[1192] The server notifies the user that the insurance application is complete, either by email or via a web page.

[1193] Example 1

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

[1195] In modern society, it is important to easily provide optimal insurance plans to individual users. However, conventional methods require users to collect and compare large amounts of information, which is time-consuming. Furthermore, insurance plan proposals are not based on the user's specific risk profile, which often results in an inappropriate selection of the optimal plan. In addition, the process for users to confirm their customized insurance plan and apply to an insurance company is complicated and inefficient. Thus, there is a need for a system that can accurately analyze a user's risk profile, propose an appropriate insurance plan, and complete the insurance application quickly and efficiently.

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

[1197] In this invention, the server includes a means for a user to input risk profile information, a means for the server to receive the risk profile information and store it in a database, and a means for the server to transmit the risk profile information to the AI ​​generator. This makes it possible to efficiently collect the user's risk profile information and have the AI ​​generator analyze it. Furthermore, the AI ​​generator can provide an optimal insurance plan as a result of its analysis, allowing the user to quickly apply for a customized plan with an insurance company.

[1198] A "User" is any person or entity that provides risk profile information to the system for the purpose of receiving insurance plan offers.

[1199] The "server" is a computer system that receives risk profile information provided by users, stores it in a database, and transmits the information to the generation AI and processes the results.

[1200] "Risk profile information" refers to information necessary for selecting an insurance plan, such as a user's age, occupation, health condition, and hobbies.

[1201] "Database" means a system for organizing and storing user risk profile information and insurance plan information.

[1202] "Generative AI" is a program that uses machine learning and natural language processing technology to analyze a user's risk profile information and select the most appropriate insurance plan based on the results.

[1203] An "insurance plan" is a form of insurance contract that includes specific coverage and terms offered to a user.

[1204] "Customization" refers to a user adding riders or adjusting the scope of coverage to a proposed insurance plan.

[1205] An "interactive form" is a portion of a web page that contains dynamically operable input fields to facilitate user input of risk profile information.

[1206] An "insurance company" is a company that actually writes insurance contracts based on the insurance plans offered.

[1207] "Notification" is a message to inform the user of the completion of the insurance application or other important information.

[1208] The present invention is a system for analyzing a user's risk profile information and proposing an optimal insurance plan. This system is realized by operating multiple hardware and software components in cooperation with each other. Specific embodiments for implementing the present invention are described below.

[1209] First, a user accesses the system using a device (PC, smartphone, tablet, etc.). The device used here requires a common web browser (Google Chrome, Mozilla Firefox, Apple Safari, etc.) and a network connection. When the user enters the system's URL and accesses it, a login screen appears and the user enters their authentication information to log in to the system.

[1210] After a successful login, the server presents the user with a form to enter their risk profile information. The form is written in HTML, CSS, and JavaScript and includes input fields for age, occupation, health status, hobbies, etc.

[1211] When a user enters their risk profile information and clicks the submit button, the form data is converted to JSON format by JavaScript and sent to the server via HTTPS. For example, a 30-year-old single man enters the following information: age: 30, occupation: IT engineer, health status: good, and hobby: outdoor activities.

[1212] The server receives the risk profile information sent by the user and stores it in a database (e.g., MySQL or PostgreSQL), where it also performs data validation and validation checks.

[1213] The server then sends the stored risk profile information to the Generation AI, which uses an advanced AI model such as GPT-4. The data is in JSON format and passed to the Generation AI via a RESTful API.

[1214] The Generator AI uses natural language processing (NLP) techniques and machine learning algorithms (for example, using the PyTorch or TensorFlow frameworks) to analyze the received risk profile information. As a result of this analysis, the Generator AI selects the optimal insurance plan from 10 candidates. This candidate plan is then sent back to the server in JSON format.

[1215] The server receives the insurance plan returned by the generation AI and displays it in HTML format to the user, who can then review the proposed insurance plan through a web browser, add specific riders, or adjust the coverage.

[1216] Furthermore, when the user customizes and confirms the insurance plan, the customization information is sent again to the server in JSON format. After the server receives the confirmed insurance plan, it stores it in the database. The final insurance plan information is sent from the server to the insurance company's system. Security protocols (e.g., OAuth) are also applied during the transmission via the insurance company's API.

[1217] Finally, the server notifies the user that the insurance application has been completed. The notification can be sent via email or a web page. Email notifications are sent using the SMTP protocol, and web notifications are sent via JavaScript.

[1218] An example of a prompt sentence is input to the generative AI model in text format, such as, "A 30-year-old single male, an engineer at an IT company, in good health, and whose hobby is outdoor activities. Please suggest the best insurance plan for this user." Based on this prompt, the generative AI selects an insurance plan that matches the user's risk profile.

[1219] As described above, the server, user, and generation AI work together to create a system that efficiently proposes the optimal insurance plan to the user and speeds up the application process.

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

[1221] Step 1: The user accesses the system using a terminal

[1222] Specific operation: A user opens a web browser on a device such as a PC, smartphone, or tablet, and enters the system's URL to access it. At this time, the user enters authentication information (user name and password) on the login screen to log in to the system.

[1223] Input: System URL, user authentication information (username, password)

[1224] Output: The user is successfully logged in and the system home page is displayed.

[1225] Step 2: The server displays the input form

[1226] What it does: After a user successfully logs in, the server displays an HTML form for the user to enter their risk profile information. The form includes input fields for age, occupation, health status, hobbies, etc.

[1227] Input: User login success information

[1228] Output: An HTML form for entering risk profile information is displayed in the user's browser.

[1229] Step 3: User enters and submits risk profile information

[1230] Specific operation: The user enters the required risk profile information into the displayed form. When the user has completed the input, they click the "Submit" button. Upon clicking, JavaScript converts the form data into JSON format and sends it to the server via the HTTPS protocol.

[1231] Input: User's risk profile information (age, occupation, health status, hobbies, etc.)

[1232] Output: Risk profile information is sent to the server in JSON format.

[1233] Step 4: The server receives the information and stores it in a database

[1234] Specific operation: The server receives the JSON data sent by the user. After receiving it, the server checks the validity of the data, performs any necessary validation, and then saves it in a database (MySQL or PostgreSQL) using SQL commands.

[1235] Input: Risk profile information in JSON format

[1236] Output: Risk profile information stored in a database

[1237] Step 5: The server sends the information to the generated AI

[1238] Specific operation: The server sends the saved risk profile information to the generation AI. This is done via a RESTful API, and the data is again in JSON format. A request is made to the API endpoint.

[1239] Input: Risk profile information stored in the database

[1240] Output: Risk profile information in JSON format is sent to the generation AI

[1241] Step 6: Generative AI analyzes the information and selects an insurance plan

[1242] How it works: The Generator AI performs an analysis based on the received risk profile information. This analysis uses NLP techniques and machine learning algorithms (e.g., PyTorch and TensorFlow frameworks). Based on the analysis, the Generator AI selects the most suitable insurance plan from 10 candidates based on the user's risk profile.

[1243] Input: Risk profile information in JSON format

[1244] Output: Insurance plan data in JSON format (10 options)

[1245] Step 7: The generative AI sends the results back to the server

[1246] Specific operation: The insurance plan selected by the generation AI is returned to the server in JSON format. The return is also done using a RESTful API.

[1247] Input: Insurance plan data in JSON format (10 options)

[1248] Output: Insurance plan data in JSON format is sent to the server

[1249] Step 8: Server displays insurance plan to user

[1250] Specific operation: The server receives the insurance plans returned by the generation AI and displays them to the user in HTML format. The user's device browser displays a list of selected insurance plans.

[1251] Input: Insurance plan data in JSON format (10 options)

[1252] Output: A list of insurance plans in HTML format, displayed in the user's browser.

[1253] Step 9: User reviews and customizes plan

[1254] How it works: The user reviews the insurance plans displayed, selects a specific plan, adds riders, or adjusts coverage. These customization operations are also performed using JavaScript, and the selection information is again converted to JSON format and sent to the server.

[1255] Input: User customization operations (adding special clauses, adjusting coverage, etc.)

[1256] Output: Customized insurance plan information is sent to the server in JSON format.

[1257] Step 10: The server receives and stores the final plan

[1258] Specific operation: The server receives the customized insurance plan information and saves it back to the database. The save operation is also performed using SQL statements. Data integrity checks are performed to ensure accurate data is saved.

[1259] Input: Customized insurance plan information in JSON format

[1260] Output: Customized insurance plan information stored in a database

[1261] Step 11: Server sends information to insurance company

[1262] What happens: The server sends the final insurance plan information to the insurance company's system, again via an API and applying security protocols (e.g., OAuth) as needed.

[1263] Input: Final insurance plan information stored in the database

[1264] Output: Insurance plan information sent to the insurance company's system

[1265] Step 12: The server notifies the user

[1266] Specific operation: The server notifies the user that the insurance application has been completed. This notification can be sent via email or a web page. Emails are sent using the SMTP protocol, and web notifications are sent via JavaScript.

[1267] Input: Final insurance plan information submitted

[1268] Output: Notification of insurance application completion sent to the user

[1269] As mentioned above, we have explained in detail how specific inputs and outputs, as well as data processing and calculations are performed at each step. This will enable the realization of a system that efficiently analyzes a user's risk profile information and proposes the most suitable insurance plan.

[1270] (Application example 1)

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

[1272] Current security plan offerings face the challenge of making it difficult to select the optimal plan based on a user's individual risk profile. Furthermore, it is difficult for users to determine which security measures are optimal, which can result in excessive or insufficient measures being selected. This not only reduces the efficiency and effectiveness of security, but also leads to cost waste. This invention aims to solve these challenges by providing a system that automatically selects and proposes the optimal security plan based on the user's risk profile.

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

[1274] In this invention, the server includes a means for a user to input risk profile information, a means for the server to receive the risk profile information and store it in a database, and a means for the server to transmit the risk profile information to a generating artificial intelligence. This provides a system including a means for the generating artificial intelligence to analyze the risk profile information and select an appropriate security plan, a means for the generating artificial intelligence to return the security plan selected by the generating artificial intelligence to the server, a means for the server to present the returned security plan to the user, a means for the user to customize the security plan and finalize the final security plan, a means for the server to receive the finalized security plan and store it in a database, a means for the server to transmit the finalized security plan to a security provider's system, and a means for the server to notify the user that the security plan is complete. This allows users to easily select and customize an appropriate security plan and implement effective security measures.

[1275] "User" means an individual or entity that inputs risk profile information into the system and selects and customizes a security plan.

[1276] "Risk profile information" is data that includes information such as a user's age, occupation, residential area, frequency of internet use, and past intrusion experiences.

[1277] A "server" is a hardware or software system that receives risk profile information from users, stores it in a database, and transmits it to the generation AI.

[1278] "Database" means a data management system for storing risk profile information and established security plans received by the Server.

[1279] "Generative artificial intelligence (generative AI)" refers to artificial intelligence technology that analyzes risk profile information received from users and selects the optimal security plan.

[1280] "Security plan" refers to specific proposals for security measures required by users, including home security systems, cybersecurity measures, and personal information protection.

[1281] "Security provider" means a company or organization that implements and provides the security plan selected and confirmed by the user.

[1282] "Collaboration" refers to the process by which multiple systems or services work together and exchange information.

[1283] "Security Measures" refers to the means used to protect Users' personal information and physical property, and includes technical, organizational, and physical measures.

[1284] A system embodying the present invention is one in which a user inputs risk profile information and an optimal security plan is proposed and customized. Specific embodiments are described below.

[1285] First, a user accesses the system using their own device (e.g., a smartphone). The system displays a form for the user to enter risk profile information. This form includes fields for entering information such as age, occupation, residential area, frequency of internet use, and past breaches. When the user enters this information and clicks the submit button, the information is sent to the server in JSON format.

[1286] Next, the server receives the risk profile information sent by the user and stores it in a database. The database uses a cloud-based data management system such as AWS RDS (MySQL). Once stored, the server sends the risk profile information to a generation AI. The generation AI is implemented in Python and uses machine learning models using scikit-learn and TensorFlow.

[1287] The Generator AI analyzes the received risk profile information and selects an appropriate security plan. This analysis utilizes a machine learning algorithm that generates optimal output based on specific input information. As a result of the analysis, the Generator AI selects the security plan that best suits the user's risk profile from multiple candidates. The selected security plan is then sent back from the Generator AI to the server.

[1288] The server receives the security plan returned by the generation AI and displays it to the user. The user can review the proposed security plan and, if necessary, view detailed information or customize it. For example, they can add specific security measures or adjust the scope of services. Once the user has finalized a security plan that satisfies them, the information is sent back to the server.

[1289] The server receives the confirmed security plan and stores it in its database. It then sends this information to the security provider's system, which completes the security service application. Finally, the server notifies the user that the security plan has been completed. This notification is sent via email or a web page.

[1290] Specific examples

[1291] For example, if a 35-year-old single man uses the system, the following process takes place. First, the user enters information such as age (35), occupation (systems engineer), residential area (Tokyo), frequency of internet use (daily), and no prior hacking experience. The server receives this information and sends it to the generation AI. Based on the user's data, the generation AI presents appropriate plans, such as a home security system, antivirus software, and personal information protection service. The user reviews these plans and adds or adjusts measures that are particularly important to them. The server then sends the confirmed information to the security provider and notifies the user of completion.

[1292] Example prompts for generative AI models

[1293] "Please suggest the best security plan based on the user's risk profile information. Here is the user information:

[1294] Age: 35

[1295] Occupation: Systems Engineer

[1296] Living area: Tokyo

[1297] Internet usage frequency: Daily

[1298] Previous breaches: None

[1299] In this way, the present invention can efficiently analyze a user's risk profile and provide an optimal security plan.

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

[1301] Step 1:

[1302] The user accesses the system using their own terminal. The terminal displays a form for entering risk profile information. The user enters information such as age, occupation, residential area, frequency of internet use, and past breaches, and clicks the submit button.

[1303] Input: Risk profile information entered by the user into a form (age, occupation, region of residence, frequency of internet use, previous breaches).

[1304] Output: Risk profile information sent to the server in JSON format.

[1305] Step 2:

[1306] The server receives the risk profile information sent by the user and stores this information in a database.

[1307] Input: Risk profile information sent from the device.

[1308] Output: Risk profile information stored in a database.

[1309] Step 3:

[1310] The server sends the risk profile information stored in the database to the Generating Artificial Intelligence (Generating AI) using JSON format data.

[1311] Input: Risk profile information stored in the database.

[1312] Output: Risk profile information sent to the generating AI.

[1313] Step 4:

[1314] The Generator AI analyzes the received risk profile information and, specifically, uses natural language processing and machine learning algorithms to select the most appropriate security plan for the user.

[1315] Input: Risk profile information sent by the server.

[1316] Output: A suitable security plan is selected.

[1317] Step 5:

[1318] The generation AI returns the selected security plan to the server.

[1319] Input: An appropriate security plan selected by the generative AI.

[1320] Output: The security plan sent back to the server by the generation AI.

[1321] Step 6:

[1322] The server then presents the received security plan to the user's terminal, where the user can review the plan and customize it as needed.

[1323] Input: The security plan sent back to the server.

[1324] Output: The security plan displayed on the user's device.

[1325] Step 7:

[1326] The user customizes the security plan and finalizes it, which is then sent from the device to the server.

[1327] Input: User customized security plan.

[1328] Output: Finalized security plan.

[1329] Step 8:

[1330] The server receives the finalized security plan and stores it in the database again.

[1331] Input: The final confirmed security plan submitted by the user.

[1332] Output: The final security plan stored in the database.

[1333] Step 9:

[1334] The server sends the finalized security plan to the security provider's system, thereby completing the application for security services.

[1335] Input: The final security plan stored in the database.

[1336] Output: The security plan sent to the security contractor's system.

[1337] Step 10:

[1338] The server will notify the user that the security service subscription has been completed. This notification will be sent via email or a web page.

[1339] Input: Record of completed transmission from server to security company.

[1340] Output: Completion notification sent to the user.

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

[1342] This invention is a system that analyzes a user's risk profile and proposes the optimal insurance plan through a system that combines generative AI and an emotion engine. The specific program processing and flow are explained below.

[1343] First, the user accesses the system using their own terminal. The system homepage is displayed, and the user accesses a form for entering risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies.

[1344] The server then embeds an emotion engine into the input form, and while the user is entering information, the emotion engine collects and analyzes emotion data from the user's facial expressions and tone of voice. The obtained emotion data is then sent to the server along with risk profile information.

[1345] The server receives the risk profile information and emotional data sent by the user and stores it in a database. Once saved, the server sends this information to the generation AI, which then analyzes the received risk profile information and emotional data. This analysis uses natural language processing (NLP) technology and machine learning algorithms. In addition, by taking emotional data into account, it becomes possible to select an insurance plan that reflects the user's emotional state.

[1346] The AI ​​selects an appropriate insurance plan from 10 options based on the risk profile and emotional data. For example, if the user has low risk tolerance, it will prioritize a plan that provides a greater sense of security. The AI ​​then returns the selected insurance plan to the server.

[1347] The server presents the insurance plans received from the generation AI to the user. The user reviews these plans and customizes them as necessary. At this time, the emotion engine can re-analyze the user's reactions and reflect them in the customization suggestions. For example, if the user is unsure about the plan contents, the emotion engine will detect this and display a more detailed explanation.

[1348] Once the user has finalized the customized insurance plan that satisfies them, the finalized information is sent to the server. The server stores the finalized insurance plan in the database again and sends this information to the insurance company's system. Once the insurance application is complete, the server notifies the user of the completion. This can be done by email or on a web page.

[1349] Specific examples

[1350] For example, a 30-year-old single man uses the system and enters his age (30), occupation (IT engineer), health condition (good), and hobby (outdoor activities). The emotion engine detects that the user is feeling a little anxious as he enters the information. Based on this risk profile and emotion data, the generative AI selects an insurance plan that emphasizes greater peace of mind. The plan may include medical insurance and life insurance, and detailed explanations and special terms and conditions are provided to enhance peace of mind. The user customizes these plans and finally confirms them.

[1351] This allows the system of the present invention to comprehensively analyze the user's risk profile and emotional state and effectively propose the most suitable insurance plan.

[1352] The processing flow will be explained below.

[1353] Step 1:

[1354] The user accesses the system using a terminal. The system homepage is displayed, and the user clicks the "Enter Risk Profile Information" button.

[1355] Step 2:

[1356] The server displays a form for entering risk profile information, including fields for age, occupation, health status, hobbies, etc.

[1357] Step 3:

[1358] As users begin to enter their risk profile information, the emotion engine kicks in and begins collecting emotional data from the user's facial expressions and vocal tone, for example, by analyzing the data in real time using the camera and microphone.

[1359] Step 4:

[1360] The user enters all the risk profile information and clicks the "Submit" button. Example: The user enters age "30 years old", occupation "IT engineer", health condition "good", and hobby "outdoor activities".

[1361] Step 5:

[1362] The emotion engine analyzes the user's emotion data and estimates their current emotional state, such as anxiety, relief, or excitement.

[1363] Step 6:

[1364] The server receives the risk profile information submitted through the form and the emotion data obtained from the emotion engine, and stores them in a database. The data is stored in an SQL database.

[1365] Step 7:

[1366] The server sends risk profile information and emotion data to the generation AI via the module, using JSON format data.

[1367] Step 8:

[1368] The generative AI analyzes risk profile information and sentiment data to select an appropriate insurance plan from 10 options. For example, if peace of mind is a priority, medical insurance and life insurance may be included.

[1369] Step 9:

[1370] The generation AI returns the selected insurance plan to the server in JSON format.

[1371] Step 10:

[1372] The server presents the insurance plans received from the generation AI to the user, who can then view the dynamically generated list of insurance plans on an HTML page.

[1373] Step 11:

[1374] The user reviews the insurance plan and customizes it as needed. At this point, the emotion engine is activated again to analyze the user's reactions. For example, if the user is feeling uneasy about a particular plan, it sends that information to the server.

[1375] Step 12:

[1376] The server provides the user with additional information or other suggestions based on the analysis results of the emotion engine, thereby increasing the user's sense of security.

[1377] Step 13:

[1378] The user finally decides on a customized insurance plan that satisfies him and clicks the "Confirm" button.

[1379] Step 14:

[1380] The server saves the confirmed insurance plan back to the database. The data is saved in an SQL database.

[1381] Step 15:

[1382] The server sends the finalized insurance plan to the insurance company's system using REST API or SOAP protocol.

[1383] Step 16:

[1384] The server notifies the user that the insurance application is complete, either by email or via a web page.

[1385] Example 2

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

[1387] Conventional insurance proposal systems propose insurance plans based solely on the user's risk profile information, making it difficult to propose optimal insurance plans that take the user's emotional state into account. Furthermore, since the proposed plans cannot reflect the user's emotions and reactions at the time of input, user satisfaction may decline. This leaves users feeling anxious and uncertain, making it difficult to select an appropriate insurance plan.

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

[1389] In this invention, the server includes a means for a user to input risk profile information, a means for an emotion engine to collect and analyze emotion data from the user's facial expressions and tone of voice, a means for transmitting the collected emotion data together with the risk profile information to the server, and a means for a generating artificial intelligence to analyze the risk profile information and emotion data and select an appropriate insurance plan. This makes it possible to propose an optimal insurance plan that comprehensively considers the user's risk profile information and emotional state.

[1390] "User" refers to an individual who utilizes the system to input risk profile information and propose and customize insurance plans.

[1391] "Terminal" refers to a device operated by a user to access the system and input information.

[1392] "Server" refers to the system component that receives, stores, and analyzes user input information and connects with the generation AI and database.

[1393] "Risk profile information" refers to personal information that users enter into the system, including information related to risk assessment, such as age, occupation, health status, and hobbies.

[1394] "Emotion Engine" refers to the software component that collects and analyzes emotional data from a user's facial expressions and vocal tone in real time.

[1395] "Emotion data" refers to data that indicates the user's emotional state, obtained by the emotion engine analyzing the user's facial expressions and tone of voice.

[1396] "Generative AI" refers to algorithms and models that analyze risk profile information and emotional data to select appropriate insurance plans.

[1397] "Insurance plan" refers to the composition and features of multiple insurance products selected by the generation AI and presented to the user.

[1398] "Database" refers to data storage for storing risk profile information, sentiment data, confirmed insurance plans, etc.

[1399] "Insurance company system" refers to an external system to which the server sends finalized insurance plans and manages insurance applications.

[1400] "Customization" refers to the act of a user adjusting or modifying the insurance plan presented to them to suit their own needs and circumstances.

[1401] "Confirmation" refers to the act of the user finally selecting a customized insurance plan and sending it to the server.

[1402] "Notification" refers to a communication method used by the server to inform the user of the completion of the insurance application or other important information.

[1403] The present invention analyzes a user's risk profile through a system that combines a generative AI and an emotion engine, and proposes an optimal insurance plan. Specific embodiments are described below.

[1404] First, a user accesses the system using their own device. The system's homepage is displayed, and the user accesses a form for entering risk profile information. This form includes fields for entering information such as age, occupation, health status, and hobbies. Input is typically done using a keyboard or touchscreen.

[1405] The server then embeds an emotion engine into the input form, and while the user is entering data, it uses a camera and microphone to collect emotion data from the user's facial expressions and tone of voice. The emotion engine analyzes the collected data in real time and determines the user's emotional state. For example, if the user looks anxious, "anxiety" is detected as the emotion data.

[1406] The server receives the risk profile information and emotion data sent by the user and stores them in a database. Once stored, the server sends this information to the generative AI, which then analyzes the risk profile information and emotion data using natural language processing (NLP) techniques and machine learning algorithms. The generative AI model used here is an advanced natural language generation model such as GPT-3.

[1407] Based on the analysis results, the generative AI selects an appropriate insurance plan from 10 candidates. For example, if the user has low risk tolerance and feels anxious, an insurance plan with content that gives them more peace of mind will be selected. The selected insurance plan is then sent back to the server.

[1408] The server presents the insurance plan received from the generation AI to the user. The user reviews the plan and customizes it as needed. During this customization, the emotion engine again analyzes the user's reaction and, for example, if the user feels anxious, presents detailed explanations and additional options.

[1409] Once the user has finalized the customized insurance plan that satisfies them, the information is sent to the server. The server stores the finalized insurance plan in the database again and sends this information to the insurance company's system. Once the insurance application is complete, the server notifies the user of the completion. This can be done by email or on a web page.

[1410] Specific examples

[1411] For example, use the following prompt:

[1412] The user is a single man, aged 30, works as an engineer in an IT company, is in good health, and enjoys outdoor activities. The user is entering his information with some trepidation. Please suggest an insurance plan that emphasizes peace of mind.

[1413] Based on this prompt, the generative AI can comprehensively analyze the user's profile and emotional state to suggest an appropriate insurance plan, which the user can then review and customize before making a final decision.

[1414] As a result, the present invention can propose optimal insurance plans that comprehensively take into account the user's risk profile and emotional state, and that will provide high levels of user satisfaction.

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

[1416] Step 1: User enters risk profile information

[1417] Users access the system using their own terminal and enter their risk profile information. The system homepage is displayed on the terminal, and a form is presented to enter information such as age, occupation, health status, and hobbies. The entered data is sent from the terminal to the server.

[1418] Input: User's risk profile information (age, occupation, health status, hobbies)

[1419] Output: Risk profile information sent to the server

[1420] Step 2: Collecting sentiment data in real time

[1421] The server embeds an emotion engine into the input form, and uses a camera and microphone to collect emotion data from the user's facial expressions and tone of voice as they input information. The emotion engine analyzes this data in real time to determine the user's emotional state.

[1422] Input: User's facial expression data, voice tone data

[1423] Output: Real-time emotion data to the server

[1424] Step 3: Send and store data

[1425] The server receives the risk profile information and emotion data sent by the user, stores this data in the system's database, and simultaneously sends the risk profile information and emotion data to the generation AI.

[1426] Input: Risk profile information, emotion data

[1427] Output: Save to database, send data to generation AI

[1428] Step 4: Data analysis with generative AI

[1429] The generative AI receives risk profile information and emotional data sent from the server and analyzes them using natural language processing (NLP) technology and machine learning algorithms. As a result of the analysis, an insurance plan that reflects the user's risk tendencies and emotional state is selected.

[1430] Input: Risk profile information, emotion data

[1431] Output: Analysis results (insurance plan based on user's risk propensity and emotional state)

[1432] Step 5: Select an insurance plan

[1433] Based on the analysis results, the generative AI selects the optimal insurance plan from 10 candidates. For example, if the user has low risk tolerance and is feeling anxious, the insurance plan with the most reassuring content will be selected.

[1434] Input: Analysis results by generative AI

[1435] Output: Selected insurance plans (10 candidates)

[1436] Step 6: Present to the user and customize

[1437] The server presents the insurance plan received from the generation AI to the user. The user reviews the presented plan and customizes it as necessary. At this time, the emotion engine again analyzes the user's reaction and, for example, if the user feels uneasy, presents detailed explanations and additional options.

[1438] Input: Selected insurance plan, user response data

[1439] Output: Customized insurance plan, additional instructions and options

[1440] Step 7: Finalize and notify

[1441] Once the user is satisfied with the customized insurance plan and finalizes it, the information is sent to the server. The server saves the finalized insurance plan in the database and sends it to the insurance company's system. Once the insurance application is complete, the server notifies the user.

[1442] Enter: Customized Insurance Plan

[1443] Output: Save to database, send to insurance company's system, notify user of completion

[1444] (Application example 2)

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

[1446] Conventional systems cannot consider the user's emotional state or real-time emotional data when analyzing the user's risk profile and proposing an appropriate plan, and as a result, the plan provided often does not adapt to the user's actual needs or emotional state. To solve this problem, a system that utilizes the user's real-time emotional data to provide a more personalized plan is needed.

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

[1448] In this invention, the server includes: means for a user to input risk profile information; means for the server to receive the risk profile information and store it in a database; means for the server to collect and receive emotion data in addition to the risk profile information; means including an emotion engine that analyzes sensor data from the smart device to generate emotion data; means for the server to transmit the risk profile information and emotion data to a generating artificial intelligence; means for the generating artificial intelligence to analyze the risk profile information and emotion data and select an appropriate plan; means for the generating artificial intelligence to return the selected plan to the server; means for the server to present the returned plan to the user; means for the user to customize the plan and finalize the final plan; means for the server to receive the finalized plan and store it in a database; means for the server to transmit the finalized plan to a related system; and means for the server to notify the user that the application has been completed. This makes it possible to provide a personalized plan that is adapted to the user's actual needs and emotional state by utilizing the user's emotion data.

[1449] "Risk profile information" is information that indicates the risk characteristics of a user, such as the user's age, occupation, health condition, and hobbies.

[1450] "Emotion data" is data that indicates the user's emotional state, generated from the user's facial expression, tone of voice, etc.

[1451] The "emotion engine" is a system that analyzes sensor data from smart devices to generate user emotion data.

[1452] "Generative AI" or "generative artificial intelligence" is artificial intelligence that analyzes a user's risk profile information and emotional data and selects an appropriate plan.

[1453] A "smart device" is an electronic device equipped with a camera and microphone that is used to capture emotional data.

[1454] The "database" is a storage device for storing information such as risk profile information, emotion data, and confirmed plans received by the server.

[1455] A "server" is a computer system responsible for processing information received from users, storing it in a database, and transmitting the information to related systems.

[1456] A "plan" is an appropriate insurance or spending plan selected based on the user's risk profile information and sentiment data.

[1457] "Relevant system" means the insurance company's system that receives the finalized plan or any other appropriate system.

[1458] The present invention is a system that analyzes a user's risk profile information and emotion data and proposes an appropriate plan. DETAILED DESCRIPTION OF THE PREFERRED EMBODIMENTS The following describes in detail specific embodiments of the present invention.

[1459] Initial Setup

[1460] A user installs the application on their smartphone and enters basic information (age, occupation, income, hobbies, etc.) when they first launch the application. This initial setting information becomes the data necessary for the user's risk profile.

[1461] Collecting Emotional Data

[1462] The smartphone's camera and microphone are used to collect facial expressions and vocal tones while the user is entering information. This emotional data is analyzed by the emotion engine and converted into a numerical emotion score.

[1463] Data transmission and analysis

[1464] The server stores the risk profile information and emotion data received from the user in a database, and simultaneously transmits this data to the generation AI.

[1465] The Generative AI analyzes the received risk profile information and emotion data to select the optimal plan, using natural language processing (NLP) technology and machine learning algorithms.

[1466] Plan proposal and customization

[1467] The artificial intelligence generator sends the selected plan back to the server, which then displays it on the user's smartphone, where the user can confirm the details.

[1468] Users can customize the proposed plan, and the emotion engine will again analyze the user's reactions and adjust the plan accordingly.

[1469] For example, if a user is unsure about a suggestion, a detailed explanation is automatically added.

[1470] Confirmation and Notification

[1471] When the user finally decides on a customized plan to his satisfaction, the server stores the decision information in a database and transmits it to the related systems.

[1472] The server will notify the user of the completion of the application via email or the app's notification function.

[1473] Specific use cases

[1474] For example, if a 30-year-old single man uses this system, he will enter his age as "30," his occupation as "IT company engineer," and his income as "5 million yen," and will supplement it with information about his hobby as "outdoor activities." The emotion engine will also detect that the user is feeling a little uneasy when entering the information. Based on this risk profile and emotion data, the generation AI will select a plan that places more emphasis on peace of mind. The plan may include health insurance, life insurance, and special provisions for outdoor activities. In this case, the generation AI will use the following prompt:

[1475] Age: 30, Income: 5 million yen, Emotional score: 0.8, Please suggest an appropriate spending plan.

[1476] Hardware and software used

[1477] Smart devices: Emotional data is collected using the smartphone's camera and microphone.

[1478] Emotion Engine: Uses Keras to perform facial recognition and speech analysis to generate emotion scores.

[1479] Generative AI: Run a GPT-2 model using Hugging Face's Transformers library to analyze risk profile information and emotion data.

[1480] Servers and databases: Serve as the infrastructure for storing and analyzing user and confirmation information.

[1481] In this way, by utilizing the user's emotional data, the present invention can provide a personalized plan that is adapted to the user's actual needs and emotional state.

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

[1483] Step 1:

[1484] The user installs and launches the smartphone app. When the app is launched for the first time, it prompts the user to enter basic information (age, occupation, income, hobbies, etc.). This allows risk profile information to be collected. The entered data is sent to the server and stored in a database.

[1485] Input: Basic information such as age, occupation, income, hobbies, etc.

[1486] Output: Risk profile information stored on the server

[1487] Step 2:

[1488] While the user is entering information, the device's camera and microphone are activated to collect emotion data, such as facial expressions and tone of voice. The emotion engine analyzes this data and generates a numerical emotion score.

[1489] Input: facial expression data, voice tone data

[1490] Output: Numerical sentiment score

[1491] Step 3:

[1492] The server stores the risk profile information and emotion score in a database and sends it to the AI ​​for analysis, which then generates a prompt as data necessary for analysis.

[1493] Input: Risk profile information, sentiment score

[1494] Output: Prompt and data sent to the generation AI

[1495] Step 4:

[1496] The generation AI performs data analysis based on the received risk profile information and emotion scores. The analysis uses natural language processing technology and machine learning algorithms to select the plan that best suits the user's needs. The generation AI then returns the selection results to the server.

[1497] Input: prompt statement, risk profile information, sentiment score

[1498] Output: The optimal plan sent back to the server

[1499] Step 5:

[1500] The server displays the plan returned by the generation AI on the user's smartphone. The user can review the plan and customize it as needed. During the customization process, the emotion engine analyzes the user's reactions and adjusts the plan accordingly.

[1501] Input: Plan selected by the generation AI, user's reaction (facial expression, voice)

[1502] Output: A plan customized by the user

[1503] Step 6:

[1504] Once the user has finalized the customized plan to their satisfaction, the information is sent to the server, which stores the finalized information in a database and sends it to the relevant systems.

[1505] Input: Customized Plan

[1506] Output: Finalized plan stored in database, plan sent to relevant systems

[1507] Step 7:

[1508] The server notifies the user of the completion of the application via email or the app's notification function.

[1509] Input: Confirmed plan information

[1510] Output: Completion notification sent to the user

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

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

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

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

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

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

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

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

[1519] The emotion map defines two emotions that promote learning. One is a negative emotion on the situation side, around the middle of "repentance" or "reflection." In other words, this occurs when the robot experiences negative emotions such as "I never want to feel this way again" or "I don't want to be scolded again." The other is a positive emotion on the response side, around "desire." In other words, this occurs when the robot experiences positive feelings such as "I want more" or "I want to know more."

[1520] The emotion identification model 59 inputs user input into a pre-trained neural network, obtains emotion values ​​indicating each emotion shown in the emotion map 400, and determines the user's emotion. This neural network is pre-trained based on multiple pieces of training data that are combinations of user input and emotion values ​​indicating each emotion shown in the emotion map 400. Furthermore, this neural network is trained so that emotions that are located close to each other have similar values, as in the emotion map 900 shown in FIG. 10. FIG. 10 shows an example in which multiple emotions, "relieved," "calm," and "reassuring," have similar emotion values.

[1521] The system according to the present disclosure has been described above mainly with respect to the functions of the data processing device 12, but the system according to the present disclosure is not necessarily implemented on a server. The system according to the present disclosure may be implemented as a general information processing system. The present disclosure may be implemented, for example, as a software program running on a personal computer or an application running on a smartphone, etc. The method according to the present disclosure may be provided to users in the form of SaaS (Software as a Service).

[1522] In the above embodiment, an example was given in which the specific processing is performed by one computer 22, but the technology of the present disclosure is not limited to this, and the specific processing may be distributed and performed by a plurality of computers including the computer 22. For example, the data generation model 58 may be provided in an external device of the data processing device 12, and data may be generated in the external device in accordance with input data.

[1523] In the above embodiment, an example in which the specific processing program 56 is stored in the storage 32 has been described, but the technology of the present disclosure is not limited to this. For example, the specific processing program 56 may be stored in a portable, computer-readable, non-transitory storage medium such as a USB (Universal Serial Bus) memory. The specific processing program 56 stored in the non-transitory storage medium is installed in the computer 22 of the data processing device 12. The processor 28 executes the specific processing in accordance with the specific processing program 56.

[1524] Alternatively, the specific processing program 56 may be stored in a storage device such as a server connected to the data processing device 12 via the network 54, and the specific processing program 56 may be downloaded and installed on the computer 22 in response to a request from the data processing device 12.

[1525] It is not necessary to store all of the specific processing program 56 in a storage device such as a server connected to the data processing device 12 via the network 54, or to store all of the specific processing program 56 in the storage 32; only a portion of the specific processing program 56 may be stored.

[1526] The hardware resource for executing a specific process can be any of the following processors: An example of a processor is a CPU, which is a general-purpose processor that functions as a hardware resource for executing a specific process by executing software, i.e., a program. Another example of a processor is a dedicated electrical circuit, such as an FPGA (Field-Programmable Gate Array), a PLD (Programmable Logic Device), or an ASIC (Application Specific Integrated Circuit), which is a processor with a circuit configuration designed specifically for executing a specific process. Each processor has built-in or connected memory, and each processor uses the memory to execute the specific process.

[1527] The hardware resource that executes the specific processing may be configured with one of these various processors, or may be configured with a combination of two or more processors of the same or different types (for example, a combination of multiple FPGAs, or a combination of a CPU and an FPGA). Also, the hardware resource that executes the specific processing may be a single processor.

[1528] As an example of a system configured with a single processor, first, one processor is configured by combining one or more CPUs and software, and this processor functions as a hardware resource that executes a specific process. Second, there is a system that uses a processor that realizes the functions of an entire system including multiple hardware resources that execute a specific process on a single IC chip, as typified by SoC (System-on-a-chip). In this way, a specific process is realized using one or more of the above-mentioned various processors as hardware resources.

[1529] Furthermore, the hardware structure of these various processors can be, more specifically, an electric circuit that combines circuit elements such as semiconductor devices. The specific processing described above is merely an example. Therefore, it goes without saying that unnecessary steps may be deleted, new steps may be added, or the processing order may be rearranged, without departing from the spirit of the invention.

[1530] The above-described description and illustrations are a detailed explanation of the parts related to the technology of the present disclosure and are merely an example of the technology of the present disclosure. For example, the above description of the configuration, functions, actions, and effects is an explanation of an example of the configuration, functions, actions, and effects of the parts related to the technology of the present disclosure. Therefore, it goes without saying that unnecessary parts may be deleted, new elements may be added, or replacements may be made to the above-described description and illustrations within the scope of the gist of the technology of the present disclosure. Furthermore, to avoid confusion and facilitate understanding of the parts related to the technology of the present disclosure, the above-described description and illustrations omit explanations of common technical knowledge that do not require particular explanation to enable the implementation of the technology of the present disclosure.

[1531] All publications, patent applications, and technical standards mentioned in this specification are herein incorporated by reference to the same extent as if each individual publication, patent application, or technical standard was specifically and individually indicated to be incorporated by reference.

[1532] The following is further disclosed regarding the above embodiment.

[1533] (Claim 1)

[1534] a means for a user to input risk profile information;

[1535] a server receiving the risk profile information and storing it in a database;

[1536] A server sends the risk profile information to the artificial intelligence generator;

[1537] A means for a generating artificial intelligence to analyze the risk profile information and select an appropriate insurance plan;

[1538] A means for returning the insurance plan selected by the generating artificial intelligence to the server;

[1539] means for the server to present the returned insurance plan to the user;

[1540] a means for the user to customize the insurance plan and finalize the insurance plan;

[1541] a means for the server to receive the confirmed insurance plan and store it in a database;

[1542] means for the server to transmit the confirmed insurance plan to the insurance company's system;

[1543] A means for the server to notify the user of completion of the insurance application;

[1544] A system including:

[1545] (Claim 2)

[1546] The system according to claim 1, wherein the generating artificial intelligence includes means for selecting an optimal insurance plan from a plurality of candidate insurance plans based on the risk profile information.

[1547] (Claim 3)

[1548] 10. The system of claim 1, wherein the server includes means for displaying a form to a user for inputting risk profile information.

[1549] "Example 1"

[1550] (Claim 1)

[1551] a means for a user to input risk profile information;

[1552] a server receiving the risk profile information and storing it in a database;

[1553] A server sends the risk profile information to the artificial intelligence generator;

[1554] A generating artificial intelligence analyzes the risk profile information and selects an optimal insurance plan;

[1555] A means for returning the insurance plan selected by the generating artificial intelligence to the server;

[1556] means for the server to present the returned insurance plan to the user;

[1557] a means for the user to customize the insurance plan and finalize the insurance plan;

[1558] a means for the server to receive the confirmed insurance plan and store it in a database;

[1559] means for the server to transmit the confirmed insurance plan to the insurance company's system;

[1560] A means for the server to notify the user of completion of the insurance application;

[1561] A system including:

[1562] (Claim 2)

[1563] The system according to claim 1, wherein the generating artificial intelligence includes means for selecting an optimal insurance plan from a plurality of candidate insurance plans based on the risk profile information.

[1564] (Claim 3)

[1565] 10. The system of claim 1, wherein the server includes means for displaying an interactive form to a user for inputting risk profile information.

[1566] "Application Example 1"

[1567] (Claim 1)

[1568] a means for a user to input risk profile information;

[1569] a server receiving the risk profile information and storing it in a database;

[1570] A server sends the risk profile information to the artificial intelligence generator;

[1571] A generating artificial intelligence analyzes the risk profile information and selects an appropriate security plan;

[1572] A means for returning the security plan selected by the generating artificial intelligence to the server;

[1573] means for the server to present the returned security plan to the user;

[1574] a means for a user to customize and finalize a security plan;

[1575] a means for the server to receive the finalized security plan and store it in a database;

[1576] A means for the server to transmit the confirmed security plan to a system of a security company;

[1577] a means by which the server notifies the user of the completion of the security plan;

[1578] A system including:

[1579] (Claim 2)

[1580] 2. The system according to claim 1, wherein the generating artificial intelligence includes means for selecting an optimal security plan from a plurality of candidate security plans based on the risk profile information.

[1581] (Claim 3)

[1582] 10. The system of claim 1, wherein the server includes means for displaying a form to a user for inputting risk profile information.

[1583] "Example 2: Combining Emotion Engines"

[1584] (Claim 1)

[1585] a means for a user to input risk profile information;

[1586] a server receiving the risk profile information and storing it in a database;

[1587] A server sends the risk profile information to the artificial intelligence generator;

[1588] A means for a generating artificial intelligence to analyze the risk profile information and emotion data and select an appropriate insurance plan;

[1589] A means for returning the insurance plan selected by the generating artificial intelligence to the server;

[1590] means for the server to present the returned insurance plan to the user;

[1591] a means for the user to customize the insurance plan and finalize the insurance plan;

[1592] a means for the server to receive the confirmed insurance plan and store it in a database;

[1593] means for the server to transmit the confirmed insurance plan to the provider's system;

[1594] A means for the server to notify the user of completion of the insurance application;

[1595] a means for the emotion engine to collect and analyze emotion data from the user's facial expressions and voice tone;

[1596] means for transmitting the emotion data analyzed by the emotion engine to a server;

[1597] A system including:

[1598] (Claim 2)

[1599] The system according to claim 1, wherein the generative artificial intelligence includes means for selecting an optimal insurance plan from a plurality of candidate insurance plans based on the risk profile information and emotion data.

[1600] (Claim 3)

[1601] 10. The system of claim 1, wherein the server includes means for displaying a form to a user for inputting risk profile information.

[1602] "Application example 2 when combining emotion engines"

[1603] (Claim 1)

[1604] a means for a user to input risk profile information;

[1605] a server receiving the risk profile information and storing it in a database;

[1606] A server collects and receives emotion data in addition to the risk profile information;

[1607] means including an emotion engine for analyzing sensor data of the smart device to generate emotion data;

[1608] A server sends the risk profile information and emotion data to the AI ​​generator;

[1609] A generating artificial intelligence analyzes the risk profile information and emotion data and selects an appropriate plan;

[1610] A means for returning the plan selected by the generating artificial intelligence to the server;

[1611] means for the server to present the returned plan to the user;

[1612] a means for the user to customize the plan and finalize the plan;

[1613] a means for the server to receive the finalized plan and store it in a database;

[1614] means for the server to transmit the finalized plan to the associated systems;

[1615] A means for the server to notify the user of completion of the application;

[1616] A system including:

[1617] (Claim 2)

[1618] 2. The system according to claim 1, wherein the generating artificial intelligence includes means for selecting an optimal plan from a plurality of candidate plans based on the risk profile information and emotion data.

[1619] (Claim 3)

[1620] 10. The system of claim 1, wherein the server includes means for displaying to the user a form for inputting risk profile information and emotional data. [Explanation of symbols]

[1621] 10, 210, 310, 410 Data Processing Systems 12 Data Processing Device 14 Smart Devices 214 Smart Glasses 314 Headset-type terminal 414 Robot< / url:> < / url:> < / url:> < / url:>

Claims

1. a means for a user to input risk profile information; a server receiving the risk profile information and storing it in a database; A server sends the risk profile information to the artificial intelligence generator; A means for a generating artificial intelligence to analyze the risk profile information and select an appropriate insurance plan; A means for returning the insurance plan selected by the generating artificial intelligence to the server; means for the server to present the returned insurance plan to the user; a means for the user to customize the insurance plan and finalize the insurance plan; a means for the server to receive the confirmed insurance plan and store it in a database; means for the server to transmit the confirmed insurance plan to the insurance company's system; A means for the server to notify the user of completion of the insurance application; A system including:

2. The system according to claim 1, wherein the artificial intelligence generator includes means for selecting an optimal insurance plan from a plurality of candidate insurance plans based on the risk profile information.

3. 2. The system of claim 1, wherein the server includes means for displaying a form to a user for inputting risk profile information.

Images